diff options
303 files changed, 7854 insertions, 9362 deletions
diff --git a/include/access.h b/include/access.h index 558dbeb5c..918dd7be6 100644 --- a/include/access.h +++ b/include/access.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef ACCESS_H @@ -25,19 +24,25 @@ enum ACCESS_FOUNDER = 10001 }; +/* A privilege, probably configured using a privilege{} block. Most + * commands require specific privileges to be executed. The AccessProvider + * backing each ChanAccess determines whether that ChanAccess has a given + * privilege. + */ struct CoreExport Privilege { Anope::string name; Anope::string desc; + /* Rank relative to other privileges */ int rank; - Privilege(const Anope::string &n, const Anope::string &d, int r); + Privilege(const Anope::string &name, const Anope::string &desc, int rank); bool operator==(const Privilege &other) const; }; class CoreExport PrivilegeManager { - static std::vector<Privilege> privs; + static std::vector<Privilege> Privileges; public: static void AddPrivilege(Privilege p); static void RemovePrivilege(Privilege &p); @@ -46,25 +51,34 @@ class CoreExport PrivilegeManager static void ClearPrivileges(); }; - +/* A provider of access. Only used for creating ChanAccesses, as + * they contain pure virtual functions. + */ class CoreExport AccessProvider : public Service { public: - AccessProvider(Module *o, const Anope::string &n); + AccessProvider(Module *owner, const Anope::string &name); virtual ~AccessProvider(); + + /** Creates a new ChanAccess entry using this provider. + * @return The new entry + */ virtual ChanAccess *Create() = 0; private: - static std::list<AccessProvider *> providers; + static std::list<AccessProvider *> Providers; public: static const std::list<AccessProvider *>& GetProviders(); }; +/* Represents one entry of an access list on a channel. */ class CoreExport ChanAccess : public Serializable { public: + /* The provider that created this access entry */ AccessProvider *provider; - serialize_obj<ChannelInfo> ci; + /* Channel this access entry is on */ + Serialize::Reference<ChannelInfo> ci; Anope::string mask; Anope::string creator; time_t last_seen; @@ -73,29 +87,69 @@ class CoreExport ChanAccess : public Serializable ChanAccess(AccessProvider *p); virtual ~ChanAccess(); - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); + /** Check if this access entry matches the given user or account + * @param u The user + * @param nc The account + */ virtual bool Matches(const User *u, const NickCore *nc) const; + + /** Check if this access entry has the given privilege. + * @param name The privilege name + */ virtual bool HasPriv(const Anope::string &name) const = 0; - virtual Anope::string Serialize() const = 0; - virtual void Unserialize(const Anope::string &data) = 0; + /** Serialize the access given by this access entry into a human + * readable form. chanserv/access will return a number, chanserv/xop + * will be AOP, SOP, etc. + */ + virtual Anope::string AccessSerialize() const = 0; + + /** Unserialize this access entry from the given data. This data + * will be fetched from AccessSerialize. + */ + virtual void AccessUnserialize(const Anope::string &data) = 0; + + /* Comparison operators to other Access entries */ bool operator>(const ChanAccess &other) const; bool operator<(const ChanAccess &other) const; bool operator>=(const ChanAccess &other) const; bool operator<=(const ChanAccess &other) const; }; +/* A group of access entries. This is used commonly, for example with ChannelInfo::AccessFor, + * to show what access a user has on a channel because users can match multiple access entries. + */ class CoreExport AccessGroup : public std::vector<ChanAccess *> { public: + /* Channel these access entries are on */ const ChannelInfo *ci; + /* Account these entries affect, if any */ const NickCore *nc; - bool SuperAdmin, Founder; + /* super_admin always gets all privs. founder is a special case where ci->founder == nc */ + bool super_admin, founder; + AccessGroup(); + + /** Check if this access group has a certain privilege. Eg, it + * will check every ChanAccess entry of this group for any that + * has the given privilege. + * @param priv The privilege + * @return true if any entry has the given privilege + */ bool HasPriv(const Anope::string &priv) const; + + /** Get the "highest" access entry from this group of entries. + * The highest entry is determined by the entry that has the privilege + * with the highest rank (see Privilege::rank). + * @return The "highest" entry + */ const ChanAccess *Highest() const; + + /* Comparison operators to other AccessGroups */ bool operator>(const AccessGroup &other) const; bool operator<(const AccessGroup &other) const; bool operator>=(const AccessGroup &other) const; diff --git a/include/account.h b/include/account.h index 8ed1f06a4..a45bf8c90 100644 --- a/include/account.h +++ b/include/account.h @@ -7,8 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. - * - * + * */ #ifndef ACCOUNT_H @@ -23,10 +22,8 @@ typedef Anope::hash_map<NickAlias *> nickalias_map; typedef Anope::hash_map<NickCore *> nickcore_map; -extern CoreExport serialize_checker<nickalias_map> NickAliasList; -extern CoreExport serialize_checker<nickcore_map> NickCoreList; - -/* NickServ nickname structures. */ +extern CoreExport Serialize::Checker<nickalias_map> NickAliasList; +extern CoreExport Serialize::Checker<nickcore_map> NickCoreList; /** Flags set on NickAliases */ @@ -50,10 +47,6 @@ enum NickNameFlag NS_END }; -const Anope::string NickNameFlagStrings[] = { - "BEGIN", "NO_EXPIRE", "HELD", "COLLIDED", "" -}; - /** Flags set on NickCores */ enum NickCoreFlag @@ -101,40 +94,36 @@ enum NickCoreFlag NI_END }; -const Anope::string NickCoreFlagStrings[] = { - "BEGIN", "KILLPROTECT", "SECURE", "MSG", "MEMO_HARDMAX", "MEMO_SIGNON", "MEMO_RECEIVE", - "PRIVATE", "HIDE_EMAIL", "HIDE_MASK", "HIDE_QUIT", "KILL_QUICK", "KILL_IMMED", - "MEMO_MAIL", "HIDE_STATUS", "SUSPENDED", "AUTOOP", "UNCONFIRMED", "STATS", "" -}; - -/* It matters that Base is here before Extensible (it is inherited by Serializable) */ -class CoreExport NickAlias : public Serializable, public Extensible, public Flags<NickNameFlag, NS_END> +/* A registered nickname. + * It matters that Base is here before Extensible (it is inherited by Serializable) + */ +class CoreExport NickAlias : public Serializable, public Extensible, public Flags<NickNameFlag> { Anope::string vhost_ident, vhost_host, vhost_creator; time_t vhost_created; public: - /** Default constructor + Anope::string nick; + Anope::string last_quit; + Anope::string last_realname; + /* Last usermask this nick was seen on, eg user@host */ + Anope::string last_usermask; + /* Last uncloaked usermask, requires nickserv/auspex to see */ + Anope::string last_realhost; + time_t time_registered; + time_t last_seen; + /* Account this nick is tied to. Multiple nicks can be tied to a single account. */ + Serialize::Reference<NickCore> nc; + + /** Constructor * @param nickname The nick * @param nickcore The nickcore for this nick */ NickAlias(const Anope::string &nickname, NickCore *nickcore); - - /** Default destructor - */ ~NickAlias(); - Anope::string nick; /* Nickname */ - Anope::string last_quit; /* Last quit message */ - Anope::string last_realname; /* Last realname */ - Anope::string last_usermask; /* Last usermask */ - Anope::string last_realhost; /* Last uncloaked usermask, requires nickserv/auspex to see */ - time_t time_registered; /* When the nick was registered */ - time_t last_seen; /* When it was seen online for the last time */ - serialize_obj<NickCore> nc; /* I'm an alias of this */ - - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); /** Release a nick * See the comment in users.cpp @@ -184,41 +173,67 @@ class CoreExport NickAlias : public Serializable, public Extensible, public Flag * @return the time it was created */ time_t GetVhostCreated() const; + + /** Finds a registered nick + * @param nick The nick to lookup + * @return the nick, if found + */ + static NickAlias *Find(const Anope::string &nick); }; -/* It matters that Base is here before Extensible (it is inherited by Serializable) */ -class CoreExport NickCore : public Serializable, public Extensible, public Flags<NickCoreFlag, NI_END> +/* A registered account. Each account must have a NickAlias with the same nick as the + * account's display. + * It matters that Base is here before Extensible (it is inherited by Serializable) + */ +class CoreExport NickCore : public Serializable, public Extensible, public Flags<NickCoreFlag> { public: - /** Default constructor - * @param display The display nick - */ - NickCore(const Anope::string &nickdisplay); + /* Name of the account. Find(display)->nc == this. */ + Anope::string display; + /* User password in form of hashm:data */ + Anope::string pass; + Anope::string email; + /* Greet associated with the account, sometimes sent when the user joins a channel */ + Anope::string greet; + /* Locale name of the language of the user. Empty means default language */ + Anope::string language; + /* Access list, contains user@host masks of users who get certain privileges based + * on if NI_SECURE is set and what (if any) kill protection is enabled. */ + std::vector<Anope::string> access; + /* SSL certificate list. Users who have a matching certificate may be automatically logged in */ + std::vector<Anope::string> cert; + MemoInfo memos; - /** Default destructor + /* Nicknames registered that are grouped to this account. + * for n in aliases, n->nc == this. */ - ~NickCore(); - - std::list<User *> Users; - - Anope::string display; /* How the nick is displayed */ - Anope::string pass; /* Password of the nicks */ - Anope::string email; /* E-mail associated to the nick */ - Anope::string greet; /* Greet associated to the nick */ - Anope::string language; /* Language name */ - std::vector<Anope::string> access; /* Access list, vector of strings */ - std::vector<Anope::string> cert; /* ssl certificate list, vector of strings */ - MemoInfo memos; + std::list<Serialize::Reference<NickAlias> > aliases; + /* Set if this user is a services operattor. o->ot must exist. */ Oper *o; /* Unsaved data */ - uint16_t channelcount; /* Number of channels currently registered */ - time_t lastmail; /* Last time this nick record got a mail */ - std::list<serialize_obj<NickAlias> > aliases; /* List of aliases */ - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + /* Number of channels registered by this account */ + uint16_t channelcount; + /* Last time an email was sent to this user */ + time_t lastmail; + /* Users online now logged into this account */ + std::list<User *> users; + + /** Constructor + * @param display The display nick + */ + NickCore(const Anope::string &nickdisplay); + ~NickCore(); + + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); + + /** Changes the display for this account + * @param na The new display, must be grouped to this account. + */ + void SetDisplay(const NickAlias *na); /** Checks whether this account is a services oper or not. * @return True if this account is a services oper, false otherwise. @@ -265,6 +280,14 @@ class CoreExport NickCore : public Serializable, public Extensible, public Flags */ void ClearAccess(); + /** Is the given user on this accounts access list? + * + * @param u The user + * + * @return true if the user is on the access list + */ + bool IsOnAccess(const User *u) const; + /** Add an entry to the nick's certificate list * * @param entry The fingerprint to add to the cert list @@ -304,10 +327,21 @@ class CoreExport NickCore : public Serializable, public Extensible, public Flags * Deletes all the memory allocated in the certificate list vector and then clears the vector. */ void ClearCert(); + + /** Finds an account + * @param nick The account name to find + * @return The account, if it exists + */ + static NickCore* Find(const Anope::string &nick); }; +/* A request to check if an account/password is valid. These can exist for + * extended periods of time due to some authentication modules take. + */ class CoreExport IdentifyRequest { + /* Owner of this request, used to cleanup requests if a module is unloaded + * while a reqyest us pending */ Module *owner; Anope::string account; Anope::string password; @@ -316,35 +350,47 @@ class CoreExport IdentifyRequest bool dispatched; bool success; - static std::set<IdentifyRequest *> requests; + static std::set<IdentifyRequest *> Requests; protected: IdentifyRequest(Module *o, const Anope::string &acc, const Anope::string &pass); virtual ~IdentifyRequest(); public: + /* One of these is called when the request goes through */ virtual void OnSuccess() = 0; virtual void OnFail() = 0; const Anope::string &GetAccount() const { return account; } const Anope::string &GetPassword() const { return password; } - /* Hold this request. Once held it must be Release()d later on */ + /* Holds this request. When a request is held it must be Released later + * for the request to complete. Multiple modules may hold a request at any time, + * but the request is not complete until every module has released it. If you do not + * require holding this (eg, your password check is done in this thread and immediately) + * then you don't need to hold the request before Successing it. + * @param m The module holding this request + */ void Hold(Module *m); + + /** Releases a held request + * @param m The module releaseing the hold + */ void Release(Module *m); + /** Called by modules when this IdentifyRequest has successeded successfully. + * If this request is behind held it must still be Released after calling this. + * @param m The module confirming authentication + */ void Success(Module *m); + /** Used to either finalize this request or marks + * it as dispatched and begins waiting for the module(s) + * that have holds to finish. + */ void Dispatch(); static void ModuleUnload(Module *m); }; -extern CoreExport void change_core_display(NickCore *nc); -extern CoreExport void change_core_display(NickCore *nc, const Anope::string &newdisplay); - -extern CoreExport NickAlias *findnick(const Anope::string &nick); -extern CoreExport NickCore *findcore(const Anope::string &nick); -extern CoreExport bool is_on_access(const User *u, const NickCore *nc); - #endif // ACCOUNT_H diff --git a/include/anope.h b/include/anope.h index b6033b15c..2dda6cf76 100644 --- a/include/anope.h +++ b/include/anope.h @@ -1,4 +1,5 @@ /* + * * (C) 2003-2012 Anope Team * Contact us at team@anope.org * @@ -6,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #ifndef ANOPE_H @@ -304,11 +306,52 @@ namespace Anope static const char *const compiled = __TIME__ " " __DATE__; + /** The time Anope started. + */ + extern time_t StartTime; + + /** The value to return from main() + */ + extern int ReturnValue; + extern bool Quitting; + extern bool Restarting; + extern Anope::string QuitReason; + /** The current system time, which is pretty close to being accurate. * Use this unless you need very specific time checks */ extern CoreExport time_t CurTime; + /** The debug level we are running at. + */ + extern int Debug; + + /** Other comand line options. + */ + extern bool ReadOnly, NoFork, NoThird, NoExpire, ProtocolDebug; + + /** The root of the services installation. Usually ~/services + */ + extern Anope::string ServicesDir; + + /** Services binary name (eg services) + */ + extern Anope::string ServicesBin; + + /** Various directory paths. These can be set at runtime by command line args + */ + extern Anope::string ConfigDir; + extern Anope::string DataDir; + extern Anope::string ModuleDir; + extern Anope::string LocaleDir; + extern Anope::string LogDir; + + /** The uplink we are currently connected to + */ + extern int CurrentUplink; + + /** Various methods to determine the Anope version running + */ extern CoreExport string Version(); extern CoreExport string VersionShort(); extern CoreExport string VersionBuildString(); @@ -316,6 +359,29 @@ namespace Anope extern CoreExport int VersionMinor(); extern CoreExport int VersionPatch(); + /** Determines if we are still attached to the terminal, and can print + * messages to the user via stderr/stdout. + * @return true if still attached + */ + extern bool AtTerm(); + + /** Used to "fork" the process and go into the background during initial startup + * while we are AtTerm(). The actual fork is not done here, but earlier, and this + * simply notifys the parent via kill() to exit(). + */ + extern void Fork(); + + /** One of the first functions called, does general initialization such as reading + * command line args, loading the configuration, doing the initial fork() if necessary, + * initializating language support, loading modules, and loading databases. + * @throws CoreException if something bad went wrong + */ + extern void Init(int ac, char **av); + + /** Calls the save database event + */ + extern void SaveDatabases(); + /** Check whether two strings match. * @param str The string to check against the pattern (e.g. foobar) * @param mask The pattern to check (e.g. foo*bar) @@ -350,6 +416,20 @@ namespace Anope */ extern CoreExport void B64Decode(const string &src, string &target); + /** Encrypts what is in 'src' to 'dest' + * @param src The source string to encrypt + * @param dest The destination where the encrypted string is placed + */ + extern void Encrypt(const Anope::string &src, Anope::string &dest); + + /** Decrypts what is in 'src' to 'dest'. + * @param src The source string to decrypt + * @param dest The destination where the decrypted string is placed + * @return true if decryption was successful. This is usually not the case + * as most encryption methods we use are one way. + */ + extern bool Decrypt(const Anope::string &src, Anope::string &dest); + /** Returns a sequence of data formatted as the format argument specifies. ** After the format parameter, the function expects at least as many ** additional arguments as specified in format. @@ -368,6 +448,48 @@ namespace Anope * @return An error message */ extern CoreExport const string LastError(); + + /** Determines if a path is a file + */ + extern bool IsFile(const Anope::string &file); + + /** Converts a string into seconds + * @param s The string, eg 3d + * @return The time represented by the string, eg 259,200 + */ + extern time_t DoTime(const Anope::string &s); + + /** Retrieves a human readable string representing the time in seconds + * @param seconds The time on seconds, eg 60 + * @param nc The account to use langauge settings for to translate this string, if applicable + * @return A human readable string, eg "1 minute" + */ + extern Anope::string Duration(time_t seconds, const NickCore *nc = NULL); + + /** Generates a human readable string of type "expires in ..." + * @param expires time in seconds + * @param nc The account to use langauge settings for to translate this string, if applicable + * @return A human readable string, eg "expires in 5 days" + */ + extern Anope::string Expires(time_t seconds, const NickCore *nc = NULL); + + /** Converts a time in seconds (epoch) to a human readable format. + * @param t The time + * @param nc The account to use langauge settings for to translate this string, if applicable + * @param short_output If true, the output is just a date (eg, "Apr 12 20:18:22 2009 MSD"), else it includes the date and how long ago/from now that date is, (eg "Apr 12 20:18:22 2009 MSD (1313 days, 9 hours, 32 minutes ago)" + */ + extern Anope::string strftime(time_t t, const NickCore *nc = NULL, bool short_output = false); + + /** Normalize buffer, stripping control characters and colors + * @param A string to be parsed for control and color codes + * @return A string stripped of control and color codes + */ + extern Anope::string NormalizeBuffer(const Anope::string &); + + /** Main processing routine. Parses the message and takes the appropriate action. + * @param Raw message from the uplink + */ + extern void Process(const Anope::string &); } /** sepstream allows for splitting token seperated lists. @@ -394,23 +516,52 @@ class CoreExport sepstream /** Create a sepstream and fill it with the provided data */ sepstream(const Anope::string &source, char seperator); - virtual ~sepstream() { } /** Fetch the next token from the stream * @param token The next token from the stream is placed here * @return True if tokens still remain, false if there are none left */ - virtual bool GetToken(Anope::string &token); + bool GetToken(Anope::string &token); + + /** Gets token number 'num' from the stream + * @param token The token is placed here + * @param num The token number to featch + * @return True if the token was able to be detched + */ + bool GetToken(Anope::string &token, int num); + + /** Gets every token from this stream + * @param token Tokens are pushed back here + */ + template<typename T> void GetTokens(T& token) + { + token.clear(); + Anope::string t; + while (this->GetToken(t)) + token.push_back(t); + } + + /** Gets token number 'num' from the stream and all remaining tokens. + * @param token The token is placed here + * @param num The token number to featch + * @return True if the token was able to be detched + */ + bool GetTokenRemainder(Anope::string &token, int num); + + /** Determines the number of tokens in this stream. + * @return The number of tokens in this stream + */ + int NumTokens(); /** Fetch the entire remaining stream, without tokenizing * @return The remaining part of the stream */ - virtual const Anope::string GetRemaining(); + const Anope::string GetRemaining(); /** Returns true if the end of the stream has been reached * @return True if the end of the stream has been reached, otherwise false */ - virtual bool StreamEnd(); + bool StreamEnd(); }; /** A derived form of sepstream, which seperates on commas @@ -478,14 +629,6 @@ class CoreException : public std::exception } }; -class FatalException : public CoreException -{ - public: - FatalException(const Anope::string &reason = "") : CoreException(reason) { } - - virtual ~FatalException() throw() { } -}; - class ModuleException : public CoreException { public: @@ -600,39 +743,43 @@ template<typename T, typename O> inline T anope_dynamic_reinterpret_cast(O ptr) /** Class with the ability to keep flags on items, they should extend from this * where T is an enum. */ -template<typename T, size_t Size = 32> class Flags +template<typename T> class Flags { - protected: - std::bitset<Size> Flag_Values; - const Anope::string *Flag_Strings; + std::vector<bool> flags_values; + static const Anope::string *flags_strings; public: - Flags() : Flag_Strings(NULL) { } - Flags(const Anope::string *flag_strings) : Flag_Strings(flag_strings) { } - /** Add a flag to this item - * @param Value The flag + * @param value The flag */ - void SetFlag(T Value) + void SetFlag(T value) { - Flag_Values[Value] = true; + if (value < 0) + return; + + if (static_cast<unsigned>(value) >= flags_values.size()) + flags_values.resize(value + 1); + flags_values[value] = true; } /** Remove a flag from this item - * @param Value The flag + * @param value The flag */ - void UnsetFlag(T Value) + void UnsetFlag(T value) { - Flag_Values[Value] = false; + if (value >= 0 && static_cast<unsigned>(value) < flags_values.size()) + flags_values[value] = false; } /** Check if this item has a flag - * @param Value The flag + * @param value The flag * @return true or false */ - bool HasFlag(T Value) const + bool HasFlag(T value) const { - return Flag_Values.test(Value); + if (value >= 0 && static_cast<unsigned>(value) < flags_values.size()) + return flags_values[value]; + return false; } /** Check how many flags are set @@ -640,14 +787,23 @@ template<typename T, size_t Size = 32> class Flags */ size_t FlagCount() const { - return Flag_Values.count(); + size_t c = 0; + for (unsigned i = 0; i < flags_values.size(); ++i) + if (flags_values[i]) + ++c; + return c; } /** Unset all of the flags */ void ClearFlags() { - Flag_Values.reset(); + flags_values.clear(); + } + + static const Anope::string* GetFlagStrings() + { + return flags_strings; } Anope::string ToString() const @@ -675,9 +831,9 @@ template<typename T, size_t Size = 32> class Flags std::vector<Anope::string> ToVector() const { std::vector<Anope::string> ret; - for (unsigned i = 0; this->Flag_Strings && !this->Flag_Strings[i].empty(); ++i) + for (unsigned i = 0; this->flags_strings && !this->flags_strings[i].empty(); ++i) if (this->HasFlag(static_cast<T>(i))) - ret.push_back(this->Flag_Strings[i]); + ret.push_back(this->flags_strings[i]); return ret; } @@ -685,9 +841,9 @@ template<typename T, size_t Size = 32> class Flags { this->ClearFlags(); - for (unsigned i = 0; this->Flag_Strings && !this->Flag_Strings[i].empty(); ++i) + for (unsigned i = 0; this->flags_strings && !this->flags_strings[i].empty(); ++i) for (unsigned j = 0; j < strings.size(); ++j) - if (this->Flag_Strings[i] == strings[j]) + if (this->flags_strings[i] == strings[j]) this->SetFlag(static_cast<T>(i)); } }; diff --git a/include/base.h b/include/base.h index c09b97400..178bb1937 100644 --- a/include/base.h +++ b/include/base.h @@ -4,6 +4,7 @@ * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #ifndef BASE_H @@ -16,48 +17,57 @@ class CoreExport Base { /* References to this base class */ - std::set<dynamic_reference_base *> References; + std::set<ReferenceBase *> references; public: Base(); virtual ~Base(); - void AddReference(dynamic_reference_base *r); - void DelReference(dynamic_reference_base *r); + + /** Adds a reference to this object. Eg, when a Reference + * is created referring to this object this is called. It is used to + * cleanup references when this object is destructed. + */ + void AddReference(ReferenceBase *r); + + void DelReference(ReferenceBase *r); }; -class dynamic_reference_base +class ReferenceBase { protected: bool invalid; public: - dynamic_reference_base() : invalid(false) { } - dynamic_reference_base(const dynamic_reference_base &other) : invalid(other.invalid) { } - virtual ~dynamic_reference_base() { } + ReferenceBase() : invalid(false) { } + ReferenceBase(const ReferenceBase &other) : invalid(other.invalid) { } + virtual ~ReferenceBase() { } inline void Invalidate() { this->invalid = true; } }; +/** Used to hold pointers to objects that may be deleted. A Reference will + * no longer be valid once the object it refers is destructed. + */ template<typename T> -class dynamic_reference : public dynamic_reference_base +class Reference : public ReferenceBase { protected: T *ref; public: - dynamic_reference() : ref(NULL) + Reference() : ref(NULL) { } - dynamic_reference(T *obj) : ref(obj) + Reference(T *obj) : ref(obj) { if (ref) ref->AddReference(this); } - dynamic_reference(const dynamic_reference<T> &other) : dynamic_reference_base(other), ref(other.ref) + Reference(const Reference<T> &other) : ReferenceBase(other), ref(other.ref) { if (operator bool()) ref->AddReference(this); } - virtual ~dynamic_reference() + virtual ~Reference() { if (operator bool()) ref->DelReference(this); @@ -105,12 +115,12 @@ class dynamic_reference : public dynamic_reference_base this->ref->AddReference(this); } - inline bool operator<(const dynamic_reference<T> &other) const + inline bool operator<(const Reference<T> &other) const { return this < &other; } - inline bool operator==(const dynamic_reference<T> &other) + inline bool operator==(const Reference<T> &other) { if (!this->invalid) return this->ref == other; diff --git a/include/bots.h b/include/bots.h index 888e8d217..3d44d08dd 100644 --- a/include/bots.h +++ b/include/bots.h @@ -1,8 +1,10 @@ /* + * * Copyright (C) 2008-2011 Robin Burchell <w00t@inspircd.org> * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #ifndef BOTS_H @@ -16,7 +18,7 @@ typedef Anope::map<BotInfo *> botinfo_map; -extern CoreExport serialize_checker<botinfo_map> BotListByNick, BotListByUID; +extern CoreExport Serialize::Checker<botinfo_map> BotListByNick, BotListByUID; /** Flags settable on a bot */ @@ -24,8 +26,6 @@ enum BotFlag { BI_BEGIN, - /* This bot is a core bot. NickServ, ChanServ, etc */ - BI_CORE, /* This bot can only be assigned by IRCops */ BI_PRIVATE, /* This bot is defined in the config */ @@ -34,17 +34,21 @@ enum BotFlag BI_END }; -static const Anope::string BotFlagString[] = { "BEGIN", "CORE", "PRIVATE", "CONF", "" }; - -class CoreExport BotInfo : public User, public Flags<BotFlag, BI_END>, public Serializable +/* A service bot (NickServ, ChanServ, a BotServ bot, etc). */ +class CoreExport BotInfo : public User, public Flags<BotFlag>, public Serializable { public: - time_t created; /* Birth date ;) */ - time_t lastmsg; /* Last time we said something */ - CommandInfo::map commands; /* Commands, actual name to service name */ - Anope::string botmodes; /* Modes the bot should have as configured in service:modes */ - std::vector<Anope::string> botchannels; /* Channels the bot should be in as configured in service:channels */ - bool introduced; /* Whether or not this bot is introduced */ + time_t created; + /* Last time this bot said something (via privmsg) */ + time_t lastmsg; + /* Map of actual command names -> service name/permission required */ + CommandInfo::map commands; + /* Modes the bot should have as configured in service:modes */ + Anope::string botmodes; + /* Channels the bot should be in as configured in service:channels */ + std::vector<Anope::string> botchannels; + /* Whether or not this bot is introduced to the network */ + bool introduced; /** Create a new bot. * @param nick The nickname to assign to the bot. @@ -59,8 +63,8 @@ class CoreExport BotInfo : public User, public Flags<BotFlag, BI_END>, public Se */ virtual ~BotInfo(); - Serialize::Data serialize() const; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); void GenerateUID(); @@ -126,11 +130,13 @@ class CoreExport BotInfo : public User, public Flags<BotFlag, BI_END>, public Se * @return A struct containing service name and permission */ CommandInfo *GetCommand(const Anope::string &cname); -}; -extern CoreExport BotInfo *findbot(const Anope::string &nick); - -extern CoreExport void bot_raw_ban(User *requester, ChannelInfo *ci, const Anope::string &nick, const Anope::string &reason); -extern CoreExport void bot_raw_kick(User *requester, ChannelInfo *ci, const Anope::string &nick, const Anope::string &reason); + /** Find a bot by nick + * @param nick The nick + * @param nick_only True to only look by nick, and not by UID + * @return The bot, if it exists + */ + static BotInfo* Find(const Anope::string &nick, bool nick_only = false); +}; #endif // BOTS_H diff --git a/include/botserv.h b/include/botserv.h deleted file mode 100644 index e5ef2c8ba..000000000 --- a/include/botserv.h +++ /dev/null @@ -1,79 +0,0 @@ -/* - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - * - * - */ - -#ifndef BOTSERV_H -#define BOTSERV_H - -#include "anope.h" - -/* BotServ SET flags */ -enum BotServFlag -{ - BS_BEGIN, - /* BotServ won't kick ops */ - BS_DONTKICKOPS, - /* BotServ won't kick voices */ - BS_DONTKICKVOICES, - /* BotServ bot accepts fantasy commands */ - BS_FANTASY, - /* BotServ should show greets */ - BS_GREET, - /* BotServ bots are not allowed to be in this channel */ - BS_NOBOT, - /* BotServ kicks for bolds */ - BS_KICK_BOLDS, - /* BotServ kicks for colors */ - BS_KICK_COLORS, - /* BOtServ kicks for reverses */ - BS_KICK_REVERSES, - /* BotServ kicks for underlines */ - BS_KICK_UNDERLINES, - /* BotServ kicks for badwords */ - BS_KICK_BADWORDS, - /* BotServ kicks for caps */ - BS_KICK_CAPS, - /* BotServ kicks for flood */ - BS_KICK_FLOOD, - /* BotServ kicks for repeating */ - BS_KICK_REPEAT, - /* BotServ kicks for italics */ - BS_KICK_ITALICS, - /* BotServ kicks for amsgs */ - BS_KICK_AMSGS, - BS_END -}; - -const Anope::string BotServFlagStrings[] = { - "BEGIN", "DONTKICKOPS", "DONTKICKVOICES", "FANTASY", "GREET", "NOBOT", - "KICK_BOLDs", "KICK_COLORS", "KICK_REVERSES", "KICK_UNDERLINES", "KICK_BADWORDS", "KICK_CAPS", - "KICK_FLOOD", "KICK_REPEAT", "KICK_ITALICS", "KICK_AMSGS", "MSG_PRIVMSG", "MSG_NOTICE", - "MSG_NOTICEOPS", "" -}; - -/* Indices for TTB (Times To Ban) */ -enum -{ - TTB_BOLDS, - TTB_COLORS, - TTB_REVERSES, - TTB_UNDERLINES, - TTB_BADWORDS, - TTB_CAPS, - TTB_FLOOD, - TTB_REPEAT, - TTB_ITALICS, - TTB_AMSGS, - TTB_SIZE -}; - -#endif // BOTSERV_H diff --git a/include/channels.h b/include/channels.h index 99ddf06b9..5cbea5ecc 100644 --- a/include/channels.h +++ b/include/channels.h @@ -4,6 +4,7 @@ * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ #ifndef CHANNELS_H @@ -18,10 +19,12 @@ typedef Anope::hash_map<Channel *> channel_map; extern CoreExport channel_map ChannelList; +/* A user container, there is one of these per user per channel. */ struct UserContainer : public Extensible { User *user; - ChannelStatus *Status; + /* Status the user has in the channel */ + ChannelStatus *status; UserContainer(User *u) : user(u) { } virtual ~UserContainer() { } @@ -39,9 +42,7 @@ enum ChannelFlag CH_SYNCING }; -const Anope::string ChannelFlagString[] = { "CH_INABIT", "CH_PERSIST", "CH_SYNCING", "" }; - -class CoreExport Channel : public virtual Base, public Extensible, public Flags<ChannelFlag, 3> +class CoreExport Channel : public Base, public Extensible, public Flags<ChannelFlag> { public: typedef std::multimap<ChannelModeName, Anope::string> ModeList; @@ -51,27 +52,27 @@ class CoreExport Channel : public virtual Base, public Extensible, public Flags< ModeList modes; public: - /** Default constructor - * @param name The channel name - * @param ts The time the channel was created - */ - Channel(const Anope::string &nname, time_t ts = Anope::CurTime); - - /** Default destructor - */ - ~Channel(); - - Anope::string name; /* Channel name */ - serialize_obj<ChannelInfo> ci; /* Corresponding ChannelInfo */ - time_t creation_time; /* When channel was created */ - - /* List of users in the channel */ + /* Channel name */ + Anope::string name; + /* Set if this channel is registered. ci->c == this. Contains information relevant to the registered channel */ + Serialize::Reference<ChannelInfo> ci; + /* When the channel was created */ + time_t creation_time; + + /* Users in the channel */ CUserList users; - Anope::string topic; /* Current topic of the channel */ - Anope::string topic_setter; /* Who set the topic */ - time_t topic_ts; /* The timestamp associated with the topic. Not necessarually anywhere close to Anope::CurTime */ - time_t topic_time; /* The actual time the topic was set, probably close to Anope::CurTime */ + /* Current topic of the channel */ + Anope::string topic; + /* Who set the topic */ + Anope::string topic_setter; + /* The timestamp associated with the topic. Not necessarually anywhere close to Anope::CurTime. + * This is the time the topic was *originally set*. When we restore the topic we want to change the TS back + * to this, but we can only do this on certain IRCds. + */ + time_t topic_ts; + /* The actual time the topic was set, probably close to Anope::CurTime */ + time_t topic_time; time_t server_modetime; /* Time of last server MODE */ time_t chanserv_modetime; /* Time of last check_modes() */ @@ -79,6 +80,16 @@ class CoreExport Channel : public virtual Base, public Extensible, public Flags< int16_t chanserv_modecount; /* Number of check_mode()'s this sec */ int16_t bouncy_modes; /* Did we fail to set modes here? */ + /** Constructor + * @param name The channel name + * @param ts The time the channel was created + */ + Channel(const Anope::string &nname, time_t ts = Anope::CurTime); + + /** Destructor + */ + ~Channel(); + /** Call if we need to unset all modes and clear all user status (internally). * Only useful if we get a SJOIN with a TS older than what we have here */ @@ -94,8 +105,9 @@ class CoreExport Channel : public virtual Base, public Extensible, public Flags< /** Join a user internally to the channel * @param u The user + * @return The UserContainer for the user */ - void JoinUser(User *u); + UserContainer* JoinUser(User *u); /** Remove a user internally from the channel * @param u The user @@ -118,94 +130,101 @@ class CoreExport Channel : public virtual Base, public Extensible, public Flags< /** Check if a user has a status on a channel * Use the overloaded function for ChannelModeStatus* to check for no status * @param u The user - * @param Name The Mode name, eg CMODE_OP, CMODE_VOICE + * @param name The mode name, eg CMODE_OP, CMODE_VOICE * @return true or false */ - bool HasUserStatus(const User *u, ChannelModeName Name) const; + bool HasUserStatus(const User *u, ChannelModeName name) const; /** See if a channel has a mode - * @param Name The mode name + * @param name The mode name * @return The number of modes set * @param param The optional mode param */ - size_t HasMode(ChannelModeName Name, const Anope::string ¶m = ""); + size_t HasMode(ChannelModeName name, const Anope::string ¶m = ""); /** Get a list of modes on a channel - * @param Name A mode name to get the list of + * @param name A mode name to get the list of * @return a pair of iterators for the beginning and end of the list */ - std::pair<ModeList::iterator, ModeList::iterator> GetModeList(ChannelModeName Name); + std::pair<ModeList::iterator, ModeList::iterator> GetModeList(ChannelModeName name); /** Set a mode internally on a channel, this is not sent out to the IRCd * @param setter The setter * @param cm The mode * @param param The param - * @param EnforceMLock true if mlocks should be enforced, false to override mlock + * @param enforce_mlock true if mlocks should be enforced, false to override mlock */ - void SetModeInternal(MessageSource &source, ChannelMode *cm, const Anope::string ¶m = "", bool EnforceMLock = true); + void SetModeInternal(MessageSource &source, ChannelMode *cm, const Anope::string ¶m = "", bool enforce_mlock = true); /** Remove a mode internally on a channel, this is not sent out to the IRCd * @param setter The Setter * @param cm The mode * @param param The param - * @param EnforceMLock true if mlocks should be enforced, false to override mlock + * @param enforce_mlock true if mlocks should be enforced, false to override mlock */ - void RemoveModeInternal(MessageSource &source, ChannelMode *cm, const Anope::string ¶m = "", bool EnforceMLock = true); + void RemoveModeInternal(MessageSource &source, ChannelMode *cm, const Anope::string ¶m = "", bool enforce_mlock = true); /** Set a mode on a channel * @param bi The client setting the modes * @param cm The mode * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock + * @param enforce_mlock true if mlocks should be enforced, false to override mlock */ - void SetMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m = "", bool EnforceMLock = true); + void SetMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m = "", bool enforce_mlock = true); /** * Set a mode on a channel * @param bi The client setting the modes - * @param Name The mode name + * @param name The mode name * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock + * @param enforce_mlock true if mlocks should be enforced, false to override mlock */ - void SetMode(BotInfo *bi, ChannelModeName Name, const Anope::string ¶m = "", bool EnforceMLock = true); + void SetMode(BotInfo *bi, ChannelModeName name, const Anope::string ¶m = "", bool enforce_mlock = true); /** Remove a mode from a channel * @param bi The client setting the modes * @param cm The mode * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock + * @param enforce_mlock true if mlocks should be enforced, false to override mlock */ - void RemoveMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m = "", bool EnforceMLock = true); + void RemoveMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m = "", bool enforce_mlock = true); /** * Remove a mode from a channel * @param bi The client setting the modes - * @param Name The mode name + * @param name The mode name * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock + * @param enforce_mlock true if mlocks should be enforced, false to override mlock */ - void RemoveMode(BotInfo *bi, ChannelModeName Name, const Anope::string ¶m = "", bool EnforceMLock = true); + void RemoveMode(BotInfo *bi, ChannelModeName name, const Anope::string ¶m = "", bool enforce_mlock = true); - /** Get a param from the channel - * @param Name The mode - * @param Target a string to put the param into - * @return true on success + /** Get a modes parameter for the channel + * @param name The mode + * @param target a string to put the param into + * @return true if the parameter was fetched, false if on error (mode not set) etc. */ - bool GetParam(ChannelModeName Name, Anope::string &Target) const; + bool GetParam(ChannelModeName name, Anope::string &target) const; /** Set a string of modes on the channel * @param bi The client setting the modes - * @param EnforceMLock Should mlock be enforced on this mode change + * @param enforce_mlock Should mlock be enforced on this mode change * @param cmodes The modes to set */ - void SetModes(BotInfo *bi, bool EnforceMLock, const char *cmodes, ...); + void SetModes(BotInfo *bi, bool enforce_mlock, const char *cmodes, ...); /** Set a string of modes internally on a channel * @param source The setter * @param mode the modes - * @param EnforceMLock true to enforce mlock + * @param enforce_mlock true to enforce mlock + */ + void SetModesInternal(MessageSource &source, const Anope::string &mode, time_t ts = 0, bool enforce_mlock = true); + + /** Does the given user match the given list? (CMODE_BAN, CMODE_EXCEPT, etc, a list mode) + * @param u The user + * @param list The mode of the list to check (eg CMODE_BAN) + * @return true if the user matches the list */ - void SetModesInternal(MessageSource &source, const Anope::string &mode, time_t ts = 0, bool EnforceMLock = true); + bool MatchesList(User *u, ChannelModeName list); /** Kick a user from a channel internally * @param source The sender of the kick @@ -246,12 +265,26 @@ class CoreExport Channel : public virtual Base, public Extensible, public Flags< /** Hold the channel open using ChanServ */ void Hold(); -}; -extern CoreExport Channel *findchan(const Anope::string &chan); + /** Set the correct modes, or remove the ones granted without permission, + * for the specified user. + * @param user The user to give/remove modes to/from + * @param give_modes if true modes may be given to the user + * @param check_noop if true, CI_NOAUTOOP is checked before giving modes + */ + void SetCorrectModes(User *u, bool give_mode, bool check_noop); -extern CoreExport User *nc_on_chan(Channel *c, const NickCore *nc); + /** Unbans a user from this channel. + * @param u The user to unban + * @param full Whether or not to match using the user's real host and IP + */ + void Unban(const User *u, bool full = false); -extern CoreExport void chan_set_correct_modes(const User *user, Channel *c, int give_modes, bool check_noop); + /** Finds a channel + * @param name The channel to find + * @return The channel, if found + */ + static Channel* Find(const Anope::string &name); +}; #endif // CHANNELS_H diff --git a/include/commands.h b/include/commands.h index 333d6882a..5c8664147 100644 --- a/include/commands.h +++ b/include/commands.h @@ -22,20 +22,20 @@ enum CommandFlag CFLAG_STRIP_CHANNEL }; -const Anope::string CommandFlagStrings[] = { - "CFLAG_ALLOW_UNREGISTERED", - "CFLAG_STRIP_CHANNEL", - "" -}; - +/* Used in BotInfo::commands */ struct CommandInfo { typedef Anope::map<CommandInfo> map; + /* Service name of the command */ Anope::string name; + /* Permission required to execute the command */ Anope::string permission; }; +/* Where the replies from commands go to. User inheits from this and is the normal + * source of a CommandReply + */ struct CommandReply { virtual void SendMessage(const BotInfo *source, const Anope::string &msg) = 0; @@ -47,16 +47,16 @@ class CoreExport CommandSource /* The nick executing the command */ Anope::string nick; /* User executing the command, may be NULL */ - dynamic_reference<User> u; + Reference<User> u; public: /* The account executing the command */ - dynamic_reference<NickCore> nc; + Reference<NickCore> nc; /* Where the reply should go */ CommandReply *reply; /* Channel the command was executed on (fantasy) */ - dynamic_reference<Channel> c; + Reference<Channel> c; /* The service this command is on */ - dynamic_reference<BotInfo> service; + Reference<BotInfo> service; /* The actual name of the command being executed */ Anope::string command; /* The permission of the command being executed */ @@ -88,9 +88,9 @@ class CoreExport Command : public Service, public Flags<CommandFlag> public: /* Maximum paramaters accepted by this command */ - size_t MaxParams; + size_t max_params; /* Minimum parameters required to use this command */ - size_t MinParams; + size_t min_params; /* Module which owns us */ Module *module; diff --git a/include/config.h b/include/config.h index 86a232485..ad772033d 100644 --- a/include/config.h +++ b/include/config.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef CONFIG_H @@ -207,23 +206,6 @@ typedef bool (*MultiValidator)(ServerConfig *, const Anope::string &, const Anop */ typedef bool (*MultiNotify)(ServerConfig *, const Anope::string &); -bool ValidateNotEmpty(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateNotZero(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateEmailReg(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidatePort(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateGuestPrefix(ServerConfig *conf, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateBantype(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &data); -bool ValidateChanServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateMemoServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateBotServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateHostServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateLimitSessions(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateOperServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateGlobal(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateNickLen(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &data); -bool ValidateMail(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); -bool ValidateGlobalOnCycle(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data); - /** Represents a configuration file */ class ConfigurationFile @@ -463,8 +445,6 @@ class CoreExport ServerConfig bool UseServerSideTopicLock; /* Default botmodes on channels, defaults to ao */ Anope::string BotModes; - /* THe actual modes */ - ChannelStatus BotModeList; /* How long to wait between connection attempts */ int RetryWait; /* If services should hide unprivileged commands */ @@ -517,7 +497,7 @@ class CoreExport ServerConfig /* Don't allow nicks to use /ns group to regroup nicks */ bool NSNoGroupChange; /* Default flags for newly registered nicks */ - Flags<NickCoreFlag, NI_END> NSDefFlags; + Flags<NickCoreFlag> NSDefFlags; /* All languages Anope is aware about */ Anope::string Languages; /* Default language used by services */ @@ -578,7 +558,7 @@ class CoreExport ServerConfig /* Core ChanServ modules */ Anope::string ChanCoreModules; /* Default flags for newly registered channels */ - Flags<ChannelInfoFlag, CI_END> CSDefFlags; + Flags<ChannelInfoFlag> CSDefFlags; /* Max number of channels a user can own */ unsigned CSMaxReg; /* Time before a channel expires */ @@ -741,7 +721,7 @@ class ConfigException : public CoreException #define CONF_FILE_NOT_FOUND 0x000200 /** Allows reading of values from configuration files - * This class allows a module to read from either the main configuration file (inspircd.conf) or from + * This class allows a module to read from either the main configuration file (services.conf) or from * a module-specified configuration file. It may either be instantiated with one parameter or none. * Constructing the class using one parameter allows you to specify a path to your own configuration * file, otherwise, inspircd.conf is read. @@ -836,7 +816,7 @@ class CoreExport ConfigReader int EnumerateValues(const Anope::string &, int); }; -extern ConfigurationFile services_conf; +extern ConfigurationFile ServicesConf; extern CoreExport ServerConfig *Config; #endif // CONFIG_H diff --git a/include/defs.h b/include/defs.h index ed6795142..437f0f08d 100644 --- a/include/defs.h +++ b/include/defs.h @@ -23,21 +23,21 @@ class ClientSocket; class Command; class CommandSource; class ConnectionSocket; -class DNSPacket; -class dynamic_reference_base; +namespace DNS { class Packet; } class Entry; class IdentifyRequest; class InfoFormatter; +class IRCDProto; class ListenSocket; class Log; class LogInfo; class Memo; -class Message; class MessageSource; class Module; class NickAlias; class NickCore; class OperType; +class ReferenceBase; class Regex; class Serializable; class Server; @@ -48,7 +48,7 @@ class User; class XLine; class XLineManager; struct BadWord; -struct DNSQuery; +namespace DNS { struct Query; } struct Exception; struct MemoInfo; struct ModeLock; diff --git a/include/dns.h b/include/dns.h index 64067107b..fee9da8a9 100644 --- a/include/dns.h +++ b/include/dns.h @@ -8,260 +8,271 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ - + #ifndef DNS_H #define DNS_H #include "sockets.h" #include "timers.h" -#include "extern.h" #include "config.h" - -/** Valid query types - */ -enum QueryType -{ - /* Nothing */ - DNS_QUERY_NONE, - /* A simple A lookup */ - DNS_QUERY_A = 1, - /* An authoritative name server */ - DNS_QUERY_NS = 2, - /* A CNAME lookup */ - DNS_QUERY_CNAME = 5, - /* Start of a zone of authority */ - DNS_QUERY_SOA = 6, - /* Reverse DNS lookup */ - DNS_QUERY_PTR = 12, - /* IPv6 AAAA lookup */ - DNS_QUERY_AAAA = 28, - /* Zone transfer */ - DNS_QUERY_AXFR = 252 -}; - -/** Flags that can be AND'd into DNSPacket::flags to receive certain values - */ -enum -{ - DNS_QUERYFLAGS_QR = 0x8000, - DNS_QUERYFLAGS_OPCODE = 0x7800, - DNS_QUERYFLAGS_AA = 0x400, - DBS_QUERYFLAGS_TC = 0x200, - DNS_QUERYFLAGS_RD = 0x100, - DNS_QUERYFLAGS_RA = 0x80, - DNS_QUERYFLAGS_Z = 0x70, - DNS_QUERYFLAGS_RCODE = 0xF -}; - -enum DNSError -{ - DNS_ERROR_NONE, - DNS_ERROR_UNKNOWN, - DNS_ERROR_UNLOADED, - DNS_ERROR_TIMEOUT, - DNS_ERROR_NOT_AN_ANSWER, - DNS_ERROR_NONSTANDARD_QUERY, - DNS_ERROR_FORMAT_ERROR, - DNS_ERROR_SERVER_FAILURE, - DNS_ERROR_DOMAIN_NOT_FOUND, - DNS_ERROR_NOT_IMPLEMENTED, - DNS_ERROR_REFUSED, - DNS_ERROR_NO_RECORDS, - DNS_ERROR_INVALIDTYPE -}; - - -struct CoreExport Question -{ - Anope::string name; - QueryType type; - unsigned short qclass; - - Question(); - Question(const Anope::string &, QueryType, unsigned short = 1); -}; - -struct CoreExport ResourceRecord : public Question -{ - unsigned int ttl; - Anope::string rdata; - time_t created; - - ResourceRecord(const Anope::string &, QueryType, unsigned short = 1); - ResourceRecord(const Question &); -}; - -struct CoreExport DNSQuery -{ - std::vector<Question> questions; - std::vector<ResourceRecord> answers, authorities, additional; - DNSError error; - - DNSQuery(); - DNSQuery(const Question &q); -}; - -/** The request - */ -class CoreExport DNSRequest : public Timer, public Question -{ - /* Use result cache if available */ - bool use_cache; - - public: - /* Request id */ - unsigned short id; - /* Creator of this request */ - Module *creator; - - DNSRequest(const Anope::string &addr, QueryType qt, bool cache = false, Module *c = NULL); - - virtual ~DNSRequest(); - - void Process(); - - virtual void OnLookupComplete(const DNSQuery *r) = 0; - - virtual void OnError(const DNSQuery *r); - void Tick(time_t) anope_override; -}; - -/** A full packet sent or recieved to/from the nameserver - */ -class DNSPacket : public DNSQuery +namespace DNS { - static const int DNS_POINTER = 0xC0; - static const int DNS_LABEL = 0x3F; - - void PackName(unsigned char *output, unsigned short output_size, unsigned short &pos, const Anope::string &name); - Anope::string UnpackName(const unsigned char *input, unsigned short input_size, unsigned short &pos); - Question UnpackQuestion(const unsigned char *input, unsigned short input_size, unsigned short &pos); - ResourceRecord UnpackResourceRecord(const unsigned char *input, unsigned short input_size, unsigned short &poss); - public: - static const int HEADER_LENGTH = 12; - - /* Source or destination of the packet */ - sockaddrs addr; - /* ID for this packet */ - unsigned short id; - /* Flags on the packet */ - unsigned short flags; - - DNSPacket(sockaddrs *a); - void Fill(const unsigned char *input, const unsigned short len); - unsigned short Pack(unsigned char *output, unsigned short output_size); -}; - -/** DNS manager - */ -class CoreExport DNSManager : public Timer -{ - class ReplySocket : public virtual Socket + /** Valid query types + */ + enum QueryType + { + /* Nothing */ + QUERY_NONE, + /* A simple A lookup */ + QUERY_A = 1, + /* An authoritative name server */ + QUERY_NS = 2, + /* A CNAME lookup */ + QUERY_CNAME = 5, + /* Start of a zone of authority */ + QUERY_SOA = 6, + /* Reverse DNS lookup */ + QUERY_PTR = 12, + /* IPv6 AAAA lookup */ + QUERY_AAAA = 28, + /* Zone transfer */ + QUERY_AXFR = 252 + }; + + /** Flags that can be AND'd into DNSPacket::flags to receive certain values + */ + enum { + QUERYFLAGS_QR = 0x8000, + QUERYFLAGS_OPCODE = 0x7800, + QUERYFLAGS_AA = 0x400, + QUERYFLAGS_TC = 0x200, + QUERYFLAGS_RD = 0x100, + QUERYFLAGS_RA = 0x80, + QUERYFLAGS_Z = 0x70, + QUERYFLAGS_RCODE = 0xF + }; + + enum Error + { + ERROR_NONE, + ERROR_UNKNOWN, + ERROR_UNLOADED, + ERROR_TIMEOUT, + ERROR_NOT_AN_ANSWER, + ERROR_NONSTANDARD_QUERY, + ERROR_FORMAT_ERROR, + ERROR_SERVER_FAILURE, + ERROR_DOMAIN_NOT_FOUND, + ERROR_NOT_IMPLEMENTED, + ERROR_REFUSED, + ERROR_NO_RECORDS, + ERROR_INVALIDTYPE + }; + + + struct CoreExport Question + { + Anope::string name; + QueryType type; + unsigned short qclass; + + Question(); + Question(const Anope::string &, QueryType, unsigned short = 1); + }; + + struct CoreExport ResourceRecord : public Question + { + unsigned int ttl; + Anope::string rdata; + time_t created; + + ResourceRecord(const Anope::string &, QueryType, unsigned short = 1); + ResourceRecord(const Question &); + }; + + struct CoreExport Query + { + std::vector<Question> questions; + std::vector<ResourceRecord> answers, authorities, additional; + Error error; + + Query(); + Query(const Question &q); + }; + + /** A DNS query. + */ + class CoreExport Request : public Timer, public Question + { + /* Use result cache if available */ + bool use_cache; + public: - virtual ~ReplySocket() { } - virtual void Reply(DNSPacket *p) = 0; + /* Request id */ + unsigned short id; + /* Creator of this request */ + Module *creator; + + Request(const Anope::string &addr, QueryType qt, bool cache = false, Module *c = NULL); + virtual ~Request(); + + void Process(); + + /** Called when this request succeeds + * @param r The query sent back from the nameserver + */ + virtual void OnLookupComplete(const Query *r) = 0; + + /** Called when this request fails or times out. + * @param r The query sent back from the nameserver, check the error code. + */ + virtual void OnError(const Query *r); + + /** Used to time out the query, Calls OnError and lets the TimerManager + * delete this request. + */ + void Tick(time_t) anope_override; }; - - /* Listens for TCP requests */ - class TCPSocket : public ListenSocket + + /** A full packet sent or recieved to/from the nameserver + */ + class Packet : public Query { - /* A TCP client */ - class Client : public ClientSocket, public Timer, public ReplySocket + static const int POINTER = 0xC0; + static const int LABEL = 0x3F; + + void PackName(unsigned char *output, unsigned short output_size, unsigned short &pos, const Anope::string &name); + Anope::string UnpackName(const unsigned char *input, unsigned short input_size, unsigned short &pos); + + Question UnpackQuestion(const unsigned char *input, unsigned short input_size, unsigned short &pos); + ResourceRecord UnpackResourceRecord(const unsigned char *input, unsigned short input_size, unsigned short &poss); + public: + static const int HEADER_LENGTH = 12; + + /* Source or destination of the packet */ + sockaddrs addr; + /* ID for this packet */ + unsigned short id; + /* Flags on the packet */ + unsigned short flags; + + Packet(sockaddrs *a); + void Fill(const unsigned char *input, const unsigned short len); + unsigned short Pack(unsigned char *output, unsigned short output_size); + }; + + /** DNS manager + */ + class CoreExport Manager : public Timer + { + class ReplySocket : public virtual Socket { - TCPSocket *tcpsock; - DNSPacket *packet; - unsigned char packet_buffer[524]; - int length; - public: - Client(TCPSocket *ls, int fd, const sockaddrs &addr); - ~Client(); - - /* Times out after a few seconds */ - void Tick(time_t) anope_override { } - void Reply(DNSPacket *p) anope_override; + virtual ~ReplySocket() { } + virtual void Reply(Packet *p) = 0; + }; + + /* Listens for TCP requests */ + class TCPSocket : public ListenSocket + { + /* A TCP client */ + class Client : public ClientSocket, public Timer, public ReplySocket + { + TCPSocket *tcpsock; + Packet *packet; + unsigned char packet_buffer[524]; + int length; + + public: + Client(TCPSocket *ls, int fd, const sockaddrs &addr); + ~Client(); + + /* Times out after a few seconds */ + void Tick(time_t) anope_override { } + void Reply(Packet *p) anope_override; + bool ProcessRead() anope_override; + bool ProcessWrite() anope_override; + }; + + public: + TCPSocket(const Anope::string &ip, int port); + + ClientSocket *OnAccept(int fd, const sockaddrs &addr) anope_override; + }; + + /* Listens for UDP requests */ + class UDPSocket : public ReplySocket + { + std::deque<Packet *> packets; + public: + + UDPSocket(const Anope::string &ip, int port); + ~UDPSocket(); + + void Reply(Packet *p) anope_override; + + std::deque<Packet *>& GetPackets() { return packets; } + bool ProcessRead() anope_override; + bool ProcessWrite() anope_override; }; - - public: - TCPSocket(const Anope::string &ip, int port); - - ClientSocket *OnAccept(int fd, const sockaddrs &addr) anope_override; - }; - - /* Listens for UDP requests */ - class UDPSocket : public ReplySocket - { - std::deque<DNSPacket *> packets; + + typedef std::multimap<Anope::string, ResourceRecord, ci::less> cache_map; + cache_map cache; + + bool listen; + uint32_t serial; + public: - - UDPSocket(const Anope::string &ip, int port); - ~UDPSocket(); - - void Reply(DNSPacket *p) anope_override; - - std::deque<DNSPacket *>& GetPackets() { return packets; } - - bool ProcessRead() anope_override; - - bool ProcessWrite() anope_override; + TCPSocket *tcpsock; + UDPSocket *udpsock; + + sockaddrs addrs; + std::map<unsigned short, Request *> requests; + + Manager(const Anope::string &nameserver, const Anope::string &ip, int port); + ~Manager(); + + bool HandlePacket(ReplySocket *s, const unsigned char *const data, int len, sockaddrs *from); + + /** Add a record to the dns cache + * @param r The record + */ + void AddCache(Query &r); + + /** Check the DNS cache to see if request can be handled by a cached result + * @return true if a cached result was found. + */ + bool CheckCache(Request *request); + + /** Tick this timer, used to clear the DNS cache. + */ + void Tick(time_t now) anope_override; + + /** Cleanup all pending DNS queries for a module + * @param mod The module + */ + void Cleanup(Module *mod); + + void UpdateSerial(); + uint32_t GetSerial() const; + + /** Does a BLOCKING DNS query and returns the first IP. + * Only use this if you know what you are doing. Unless you specifically + * need a blocking query use the DNSRequest system + */ + static Query BlockingQuery(const Anope::string &mask, QueryType qt); }; - - typedef std::multimap<Anope::string, ResourceRecord, ci::less> cache_map; - cache_map cache; - - bool listen; - uint32_t serial; - - public: - TCPSocket *tcpsock; - UDPSocket *udpsock; - - sockaddrs addrs; - std::map<unsigned short, DNSRequest *> requests; - - DNSManager(const Anope::string &nameserver, const Anope::string &ip, int port); - ~DNSManager(); - - bool HandlePacket(ReplySocket *s, const unsigned char *const data, int len, sockaddrs *from); - - /** Add a record to the dns cache - * @param r The record - */ - void AddCache(DNSQuery &r); - - /** Check the DNS cache to see if request can be handled by a cached result - * @return true if a cached result was found. - */ - bool CheckCache(DNSRequest *request); - - /** Tick this timer, used to clear the DNS cache. - */ - void Tick(time_t now) anope_override; - - /** Cleanup all pending DNS queries for a module - * @param mod The module - */ - void Cleanup(Module *mod); - - void UpdateSerial(); - uint32_t GetSerial() const; - - /** Does a BLOCKING DNS query and returns the first IP. - * Only use this if you know what you are doing. Unless you specifically - * need a blocking query use the DNSRequest system - */ - static DNSQuery BlockingQuery(const Anope::string &mask, QueryType qt); -}; - -extern CoreExport DNSManager *DNSEngine; - + + extern CoreExport Manager *Engine; + +} // namespace DNS + #endif // DNS_H - - + + diff --git a/include/extensible.h b/include/extensible.h index 6db4cf112..493dc20cf 100644 --- a/include/extensible.h +++ b/include/extensible.h @@ -1,7 +1,10 @@ /* - * Copyright (C) 2008-2012 Anope Team <team@anope.org> + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ #ifndef EXTENSIBLE_H @@ -9,19 +12,28 @@ #include "anope.h" +/* All items added to Extensible must inherit from this. + */ class CoreExport ExtensibleItem { public: - ExtensibleItem(); - virtual ~ExtensibleItem(); - virtual void OnDelete(); + virtual ~ExtensibleItem() { } + + /* Called when this ExtensibleItem is being deleted. This should + * clean up things (eg, delete this;) if necessary. + */ + virtual void OnDelete() { delete this; } }; +/** Common class used to Extensible::Extend non-pointers from, as it doesn't delete + * itself when removed. Eg, obj->Extend(key, new ExtensibleItemClass<Anope::string>(value)); + */ template<typename T> struct CoreExport ExtensibleItemClass : T, ExtensibleItem { ExtensibleItemClass(const T& t) : T(t) { } }; +/* Used to attach arbitrary objects to this object using unique keys */ class CoreExport Extensible { private: @@ -33,7 +45,7 @@ class CoreExport Extensible */ Extensible() { } - /** Default destructor, deletes all of the extensible items in this object + /** Destructor, deletes all of the extensible items in this object * then clears the map */ virtual ~Extensible() diff --git a/include/extern.h b/include/extern.h deleted file mode 100644 index e8a47c209..000000000 --- a/include/extern.h +++ /dev/null @@ -1,108 +0,0 @@ -/* Prototypes and external variable declarations. - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - -#ifndef EXTERN_H -#define EXTERN_H - -#include "modes.h" - -#define E extern CoreExport -#define EI extern DllExport - - -/**** actions.c ****/ - -E bool bad_password(User *u); -E void common_unban(const ChannelInfo *ci, User *u, bool full = false); - -/**** encrypt.c ****/ - -E void enc_encrypt(const Anope::string &src, Anope::string &dest); -E bool enc_decrypt(const Anope::string &src, Anope::string &dest); - -/**** init.c ****/ - -E Anope::string conf_dir, db_dir, modules_dir, locale_dir, log_dir; - -E void introduce_user(const Anope::string &user); -E bool GetCommandLineArgument(const Anope::string &name, char shortname = 0); -E bool GetCommandLineArgument(const Anope::string &name, char shortname, Anope::string ¶m); -E bool AtTerm(); -E void Fork(); -E void Init(int ac, char **av); - -/**** language.cpp ****/ - -E std::vector<Anope::string> languages; -E std::vector<Anope::string> domains; -E void InitLanguages(); -E const char *translate(const char *string); -E const char *translate(User *u, const char *string); -E const char *translate(const NickCore *nc, const char *string); -E const char *anope_gettext(const char *lang, const char *string); - -/**** main.c ****/ - -E Anope::string services_dir; -E Anope::string services_bin; -E int debug; -E bool readonly; -E bool nofork; -E bool nothird; -E bool noexpire; -E bool protocoldebug; - -E bool quitting; -E int return_code; -E bool restarting; -E Anope::string quitmsg; -E time_t start_time; - -E int CurrentUplink; - -E void save_databases(); -E void sighandler(int signum); - -/**** misc.c ****/ - -E bool IsFile(const Anope::string &filename); - -E time_t dotime(const Anope::string &s); -E Anope::string duration(const time_t &seconds, const NickCore *nc = NULL); -E Anope::string expire_left(const NickCore *nc, time_t expires); -E Anope::string do_strftime(const time_t &t, const NickCore *nc = NULL, bool short_output = false); -E bool IsValidIdent(const Anope::string &ident); -E bool IsValidHost(const Anope::string &host); - -E Anope::string myStrGetToken(const Anope::string &str, char dilim, int token_number); -E Anope::string myStrGetTokenRemainder(const Anope::string &str, char dilim, int token_number); -E int myNumToken(const Anope::string &str, char dilim); -E bool nickIsServices(const Anope::string &nick, bool bot); - -E std::list<Anope::string> BuildStringList(const Anope::string &, char = ' '); -E std::vector<Anope::string> BuildStringVector(const Anope::string &, char = ' '); - -E bool str_is_wildcard(const Anope::string &str); -E bool str_is_pure_wildcard(const Anope::string &str); -E Anope::string normalizeBuffer(const Anope::string &); - -/**** modes.cpp ****/ - -/* Number of generic modes we support */ -E unsigned GenericChannelModes, GenericUserModes; -E std::multimap<ChannelModeName, ModeLock *> def_mode_locks; -E void SetDefaultMLock(ServerConfig *config); - -/**** process.c ****/ - -E void process(const Anope::string &buf); - -#endif /* EXTERN_H */ diff --git a/include/hashcomp.h b/include/hashcomp.h index 9f9be9793..74258151a 100644 --- a/include/hashcomp.h +++ b/include/hashcomp.h @@ -1,13 +1,10 @@ /* + * * Copyright (C) 2002-2011 InspIRCd Development Team * Copyright (C) 2009-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. * - * These classes have been copied from InspIRCd and modified - * for use in Anope. - * - * */ #ifndef HASHCOMP_H @@ -28,13 +25,15 @@ namespace Anope { class string; + /* Casemap in use by Anope. ci::string's comparation functions use this (and thus Anope::string) */ extern std::locale casemap; - template<typename charT> - class ascii_ctype : public std::ctype<charT> + /* ASCII case insensitive ctype. */ + template<typename char_type> + class ascii_ctype : public std::ctype<char_type> { public: - charT do_toupper(charT c) const anope_override + char_type do_toupper(char_type c) const anope_override { if (c >= 'a' && c <= 'z') return c - 32; @@ -42,7 +41,7 @@ namespace Anope return c; } - charT do_tolower(charT c) const anope_override + char_type do_tolower(char_type c) const anope_override { if (c >= 'A' && c <= 'Z') return c + 32; @@ -51,29 +50,30 @@ namespace Anope } }; - template<typename charT> - class rfc1459_ctype : public ascii_ctype<charT> + /* rfc1459 case insensitive ctype, { = [, } = ], and | = \ */ + template<typename char_type> + class rfc1459_ctype : public ascii_ctype<char_type> { public: - charT do_toupper(charT c) const anope_override + char_type do_toupper(char_type c) const anope_override { if (c == '{' || c == '}' || c == '|') return c - 32; else - return ascii_ctype<charT>::do_toupper(c); + return ascii_ctype<char_type>::do_toupper(c); } - charT do_tolower(charT c) const anope_override + char_type do_tolower(char_type c) const anope_override { if (c == '[' || c == ']' || c == '\\') return c + 32; else - return ascii_ctype<charT>::do_tolower(c); + return ascii_ctype<char_type>::do_tolower(c); } }; } -/** The ci namespace contains a number of helper classes. +/** The ci namespace contains a number of helper classes relevant to case insensitive strings. */ namespace ci { diff --git a/include/language.h b/include/language.h index f48d9ce2d..eeb23af02 100644 --- a/include/language.h +++ b/include/language.h @@ -1,11 +1,67 @@ -/* Commonly used language strings +/* * * (C) 2008-2012 Anope Team * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ +namespace Language +{ + + /* Languages we support as configured in services.conf. They are + * added to this list if we detect a language exists in the correct + * location for each language. + */ + extern std::vector<Anope::string> Languages; + + /* Domains to search when looking for translations other than the + * default "anope domain. This is used by modules who add their own + * language files (and thus domains) to Anope. If a module is loaded + * and we detect a language file exists for at least one of the supported + * languages for the module, then we add the module's domain (its name) + * here. + * + * When strings are translated they are checked against all domains. + */ + extern std::vector<Anope::string> Domains; + + /** Initialize the language system. Finds valid language files and + * populates the Languages list. + */ + extern void InitLanguages(); + + /** Translates a string to the default language. + * @param string A string to translate + * @return The translated string if found, else the original string. + */ + extern const char *Translate(const char *string); + + /** Translates a string to the language of the given user. + * @param u The user to transate the string for + * @param string A string to translate + * @return The translated string if found, else the original string. + */ + extern const char *Translate(User *u, const char *string); + + /** Translates a string to the language of the given account. + * @param nc The account to translate the string for + * @param string A string to translate + * @return The translated string if count, else the original string + */ + extern const char *Translate(const NickCore *nc, const char *string); + + /** Translatesa string to the given language. + * @param lang The language to trnalsate to + * @param string The string to translate + * @return The translated string if found, else the original string. + */ + extern const char *Translate(const char *lang, const char *string); + +} // namespace Language + +/* Commonly used language strings */ #define MORE_INFO _("\002%s%s HELP %s\002 for more information.") #define BAD_USERHOST_MASK _("Mask must be in the form \037user\037@\037host\037.") #define BAD_EXPIRY_TIME _("Invalid expiry time.") diff --git a/include/lists.h b/include/lists.h index 841faf7a9..94d03aa4b 100644 --- a/include/lists.h +++ b/include/lists.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef LISTS_H @@ -48,9 +47,9 @@ class CoreExport NumberList void Process(); /** Called with a number from the list - * @param Number The number + * @param number The number */ - virtual void HandleNumber(unsigned Number); + virtual void HandleNumber(unsigned number); /** Called when there is an error with the numbered list * Return false to immediatly stop processing the list and return @@ -71,9 +70,9 @@ class CoreExport ListFormatter std::vector<Anope::string> columns; std::vector<ListEntry> entries; public: - ListFormatter &addColumn(const Anope::string &name); - void addEntry(const ListEntry &entry); - bool isEmpty() const; + ListFormatter &AddColumn(const Anope::string &name); + void AddEntry(const ListEntry &entry); + bool IsEmpty() const; void Process(std::vector<Anope::string> &); }; diff --git a/include/logger.h b/include/logger.h index 5df81a5bc..1f674467a 100644 --- a/include/logger.h +++ b/include/logger.h @@ -18,8 +18,13 @@ enum LogType { + /* Used whenever an administrator uses an administrative comand */ LOG_ADMIN, + /* Used whenever an administrator overides something, such as adding + * access to a channel where they don't have permission to. + */ LOG_OVERRIDE, + /* Any other command usage */ LOG_COMMAND, LOG_SERVER, LOG_CHANNEL, @@ -37,30 +42,37 @@ enum LogType struct LogFile { Anope::string filename; - - public: std::ofstream stream; LogFile(const Anope::string &name); Anope::string GetName() const; }; - +/* Represents a single log message */ class CoreExport Log { public: + /* Bot that should log this message */ const BotInfo *bi; + /* For commands, the user executing the command */ Anope::string nick; + /* For commands, the user executing the command, but might not always exist */ const User *u; + /* For commands, the account executing teh command, but will not always exist */ const NickCore *nc; + /* For commands, the command being executed */ Command *c; + /* Used for LOG_CHANNEL */ Channel *chan; + /* For commands, the channel the command was executed on, will not always exist */ const ChannelInfo *ci; + /* For LOG_SERVER */ Server *s; + /* For LOG_MODULE */ Module *m; - LogType Type; - Anope::string Category; - std::list<Anope::string> Sources; + LogType type; + Anope::string category; + std::list<Anope::string> sources; std::stringstream buf; @@ -93,22 +105,23 @@ class CoreExport Log } }; +/* Configured in the configuration file, actually does the message logging */ class CoreExport LogInfo { public: - std::list<Anope::string> Targets; - std::map<Anope::string, LogFile *> Logfiles; - std::list<Anope::string> Sources; - int LogAge; - std::list<Anope::string> Admin; - std::list<Anope::string> Override; - std::list<Anope::string> Commands; - std::list<Anope::string> Servers; - std::list<Anope::string> Users; - std::list<Anope::string> Channels; - std::list<Anope::string> Normal; - bool RawIO; - bool Debug; + std::list<Anope::string> targets; + std::map<Anope::string, LogFile *> logfiles; + std::list<Anope::string> sources; + int log_age; + std::list<Anope::string> admin; + std::list<Anope::string> override; + std::list<Anope::string> commands; + std::list<Anope::string> servers; + std::list<Anope::string> users; + std::list<Anope::string> channels; + std::list<Anope::string> normal; + bool raw_io; + bool debug; LogInfo(int logage, bool rawio, bool debug); @@ -118,6 +131,7 @@ class CoreExport LogInfo bool HasType(LogType ltype, const Anope::string &type) const; + /* Logs the message l if configured to */ void ProcessMessage(const Log *l); }; diff --git a/include/mail.h b/include/mail.h index 493002637..2b513c849 100644 --- a/include/mail.h +++ b/include/mail.h @@ -18,28 +18,41 @@ #include "threadengine.h" #include "serialize.h" -extern CoreExport bool Mail(User *u, NickCore *nc, const BotInfo *service, const Anope::string &subject, const Anope::string &message); -extern CoreExport bool Mail(NickCore *nc, const Anope::string &subject, const Anope::string &message); -extern CoreExport bool MailValidate(const Anope::string &email); - -class MailThread : public Thread +namespace Mail { - private: - Anope::string SendMailPath; - Anope::string SendFrom; - Anope::string MailTo; - Anope::string Addr; - Anope::string Subject; - Anope::string Message; - bool DontQuoteAddresses; - - bool Success; - public: - MailThread(const Anope::string &smpath, const Anope::string &sf, const Anope::string &mailto, const Anope::string &addr, const Anope::string &subject, const Anope::string &message); - - ~MailThread(); - - void Run(); -}; + extern CoreExport bool Send(User *from, NickCore *to, const BotInfo *service, const Anope::string &subject, const Anope::string &message); + extern CoreExport bool Send(NickCore *to, const Anope::string &subject, const Anope::string &message); + extern CoreExport bool Validate(const Anope::string &email); + + /* A email message being sent */ + class Message : public Thread + { + private: + Anope::string sendmail_path; + Anope::string send_from; + Anope::string mail_to; + Anope::string addr; + Anope::string subject; + Anope::string message; + bool dont_quote_addresses; + + bool success; + public: + /** Construct this message. Once constructed call Thread::Start to launch the mail sending. + * @param sf Config->SendFrom + * @param mailto Name of person being mailed (u->nick, nc->display, etc) + * @param addr Destination address to mail + * @param subject Message subject + * @param message The actual message + */ + Message(const Anope::string &sf, const Anope::string &mailto, const Anope::string &addr, const Anope::string &subject, const Anope::string &message); + + ~Message(); + + /* Called from within the thread to actually send the mail */ + void Run() anope_override; + }; + +} // namespace Mail #endif // MAIL_H diff --git a/include/memo.h b/include/memo.h index 1879f89b3..9fdbb3cab 100644 --- a/include/memo.h +++ b/include/memo.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef MEMO_H @@ -27,30 +26,28 @@ enum MemoFlag MF_RECEIPT }; -const Anope::string MemoFlagStrings[] = { - "MF_UNREAD", "MF_RECEIPT", "" -}; - -/* Memo info structures. Since both nicknames and channels can have memos, - * we encapsulate memo data in a MemoList to make it easier to handle. */ class CoreExport Memo : public Flags<MemoFlag>, public Serializable { public: Memo(); - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); Anope::string owner; - time_t time; /* When it was sent */ + /* When it was sent */ + time_t time; Anope::string sender; Anope::string text; }; +/* Memo info structures. Since both nicknames and channels can have memos, + * we encapsulate memo data in a MemoInfo to make it easier to handle. + */ struct CoreExport MemoInfo { int16_t memomax; - serialize_checker<std::vector<Memo *> > memos; + Serialize::Checker<std::vector<Memo *> > memos; std::vector<Anope::string> ignores; MemoInfo(); diff --git a/include/messages.h b/include/messages.h index 1a577ae85..1ef9638ff 100644 --- a/include/messages.h +++ b/include/messages.h @@ -1,126 +1,161 @@ +/* + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + #include "protocol.h" - + /* Common IRCD messages. * Protocol modules may chose to include some, none, or all of these handlers * as they see fit. */ - -struct CoreExport CoreIRCDMessageAway : IRCDMessage -{ - CoreIRCDMessageAway(const Anope::string &mname = "AWAY") : IRCDMessage(mname, 0) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageCapab : IRCDMessage -{ - CoreIRCDMessageCapab(const Anope::string &mname = "CAPAB") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageError : IRCDMessage -{ - CoreIRCDMessageError(const Anope::string &mname = "ERROR") : IRCDMessage(mname, 1) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageJoin : IRCDMessage -{ - CoreIRCDMessageJoin(const Anope::string &mname = "JOIN") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageKick : IRCDMessage -{ - CoreIRCDMessageKick(const Anope::string &mname = "KICK") : IRCDMessage(mname, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageKill : IRCDMessage -{ - CoreIRCDMessageKill(const Anope::string &mname = "KILL") : IRCDMessage(mname, 2) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageMOTD : IRCDMessage -{ - CoreIRCDMessageMOTD(const Anope::string &mname = "MOTD") : IRCDMessage(mname, 1) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessagePart : IRCDMessage -{ - CoreIRCDMessagePart(const Anope::string &mname = "PART") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessagePing : IRCDMessage -{ - CoreIRCDMessagePing(const Anope::string &mname = "PING") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessagePrivmsg : IRCDMessage -{ - CoreIRCDMessagePrivmsg(const Anope::string &mname = "PRIVMSG") : IRCDMessage(mname, 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageQuit : IRCDMessage -{ - CoreIRCDMessageQuit(const Anope::string &mname = "QUIT") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageSQuit : IRCDMessage -{ - CoreIRCDMessageSQuit(const Anope::string &mname = "SQUIT") : IRCDMessage(mname, 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageStats : IRCDMessage -{ - CoreIRCDMessageStats(const Anope::string &mname = "STATS") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageTime : IRCDMessage -{ - CoreIRCDMessageTime(const Anope::string &mname = "TIME") : IRCDMessage(mname, 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageTopic : IRCDMessage -{ - CoreIRCDMessageTopic(const Anope::string &mname = "TOPIC") : IRCDMessage(mname, 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageVersion : IRCDMessage -{ - CoreIRCDMessageVersion(const Anope::string &mname = "VERSION") : IRCDMessage(mname, 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - -struct CoreExport CoreIRCDMessageWhois : IRCDMessage -{ - CoreIRCDMessageWhois(const Anope::string &mname = "WHOIS") : IRCDMessage(mname, 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; -}; - + +namespace Message +{ + + struct CoreExport Away : IRCDMessage + { + Away(Module *creator, const Anope::string &mname = "AWAY") : IRCDMessage(creator, mname, 0) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Capab : IRCDMessage + { + Capab(Module *creator, const Anope::string &mname = "CAPAB") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Error : IRCDMessage + { + Error(Module *creator, const Anope::string &mname = "ERROR") : IRCDMessage(creator, mname, 1) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Join : IRCDMessage + { + Join(Module *creator, const Anope::string &mname = "JOIN") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + + typedef std::pair<ChannelStatus, User *> SJoinUser; + + /** Handle a SJOIN. + * @param source The source of the SJOIN + * @param chan The channel the users are joining to + * @param ts The TS for the channel + * @param modes The modes sent with the SJOIN, if any + * @param users The users and their status, if any + */ + static void SJoin(MessageSource &source, const Anope::string &chan, time_t ts, const Anope::string &modes, const std::list<SJoinUser> &users); + }; + + struct CoreExport Kick : IRCDMessage + { + Kick(Module *creator, const Anope::string &mname = "KICK") : IRCDMessage(creator, mname, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Kill : IRCDMessage + { + Kill(Module *creator, const Anope::string &mname = "KILL") : IRCDMessage(creator, mname, 2) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Mode : IRCDMessage + { + Mode(Module *creator, const Anope::string &mname = "MODE") : IRCDMessage(creator, mname, 2) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport MOTD : IRCDMessage + { + MOTD(Module *creator, const Anope::string &mname = "MOTD") : IRCDMessage(creator, mname, 1) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Part : IRCDMessage + { + Part(Module *creator, const Anope::string &mname = "PART") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Ping : IRCDMessage + { + Ping(Module *creator, const Anope::string &mname = "PPING") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Privmsg : IRCDMessage + { + Privmsg(Module *creator, const Anope::string &mname = "PRIVMSG") : IRCDMessage(creator, mname, 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Quit : IRCDMessage + { + Quit(Module *creator, const Anope::string &mname = "QUIT") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport SQuit : IRCDMessage + { + SQuit(Module *creator, const Anope::string &mname = "SQUIT") : IRCDMessage(creator, mname, 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Stats : IRCDMessage + { + Stats(Module *creator, const Anope::string &mname = "STATS") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Time : IRCDMessage + { + Time(Module *creator, const Anope::string &mname = "TIME") : IRCDMessage(creator, mname, 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Topic : IRCDMessage + { + Topic(Module *creator, const Anope::string &mname = "TOPIC") : IRCDMessage(creator, mname, 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Version : IRCDMessage + { + Version(Module *creator, const Anope::string &mname = "VERSION") : IRCDMessage(creator, mname, 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + + struct CoreExport Whois : IRCDMessage + { + Whois(Module *creator, const Anope::string &mname = "WHOIS") : IRCDMessage(creator, mname, 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override; + }; + +} // namespace Message + diff --git a/include/modes.h b/include/modes.h index 1bd928ed1..b38ef3dc1 100644 --- a/include/modes.h +++ b/include/modes.h @@ -27,18 +27,6 @@ enum UserModeName UMODE_END }; -const Anope::string UserModeNameStrings[] = { - "UMODE_BEGIN", - - "UMODE_SERV_ADMIN", "UMODE_BOT", "UMODE_CO_ADMIN", "UMODE_FILTER", "UMODE_HIDEOPER", "UMODE_NETADMIN", - "UMODE_REGPRIV", "UMODE_PROTECTED", "UMODE_NOCTCP", "UMODE_WEBTV", "UMODE_WEBIRC", "UMODE_WHOIS", "UMODE_ADMIN", "UMODE_DEAF", - "UMODE_GLOBOPS", "UMODE_HELPOP", "UMODE_INVIS", "UMODE_OPER", "UMODE_PRIV", "UMODE_GOD", "UMODE_REGISTERED", - "UMODE_SNOMASK", "UMODE_VHOST", "UMODE_WALLOPS", "UMODE_CLOAK", "UMODE_SSL", "UMODE_SOFTCALLERID", "UMODE_CALLERID", - "UMODE_COMMONCHANS", "UMODE_HIDDEN", "UMODE_STRIPCOLOR", "UMODE_INVISIBLE_OPER", "UMODE_RESTRICTED", "UMODE_HIDEIDLE", - - "" -}; - /** All of the valid channel mode names */ enum ChannelModeName @@ -64,29 +52,6 @@ enum ChannelModeName CMODE_END }; -const Anope::string ChannelModeNameStrings[] = { - "CMODE_BEGIN", - - /* Channel modes */ - "CMODE_BLOCKCOLOR", "CMODE_FLOOD", "CMODE_INVITE", "CMODE_KEY", "CMODE_LIMIT", "CMODE_MODERATED", "CMODE_NOEXTERNAL", - "CMODE_PRIVATE", "CMODE_REGISTERED", "CMODE_SECRET", "CMODE_TOPIC", "CMODE_AUDITORIUM", "CMODE_SSL", "CMODE_ADMINONLY", - "CMODE_NOCTCP", "CMODE_FILTER", "CMODE_NOKNOCK", "CMODE_REDIRECT", "CMODE_REGMODERATED", "CMODE_NONICK", "CMODE_OPERONLY", - "CMODE_NOKICK", "CMODE_REGISTEREDONLY", "CMODE_STRIPCOLOR", "CMODE_NONOTICE", "CMODE_NOINVITE", "CMODE_ALLINVITE", - "CMODE_BLOCKCAPS", "CMODE_PERM", "CMODE_NICKFLOOD", "CMODE_JOINFLOOD", "CMODE_DELAYEDJOIN", "CMODE_NOREJOIN", - "CMODE_BANDWIDTH", - - /* b/e/I */ - "CMODE_BAN", "CMODE_EXCEPT", - "CMODE_INVITEOVERRIDE", - - /* v/h/o/a/q */ - "CMODE_VOICE", "CMODE_HALFOP", "CMODE_OP", - "CMODE_PROTECT", "CMODE_OWNER", - - "" -}; - - /** The different types of modes */ enum ModeType @@ -105,9 +70,7 @@ enum ModeType */ enum ModeClass { - /* Channel mode */ MC_CHANNEL, - /* User mode */ MC_USER }; @@ -116,22 +79,19 @@ enum ModeClass class CoreExport Mode : public Base { public: - /* Class of mode this is */ - ModeClass Class; - /* Mode char for this */ - char ModeChar; - /* Type of mode this is */ - ModeType Type; - - /** Default constructor - * @param mClass The type of mode this is - * @param modeChar The mode char + /* Class of mode this is (user/channel) */ + ModeClass mclass; + /* Mode char for this, eg 'b' */ + char mchar; + /* Type of mode this is, eg MODE_LIST */ + ModeType type; + + /** constructor + * @param mclass The type of mode this is + * @param mc The mode char * @param type The mode type */ - Mode(ModeClass mClass, char modeChar, ModeType type); - - /** Default destructor - */ + Mode(ModeClass mclass, char mc, ModeType type); virtual ~Mode(); }; @@ -141,16 +101,13 @@ class CoreExport UserMode : public Mode { public: /* Mode name */ - UserModeName Name; - - /** Default constructor - * @param nName The mode name - * @param modeChar The mode char - */ - UserMode(UserModeName mName, char modeChar); + UserModeName name; - /** Default destructor + /** constructor + * @param name The mode name + * @param mc The mode char */ + UserMode(UserModeName name, char mc); virtual ~UserMode(); /** Returns the mode name as a string @@ -161,11 +118,11 @@ class CoreExport UserMode : public Mode class CoreExport UserModeParam : public UserMode { public: - /** Default constructor - * @param mName The mode name - * @param modeChar The mode char + /** constructor + * @param name The mode name + * @param mc The mode char */ - UserModeParam(UserModeName mName, char modeChar); + UserModeParam(UserModeName name, char mc); /** Check if the param is valid * @param value The param @@ -180,16 +137,13 @@ class CoreExport ChannelMode : public Mode { public: /* Mode name */ - ChannelModeName Name; + ChannelModeName name; - /** Default constructor - * @param mName The mode name - * @param modeChar The mode char - */ - ChannelMode(ChannelModeName mName, char modeChar); - - /** Default destructor + /** constructor + * @param name The mode name + * @param mc The mode char */ + ChannelMode(ChannelModeName name, char mc); virtual ~ChannelMode(); /** Can a user set this mode, used for mlock @@ -209,13 +163,13 @@ class CoreExport ChannelMode : public Mode class CoreExport ChannelModeList : public ChannelMode { public: - /** Default constructor - * @param mName The mode name - * @param modeChar The mode char + /** constructor + * @param name The mode name + * @param mc The mode char */ - ChannelModeList(ChannelModeName mName, char modeChar); + ChannelModeList(ChannelModeName name, char mc); - /** Default destructor + /** destructor */ virtual ~ChannelModeList(); @@ -251,19 +205,19 @@ class CoreExport ChannelModeList : public ChannelMode class CoreExport ChannelModeParam : public ChannelMode { public: - /** Default constructor - * @param mName The mode name - * @param modeChar The mode char - * @param MinusArg true if this mode sends no arg when unsetting + /** constructor + * @param name The mode name + * @param mc The mode char + * @param minus_no_arg true if this mode sends no arg when unsetting */ - ChannelModeParam(ChannelModeName mName, char modeChar, bool MinusArg = false); + ChannelModeParam(ChannelModeName name, char mc, bool minus_no_arg = false); - /** Default destructor + /** destructor */ virtual ~ChannelModeParam(); /* Should we send an arg when unsetting this mode? */ - bool MinusNoArg; + bool minus_no_arg; /** Is the param valid * @param value The param @@ -284,25 +238,33 @@ class CoreExport ChannelModeStatus : public ChannelMode */ unsigned short Level; - /** Default constructor - * @param mName The mode name - * @param modeChar The mode char + /** constructor + * @param name The mode name + * @param mc The mode char * @param mSymbol The symbol for the mode, eg @ % * @param mLevel A level for the mode, which is usually determined by the PREFIX capab */ - ChannelModeStatus(ChannelModeName mName, char modeChar, char mSymbol, unsigned short mLevel = 0); + ChannelModeStatus(ChannelModeName name, char mc, char mSymbol, unsigned short mLevel = 0); - /** Default destructor + /** destructor */ virtual ~ChannelModeStatus(); }; +/* The status a user has on a channel (+v, +h, +o) etc */ +class CoreExport ChannelStatus : public Flags<ChannelModeName> +{ + public: + Anope::string BuildCharPrefixList() const; + Anope::string BuildModePrefixList() const; +}; + /** Channel mode +k (key) */ class CoreExport ChannelModeKey : public ChannelModeParam { public: - ChannelModeKey(char modeChar) : ChannelModeParam(CMODE_KEY, modeChar) { } + ChannelModeKey(char mc) : ChannelModeParam(CMODE_KEY, mc) { } bool IsValid(const Anope::string &value) const anope_override; }; @@ -313,7 +275,7 @@ class CoreExport ChannelModeKey : public ChannelModeParam class CoreExport ChannelModeAdmin : public ChannelMode { public: - ChannelModeAdmin(char modeChar) : ChannelMode(CMODE_ADMINONLY, modeChar) { } + ChannelModeAdmin(char mc) : ChannelMode(CMODE_ADMINONLY, mc) { } /* Opers only */ bool CanSet(User *u) const anope_override; @@ -325,7 +287,7 @@ class CoreExport ChannelModeAdmin : public ChannelMode class CoreExport ChannelModeOper : public ChannelMode { public: - ChannelModeOper(char modeChar) : ChannelMode(CMODE_OPERONLY, modeChar) { } + ChannelModeOper(char mc) : ChannelMode(CMODE_OPERONLY, mc) { } /* Opers only */ bool CanSet(User *u) const anope_override; @@ -337,7 +299,7 @@ class CoreExport ChannelModeOper : public ChannelMode class CoreExport ChannelModeRegistered : public ChannelMode { public: - ChannelModeRegistered(char modeChar) : ChannelMode(CMODE_REGISTERED, modeChar) { } + ChannelModeRegistered(char mc) : ChannelMode(CMODE_REGISTERED, mc) { } /* No one mlocks +r */ bool CanSet(User *u) const anope_override; @@ -355,17 +317,17 @@ class StackerInfo /** Add a mode to this object * @param mode The mode - * @param Set true if setting, false if unsetting - * @param Param The param for the mode + * @param set true if setting, false if unsetting + * @param param The param for the mode */ - void AddMode(Mode *mode, bool Set, const Anope::string &Param); + void AddMode(Mode *mode, bool set, const Anope::string ¶m); }; -/** This is mode manager +/** This is the mode manager * It contains functions for adding modes to Anope so Anope can track them * and do things such as MLOCK. * This also contains a mode stacker that will combine multiple modes and set - * them on a channel all at once + * them on a channel or user at once */ class CoreExport ModeManager { @@ -385,6 +347,13 @@ class CoreExport ModeManager static std::vector<ChannelMode *> ChannelModes; static std::vector<UserMode *> UserModes; + /* Number of generic channel and user modes we are tracking */ + static unsigned GenericChannelModes, GenericUserModes; + /* Default channel mode lock */ + static std::multimap<ChannelModeName, ModeLock *> DefaultModeLocks; + /* Default modes bots have on channels */ + static ChannelStatus DefaultBotModes; + /** Add a user mode to Anope * @param um A UserMode or UserMode derived class * @return true on success, false on error @@ -397,29 +366,39 @@ class CoreExport ModeManager */ static bool AddChannelMode(ChannelMode *cm); + /** Remove a user mode from Anope + * @param um A UserMode to remove + */ + static void RemoveUserMode(UserMode *um); + + /** Remove a channel mode from Anope + * @param um A ChanneMode to remove + */ + static void RemoveChannelMode(ChannelMode *cm); + /** Find a channel mode - * @param Mode The mode + * @param mode The mode * @return The mode class */ - static ChannelMode *FindChannelModeByChar(char Mode); + static ChannelMode *FindChannelModeByChar(char mode); /** Find a user mode - * @param Mode The mode + * @param mode The mode * @return The mode class */ - static UserMode *FindUserModeByChar(char Mode); + static UserMode *FindUserModeByChar(char mode); /** Find a channel mode - * @param Mode The modename + * @param name The modename * @return The mode class */ - static ChannelMode *FindChannelModeByName(ChannelModeName Name); + static ChannelMode *FindChannelModeByName(ChannelModeName name); /** Find a user mode - * @param Mode The modename + * @param name The modename * @return The mode class */ - static UserMode *FindUserModeByName(UserModeName Name); + static UserMode *FindUserModeByName(UserModeName name); /** Find channel mode by string * @param name The mode name @@ -434,37 +413,44 @@ class CoreExport ModeManager static UserMode *FindUserModeByString(const Anope::string &name); /** Gets the channel mode char for a symbol (eg + returns v) - * @param Value The symbol + * @param symbol The symbol * @return The char */ - static char GetStatusChar(char Value); + static char GetStatusChar(char symbol); /** Add a mode to the stacker to be set on a channel * @param bi The client to set the modes from * @param c The channel * @param cm The channel mode - * @param Set true for setting, false for removing - * @param Param The param, if there is one + * @param set true for setting, false for removing + * @param param The param, if there is one */ - static void StackerAdd(const BotInfo *bi, Channel *c, ChannelMode *cm, bool Set, const Anope::string &Param = ""); + static void StackerAdd(const BotInfo *bi, Channel *c, ChannelMode *cm, bool set, const Anope::string ¶m = ""); /** Add a mode to the stacker to be set on a user * @param bi The client to set the modes from * @param u The user * @param um The user mode - * @param Set true for setting, false for removing + * @param set true for setting, false for removing * @param param The param, if there is one */ - static void StackerAdd(const BotInfo *bi, User *u, UserMode *um, bool Set, const Anope::string &Param = ""); + static void StackerAdd(const BotInfo *bi, User *u, UserMode *um, bool set, const Anope::string ¶m = ""); /** Process all of the modes in the stacker and send them to the IRCd to be set on channels/users */ static void ProcessModes(); - /** Delete a user or channel from the stacker + /** Delete a user, channel, or mode from the stacker */ static void StackerDel(User *u); static void StackerDel(Channel *c); + static void StackerDel(Mode *m); + + /** Updates the default mode locks and default bot modes + * @param config The configuration to read from. This is often called + * during a config reload. + */ + static void UpdateDefaultMLock(ServerConfig *config); }; /** Entry flags @@ -493,10 +479,10 @@ class CoreExport Entry : public Flags<EntryType> Anope::string nick, user, host; /** Constructor - * @param _host A full nick!ident@host/cidr mask * @param mode What mode this host is for - can be CMODE_BEGIN for unknown/no mode + * @param host A full nick!ident@host/cidr mask */ - Entry(ChannelModeName mode, const Anope::string &_host); + Entry(ChannelModeName mode, const Anope::string &host); /** Get the banned mask for this entry * @return The mask diff --git a/include/module.h b/include/module.h index bba901741..e6b63bdfb 100644 --- a/include/module.h +++ b/include/module.h @@ -18,13 +18,11 @@ #include "anope.h" #include "base.h" #include "bots.h" -#include "botserv.h" #include "channels.h" #include "commands.h" #include "config.h" #include "dns.h" #include "extensible.h" -#include "extern.h" #include "hashcomp.h" #include "language.h" #include "lists.h" @@ -34,7 +32,6 @@ #include "messages.h" #include "modes.h" #include "modules.h" -#include "oper.h" #include "opertype.h" #include "protocol.h" #include "regexpr.h" @@ -50,9 +47,14 @@ #include "timers.h" #include "uplink.h" #include "users.h" +#include "xline.h" +#include "chanserv.h" +#include "botserv.h" #include "global.h" +#include "hostserv.h" #include "memoserv.h" #include "nickserv.h" +#include "operserv.h" #endif // MODULE_H diff --git a/include/modules.h b/include/modules.h index cdaf53fc0..e62ed8e36 100644 --- a/include/modules.h +++ b/include/modules.h @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "serialize.h" @@ -31,7 +32,7 @@ { \ return new x(modname, creator); \ } \ - BOOLEAN WINAPI DllMain(HINSTANCE, DWORD nReason, LPVOID) \ + BOOLEAN WINAPI DllMain(HINSTANCE, DWORD, LPVOID) \ { \ return TRUE; \ } \ @@ -120,7 +121,6 @@ enum EventReturn EVENT_ALLOW }; - enum ModuleReturn { MOD_ERR_OK, @@ -141,26 +141,23 @@ enum Priority { PRIORITY_FIRST, PRIORITY_DONTCARE, PRIORITY_LAST, PRIORITY_BEFOR /* Module types, in the order in which they are unloaded. The order these are in is IMPORTANT */ enum ModType { MT_BEGIN, THIRD, SUPPORTED, CORE, DATABASE, ENCRYPTION, PROTOCOL, MT_END }; -extern CoreExport std::list<Module *> Modules; - +/** Returned by Module::GetVersion, used to see what version of Anope + * a module is compiled against. + */ class ModuleVersion { private: - int Major; - int Minor; - int Patch; + int version_major; + int version_minor; + int version_patch; public: /** Constructor - * @param vMajor The major version numbber - * @param vMinor The minor version numbber - * @param vPatch The patch version numbber - */ - ModuleVersion(int vMajor, int vMinor, int vPatch); - - /** Destructor + * @param major The major version numbber + * @param minor The minor version numbber + * @param patch The patch version numbber */ - virtual ~ModuleVersion(); + ModuleVersion(int major, int minor, int patch); /** Get the major version of Anope this was built against * @return The major version @@ -200,7 +197,7 @@ class CoreExport Module : public Extensible /** Callbacks used in this module */ - std::list<CallBack *> CallBacks; + std::list<CallBack *> callbacks; /** Handle for this module, obtained from dlopen() */ @@ -259,6 +256,14 @@ class CoreExport Module : public Extensible */ ModuleVersion GetVersion() const; + /** Gets the IRCd protocol published by this module + */ + virtual IRCDProto *GetIRCDProto(); + + /* Everything below here are events. Modules must ModuleManager::Attach to these events + * before they will be called. + */ + /** Called when the ircd notifies that a user has been kicked from a channel. * @param c The channel the user has been kicked from. * @param target The user that has been kicked. @@ -290,7 +295,7 @@ class CoreExport Module : public Extensible * @param u The connecting user. * @param exempt set to true/is true if the user should be excepted from bans etc */ - virtual void OnUserConnect(dynamic_reference<User> &u, bool &exempt) { } + virtual void OnUserConnect(Reference<User> &u, bool &exempt) { } /** Called when a new server connects to the network. * @param s The server that has connected to the network @@ -649,9 +654,9 @@ class CoreExport Module : public Extensible * @param source The user requesting info * @param ci The channel the user is requesting info for * @param info Data to show the user requesting information - * @param ShowHidden true if we should show the user everything + * @param show_hidden true if we should show the user everything */ - virtual void OnChanInfo(CommandSource &source, ChannelInfo *ci, InfoFormatter &info, bool ShowHidden) { } + virtual void OnChanInfo(CommandSource &source, ChannelInfo *ci, InfoFormatter &info, bool show_hidden) { } /** Checks if access has the channel privilege 'priv'. * @param access THe access struct @@ -763,9 +768,9 @@ class CoreExport Module : public Extensible * @param source The user requesting info * @param na The nick the user is requesting info from * @param info Data to show the user requesting information - * @param ShowHidden true if we should show the user everything + * @param show_hidden true if we should show the user everything */ - virtual void OnNickInfo(CommandSource &source, NickAlias *na, InfoFormatter &info, bool ShowHidden) { } + virtual void OnNickInfo(CommandSource &source, NickAlias *na, InfoFormatter &info, bool show_hidden) { } /** Check whether a username and password is correct * @param u The user trying to identify, if applicable. @@ -824,32 +829,32 @@ class CoreExport Module : public Extensible /** Called when a mode is set on a channel * @param c The channel * @param setter The user or server that is setting the mode - * @param Name The mode name + * @param mname The mode name * @param param The mode param, if there is one * @return EVENT_STOP to make mlock/secureops etc checks not happen */ - virtual EventReturn OnChannelModeSet(Channel *c, MessageSource &setter, ChannelModeName Name, const Anope::string ¶m) { return EVENT_CONTINUE; } + virtual EventReturn OnChannelModeSet(Channel *c, MessageSource &setter, ChannelModeName mname, const Anope::string ¶m) { return EVENT_CONTINUE; } /** Called when a mode is unset on a channel * @param c The channel * @param setter The user or server that is unsetting the mode - * @param Name The mode name + * @param mname The mode name * @param param The mode param, if there is one * @return EVENT_STOP to make mlock/secureops etc checks not happen */ - virtual EventReturn OnChannelModeUnset(Channel *c, MessageSource &setter, ChannelModeName Name, const Anope::string ¶m) { return EVENT_CONTINUE; } + virtual EventReturn OnChannelModeUnset(Channel *c, MessageSource &setter, ChannelModeName mname, const Anope::string ¶m) { return EVENT_CONTINUE; } /** Called when a mode is set on a user * @param u The user - * @param Name The mode name + * @param mname The mode name */ - virtual void OnUserModeSet(User *u, UserModeName Name) { } + virtual void OnUserModeSet(User *u, UserModeName mname) { } /** Called when a mode is unset from a user * @param u The user - * @param Name The mode name + * @param mname The mode name */ - virtual void OnUserModeUnset(User *u, UserModeName Name) { } + virtual void OnUserModeUnset(User *u, UserModeName mname) { } /** Called when a channel mode is introducted into Anope * @param cm The mode @@ -921,7 +926,7 @@ class CoreExport Module : public Extensible * @param req The dns request * @param reply The reply that will be sent */ - virtual void OnDnsRequest(DNSPacket &req, DNSPacket *reply) { } + virtual void OnDnsRequest(DNS::Packet &req, DNS::Packet *reply) { } /** Called when a channels modes are being checked to see if they are allowed, * mostly to ensure mlock/+r are set. @@ -930,7 +935,7 @@ class CoreExport Module : public Extensible */ virtual EventReturn OnCheckModes(Channel *c) { return EVENT_CONTINUE; } - virtual void OnSerializeCheck(SerializeType *) { } + virtual void OnSerializeCheck(Serialize::Type *) { } virtual void OnSerializableConstruct(Serializable *) { } virtual void OnSerializableDestruct(Serializable *) { } virtual void OnSerializableUpdate(Serializable *) { } @@ -1012,6 +1017,10 @@ enum Implementation class CoreExport ModuleManager { public: + /** List of all modules loaded in Anope + */ + static CoreExport std::list<Module *> Modules; + /** Event handler hooks. * This needs to be public to be used by FOREACH_MOD and friends. */ @@ -1124,7 +1133,8 @@ class CoreExport ModuleManager static ModuleReturn DeleteModule(Module *m); }; -/** Class used for callbacks within modules +/** Class used for callbacks within modules. These are identical to Timers hwoever + * they will be cleaned up automatically when a module is unloaded, and Timers will not. */ class CoreExport CallBack : public Timer { diff --git a/include/opertype.h b/include/opertype.h index 4e3f01e28..ccba85141 100644 --- a/include/opertype.h +++ b/include/opertype.h @@ -3,6 +3,7 @@ * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #ifndef OPERTYPE_H @@ -11,15 +12,22 @@ #include "services.h" #include "account.h" +/* A services operator. Usually made by the configuration file, but not always. + * NickAlias::Find(name)->nc->o == this + */ struct CoreExport Oper { + /* The oper's nick */ Anope::string name; + /* The type of operator this operator is */ OperType *ot; + /* Whether the user must be an IRC operator (umode +o) to be considered a services operator */ bool require_oper; Anope::string password; Anope::string certfp; + /* True if this operator is set in the config */ bool config; - + /* Hosts allowed to use this operator block */ std::vector<Anope::string> hosts; Anope::string vhost; diff --git a/include/protocol.h b/include/protocol.h index 4da0b5b3a..ec7061d38 100644 --- a/include/protocol.h +++ b/include/protocol.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef PROTOCOL_H @@ -16,14 +15,17 @@ #include "services.h" #include "anope.h" +#include "service.h" +/* Encapsultes the IRCd protocol we are speaking. */ class CoreExport IRCDProto { Anope::string proto_name; - IRCDProto() { } protected: IRCDProto(const Anope::string &proto_name); + public: + virtual ~IRCDProto(); virtual void SendSVSKillInternal(const BotInfo *, User *, const Anope::string &); virtual void SendModeInternal(const BotInfo *, const Channel *, const Anope::string &); @@ -37,8 +39,6 @@ class CoreExport IRCDProto virtual void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf); virtual void SendCTCPInternal(const BotInfo *bi, const Anope::string &dest, const Anope::string &buf); virtual void SendNumericInternal(int numeric, const Anope::string &dest, const Anope::string &buf); - public: - virtual ~IRCDProto(); const Anope::string &GetProtocolName(); /* Modes used by default by our clients */ @@ -66,53 +66,135 @@ class CoreExport IRCDProto /* The maximum number of modes we are allowed to set with one MODE command */ unsigned MaxModes; - virtual void SendSVSNOOP(const Server *, bool) { } + /** Sets the server in NOOP mode. If NOOP mode is enabled, no users + * will be able to oper on the server. + * @param s The server + * @param mode Whether to turn NOOP on or off + */ + virtual void SendSVSNOOP(const Server *s, bool mode) { } + + /** Sets the topic on a channel + * @param bi The bot to set the topic from + * @param c The channel to set the topic on. The topic being set is Channel::topic + */ virtual void SendTopic(BotInfo *, Channel *); + + /** Sets a vhost on a user. + * @param u The user + * @param vident The ident to set + * @param vhost The vhost to set + */ + virtual void SendVhost(User *u, const Anope::string &vident, const Anope::string &vhost) { } virtual void SendVhostDel(User *) { } + + /** Sets an akill. This is a recursive function that can be called multiple times + * for the same xline, but for different users, if the xline is not one that can be + * enforced by the IRCd, such as a nick/user/host/realname combination ban. + * @param u The user affected by the akill, if known + * @param x The akill + */ virtual void SendAkill(User *, XLine *) = 0; virtual void SendAkillDel(const XLine *) = 0; + + /* Realname ban */ + virtual void SendSGLine(User *, const XLine *) { } + virtual void SendSGLineDel(const XLine *) { } + + /* IP ban */ + virtual void SendSZLine(User *u, const XLine *) { } + virtual void SendSZLineDel(const XLine *) { } + + /* Nick ban (and sometimes channel) */ + virtual void SendSQLine(User *, const XLine *x) { } + virtual void SendSQLineDel(const XLine *x) { } + + /** Kills a user + * @param source The client used to kill the user, if any + * @param user The user to be killed + * @param fmt Kill reason + */ virtual void SendSVSKill(const BotInfo *source, User *user, const char *fmt, ...); + virtual void SendMode(const BotInfo *bi, const Channel *dest, const char *fmt, ...); virtual void SendMode(const BotInfo *bi, const User *u, const char *fmt, ...); + + /** Introduces a client to the rest of the network + * @param u The client to introduce + */ virtual void SendClientIntroduction(const User *u) = 0; + virtual void SendKick(const BotInfo *bi, const Channel *chan, const User *user, const char *fmt, ...); + + /* Sends a message using SendPrivmsg or SendNotice, depending on the default message method. */ virtual void SendMessage(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); virtual void SendNotice(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); - virtual void SendAction(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); virtual void SendPrivmsg(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); + virtual void SendAction(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); + virtual void SendCTCP(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); + virtual void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) = 0; virtual void SendGlobalPrivmsg(const BotInfo *bi, const Server *desc, const Anope::string &msg) = 0; virtual void SendQuit(const User *u, const char *fmt, ...); virtual void SendPing(const Anope::string &servname, const Anope::string &who); virtual void SendPong(const Anope::string &servname, const Anope::string &who); - virtual void SendJoin(const User *, Channel *, const ChannelStatus *) = 0; - virtual void SendSQLineDel(const XLine *x) { } - virtual void SendInvite(const BotInfo *bi, const Channel *c, const User *u); + + /** Joins one of our users to a channel. + * @param u The user to join + * @param c The channel to join the user to + * @param status The status to set on the user after joining. This may or may not already internally + * be set on the user. This may include the modes in the join, but will usually place them on the mode + * stacker to be set "soon". + */ + virtual void SendJoin(const User *u, Channel *c, const ChannelStatus *status) = 0; virtual void SendPart(const BotInfo *bi, const Channel *chan, const char *fmt, ...); + + /** Force joins a user that isn't ours to a channel. + * @param bi The source of the message + * @param nick The user to join + * @param chan The channel to join the user to + * @param param Channel key? + */ + virtual void SendSVSJoin(const BotInfo *bi, const Anope::string &nick, const Anope::string &chan, const Anope::string ¶m) { } + + virtual void SendInvite(const BotInfo *bi, const Channel *c, const User *u); virtual void SendGlobops(const BotInfo *source, const char *fmt, ...); - virtual void SendSQLine(User *, const XLine *x) { } - virtual void SendSquit(Server *, const Anope::string &message); + + /** Sets oper flags on a user, currently only supported by Unreal + */ virtual void SendSVSO(const BotInfo *, const Anope::string &, const Anope::string &) { } - virtual void SendChangeBotNick(const BotInfo *bi, const Anope::string &newnick); + + /** Sends a nick change of one of our clients. + */ + virtual void SendNickChange(const User *u, const Anope::string &newnick); + + /** Forces a nick change of a user that isn't ours (SVSNICK) + */ virtual void SendForceNickChange(const User *u, const Anope::string &newnick, time_t when); - virtual void SendVhost(User *, const Anope::string &, const Anope::string &) { } + + /** Used to introduce ourselves to our uplink. Usually will SendServer(Me) and any other + * initial handshake requirements. + */ virtual void SendConnect() = 0; + + /** Called right before we begin our burst, after we have handshaked successfully with the uplink/ + * At this point none of our servesr, users, or channels exist on the uplink + */ + virtual void SendBOB() { } + virtual void SendEOB() { } + virtual void SendSVSHold(const Anope::string &) { } virtual void SendSVSHoldDel(const Anope::string &) { } - virtual void SendSGLineDel(const XLine *) { } - virtual void SendSZLineDel(const XLine *) { } - virtual void SendSZLine(User *u, const XLine *) { } - virtual void SendSGLine(User *, const XLine *) { } - virtual void SendCTCP(const BotInfo *bi, const Anope::string &dest, const char *fmt, ...); - virtual void SendSVSJoin(const BotInfo *bi, const Anope::string &, const Anope::string &, const Anope::string &) { } + virtual void SendSWhois(const BotInfo *bi, const Anope::string &, const Anope::string &) { } - virtual void SendBOB() { } - virtual void SendEOB() { } + + /** Introduces a server to the uplink + */ virtual void SendServer(const Server *) = 0; - virtual bool IsNickValid(const Anope::string &) { return true; } - virtual bool IsChannelValid(const Anope::string &); + virtual void SendSquit(Server *, const Anope::string &message); + virtual void SendNumeric(int numeric, const Anope::string &dest, const char *fmt, ...); + virtual void SendLogin(User *u) = 0; virtual void SendLogout(User *u) = 0; @@ -125,6 +207,11 @@ class CoreExport IRCDProto * Normally this is a simple +o, though some IRCds require us to send the oper type */ virtual void SendOper(User *u); + + virtual bool IsNickValid(const Anope::string &); + virtual bool IsChannelValid(const Anope::string &); + virtual bool IsIdentValid(const Anope::string &); + virtual bool IsHostValid(const Anope::string &); }; enum IRCDMessageFlag @@ -150,21 +237,16 @@ class CoreExport MessageSource Server *GetServer(); }; -class CoreExport IRCDMessage : public Flags<IRCDMessageFlag, 3> +class CoreExport IRCDMessage : public Flags<IRCDMessageFlag>, public Service { - static std::map<Anope::string, std::vector<IRCDMessage *> > messages; - Anope::string name; unsigned param_count; public: - static const std::vector<IRCDMessage *> *Find(const Anope::string &name); - - IRCDMessage(const Anope::string &n, unsigned p = 0); - ~IRCDMessage(); + IRCDMessage(Module *owner, const Anope::string &n, unsigned p = 0); unsigned GetParamCount() const; virtual bool Run(MessageSource &, const std::vector<Anope::string> ¶ms) = 0; }; -extern CoreExport IRCDProto *ircdproto; +extern CoreExport IRCDProto *IRCD; #endif // PROTOCOL_H diff --git a/include/regchannel.h b/include/regchannel.h index a692dda4a..9e01963b8 100644 --- a/include/regchannel.h +++ b/include/regchannel.h @@ -1,15 +1,15 @@ -/* Modular support +/* * * (C) 2008-2012 Anope Team * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ #ifndef REGCHANNEL_H #define REGCHANNEL_H -#include "botserv.h" #include "memo.h" #include "modes.h" #include "extensible.h" @@ -20,7 +20,7 @@ typedef Anope::hash_map<ChannelInfo *> registered_channel_map; -extern CoreExport serialize_checker<registered_channel_map> RegisteredChannelList; +extern CoreExport Serialize::Checker<registered_channel_map> RegisteredChannelList; /** Flags used for the ChannelInfo class */ @@ -68,10 +68,57 @@ enum ChannelInfoFlag CI_END }; -const Anope::string ChannelInfoFlagStrings[] = { - "BEGIN", "KEEPTOPIC", "SECUREOPS", "PRIVATE", "TOPICLOCK", "RESTRICTED", - "PEACE", "SECURE", "NO_EXPIRE", "MEMO_HARDMAX", "SECUREFOUNDER", - "SIGNKICK", "SIGNKICK_LEVEL", "SUSPENDED", "PERSIST", "STATS", "NOAUTOOP", "" +/* BotServ SET flags (ChannelInfo::botflags) */ +enum BotServFlag +{ + BS_BEGIN, + /* BotServ won't kick ops */ + BS_DONTKICKOPS, + /* BotServ won't kick voices */ + BS_DONTKICKVOICES, + /* BotServ bot accepts fantasy commands */ + BS_FANTASY, + /* BotServ should show greets */ + BS_GREET, + /* BotServ bots are not allowed to be in this channel */ + BS_NOBOT, + /* BotServ kicks for bolds */ + BS_KICK_BOLDS, + /* BotServ kicks for colors */ + BS_KICK_COLORS, + /* BOtServ kicks for reverses */ + BS_KICK_REVERSES, + /* BotServ kicks for underlines */ + BS_KICK_UNDERLINES, + /* BotServ kicks for badwords */ + BS_KICK_BADWORDS, + /* BotServ kicks for caps */ + BS_KICK_CAPS, + /* BotServ kicks for flood */ + BS_KICK_FLOOD, + /* BotServ kicks for repeating */ + BS_KICK_REPEAT, + /* BotServ kicks for italics */ + BS_KICK_ITALICS, + /* BotServ kicks for amsgs */ + BS_KICK_AMSGS, + BS_END +}; + +/* Indices for TTB (Times To Ban) */ +enum +{ + TTB_BOLDS, + TTB_COLORS, + TTB_REVERSES, + TTB_UNDERLINES, + TTB_BADWORDS, + TTB_CAPS, + TTB_FLOOD, + TTB_REPEAT, + TTB_ITALICS, + TTB_AMSGS, + TTB_SIZE }; /** Flags for badwords @@ -96,8 +143,8 @@ struct CoreExport BadWord : Serializable BadWordType type; BadWord() : Serializable("BadWord") { } - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); }; /** Flags for auto kick @@ -108,31 +155,31 @@ enum AutoKickFlag AK_ISNICK }; -const Anope::string AutoKickFlagString[] = { "AK_ISNICK", "" }; - /* AutoKick data. */ class CoreExport AutoKick : public Flags<AutoKickFlag>, public Serializable { public: - AutoKick(); - serialize_obj<ChannelInfo> ci; - /* Only one of these can be in use */ + /* Channel this autokick is on */ + Serialize::Reference<ChannelInfo> ci; + + /* Only one of these can be in use. if HasFlag(AK_ISNICK) then nc is in use */ Anope::string mask; - serialize_obj<NickCore> nc; + Serialize::Reference<NickCore> nc; Anope::string reason; Anope::string creator; time_t addtime; time_t last_used; - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + AutoKick(); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); }; struct CoreExport ModeLock : Serializable { public: - serialize_obj<ChannelInfo> ci; + Serialize::Reference<ChannelInfo> ci; bool set; ChannelModeName name; Anope::string param; @@ -141,13 +188,13 @@ struct CoreExport ModeLock : Serializable ModeLock(ChannelInfo *ch, bool s, ChannelModeName n, const Anope::string &p, const Anope::string &se = "", time_t c = Anope::CurTime); - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); }; struct CoreExport LogSetting : Serializable { - serialize_obj<ChannelInfo> ci; + Serialize::Reference<ChannelInfo> ci; /* Our service name of the command */ Anope::string service_name; /* The name of the client the command is on */ @@ -159,67 +206,65 @@ struct CoreExport LogSetting : Serializable time_t created; LogSetting() : Serializable("LogSetting") { } - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); }; /* It matters that Base is here before Extensible (it is inherited by Serializable) */ -class CoreExport ChannelInfo : public Serializable, public Extensible, public Flags<ChannelInfoFlag, CI_END> +class CoreExport ChannelInfo : public Serializable, public Extensible, public Flags<ChannelInfoFlag> { private: - serialize_obj<NickCore> founder; /* Channel founder */ - serialize_checker<std::vector<ChanAccess *> > access; /* List of authorized users */ - serialize_checker<std::vector<AutoKick *> > akick; /* List of users to kickban */ - serialize_checker<std::vector<BadWord *> > badwords; /* List of badwords */ + Serialize::Reference<NickCore> founder; /* Channel founder */ + Serialize::Checker<std::vector<ChanAccess *> > access; /* List of authorized users */ + Serialize::Checker<std::vector<AutoKick *> > akick; /* List of users to kickban */ + Serialize::Checker<std::vector<BadWord *> > badwords; /* List of badwords */ std::map<Anope::string, int16_t> levels; public: typedef std::multimap<ChannelModeName, ModeLock *> ModeList; - serialize_checker<ModeList> mode_locks; - serialize_checker<std::vector<LogSetting *> > log_settings; - - /** Default constructor - * @param chname The channel name - */ - ChannelInfo(const Anope::string &chname); - - /** Copy constructor - * @param ci The ChannelInfo to copy settings to - */ - ChannelInfo(const ChannelInfo &ci); - - /** Default destructor - */ - ~ChannelInfo(); + Serialize::Checker<ModeList> mode_locks; + Serialize::Checker<std::vector<LogSetting *> > log_settings; - Anope::string name; /* Channel name */ - serialize_obj<NickCore> successor; /* Who gets the channel if the founder nick is dropped or expires */ + Anope::string name; /* Channel name */ + Serialize::Reference<NickCore> successor; /* Who gets the channel if the founder nick is dropped or expires */ Anope::string desc; time_t time_registered; time_t last_used; - Anope::string last_topic; /* The last topic that was set on this channel */ - Anope::string last_topic_setter; /* Setter */ - time_t last_topic_time; /* Time */ + Anope::string last_topic; /* The last topic that was set on this channel */ + Anope::string last_topic_setter; /* Setter */ + time_t last_topic_time; /* Time */ int16_t bantype; MemoInfo memos; - Channel *c; /* Pointer to channel record (if channel is currently in use) */ + Channel *c; /* Pointer to channel, if the channel exists */ /* For BotServ */ - serialize_obj<BotInfo> bi; /* Bot used on this channel */ + Serialize::Reference<BotInfo> bi; /* Bot used on this channel */ Flags<BotServFlag> botflags; - int16_t ttb[TTB_SIZE]; /* Times to ban for each kicker */ + int16_t ttb[TTB_SIZE]; /* Times to ban for each kicker */ + + int16_t capsmin, capspercent; /* For CAPS kicker */ + int16_t floodlines, floodsecs; /* For FLOOD kicker */ + int16_t repeattimes; /* For REPEAT kicker */ - int16_t capsmin, capspercent; /* For CAPS kicker */ - int16_t floodlines, floodsecs; /* For FLOOD kicker */ - int16_t repeattimes; /* For REPEAT kicker */ + /** Constructor + * @param chname The channel name + */ + ChannelInfo(const Anope::string &chname); - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &); + /** Copy constructor + * @param ci The ChannelInfo to copy settings to + */ + ChannelInfo(const ChannelInfo &ci); + + ~ChannelInfo(); + + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &); /** Change the founder of the channek * @params nc The new founder @@ -440,11 +485,26 @@ class CoreExport ChannelInfo : public Serializable, public Extensible, public Fl /** Clear all privileges from the channel */ void ClearLevels(); + + /** Gets a ban mask for the given user based on the bantype + * of the channel. + * @param u The user + * @return A ban mask that affects the user + */ + Anope::string GetIdealBan(User *u) const; + + /** Finds a ChannelInfo + * @param name channel name to lookup + * @return the ChannelInfo associated with the channel + */ + static ChannelInfo* Find(const Anope::string &name); }; -extern CoreExport ChannelInfo *cs_findchan(const Anope::string &chan); +/** Is the user the real founder? + * @param user The user + * @param ci The channel + * @return true or false + */ extern CoreExport bool IsFounder(const User *user, const ChannelInfo *ci); -extern CoreExport void update_cs_lastseen(User *user, ChannelInfo *ci); -extern CoreExport int get_idealban(const ChannelInfo *ci, User *u, Anope::string &ret); #endif // REGCHANNEL_H diff --git a/include/serialize.h b/include/serialize.h index 53bd096de..8b8497c40 100644 --- a/include/serialize.h +++ b/include/serialize.h @@ -25,54 +25,65 @@ namespace Serialize DT_TEXT, DT_INT }; -} -class CoreExport stringstream : public std::stringstream -{ - private: - Serialize::DataType type; - unsigned _max; + class CoreExport stringstream : public std::stringstream + { + private: + Serialize::DataType type; + unsigned _max; - public: - stringstream(); - stringstream(const stringstream &ss); - Anope::string astr() const; + public: + stringstream(); + stringstream(const stringstream &ss); + Anope::string astr() const; - template<typename T> std::istream &operator>>(T &val) - { - std::istringstream is(this->str()); - is >> val; - return *this; - } - std::istream &operator>>(Anope::string &val); + template<typename T> std::istream &operator>>(T &val) + { + std::istringstream is(this->str()); + is >> val; + return *this; + } + std::istream &operator>>(Anope::string &val); - bool operator==(const stringstream &other) const; - bool operator!=(const stringstream &other) const; + bool operator==(const stringstream &other) const; + bool operator!=(const stringstream &other) const; - stringstream &setType(Serialize::DataType t); - Serialize::DataType getType() const; - stringstream &setMax(unsigned m); - unsigned getMax() const; -}; + stringstream &SetType(Serialize::DataType t); + Serialize::DataType GetType() const; + stringstream &SetMax(unsigned m); + unsigned GetMax() const; + }; -namespace Serialize -{ typedef std::map<Anope::string, stringstream> Data; -} -extern void RegisterTypes(); + extern void RegisterTypes(); -class SerializeType; + class Type; + template<typename T> class Checker; + template<typename T> class Reference; +} +/** A serialziable object. Serializable objects can be serialized into + * a map of stringstreams (Serialize::Data), and then reconstructed or + * updated later at any time. + */ class CoreExport Serializable : public virtual Base { private: - static std::list<Serializable *> *serializable_items; - SerializeType *s_type; + /* A list of every serializable item in Anope. + * Some of these are static and constructed at runtime, + * so this list must be on the heap, as it is not always + * constructed before other objects are if it isn't. + */ + static std::list<Serializable *> *SerializableItems; + /* The type of item this object is */ + Serialize::Type *s_type; private: - std::list<Serializable *>::iterator s_iter; // Iterator into serializable_items - + /* Iterator into serializable_items */ + std::list<Serializable *>::iterator s_iter; + /* The last serialized form of this object commited to the database */ Serialize::Data last_commit; + /* The last time this object was commited to the database */ time_t last_commit_time; Serializable(); @@ -85,10 +96,16 @@ class CoreExport Serializable : public virtual Base Serializable &operator=(const Serializable &); public: + /* Unique ID (per type, not globally) for this object */ unsigned int id; - void destroy(); + /* Destroys this object. This is effectively the same thing as + * delete, however it properly cleans up after this object. + */ + void Destroy(); + /** Marks the object as potentially being updated "soon". + */ void QueueUpdate(); bool IsCached(); @@ -97,27 +114,43 @@ class CoreExport Serializable : public virtual Base bool IsTSCached(); void UpdateTS(); - SerializeType* GetSerializableType() const; + /** Get the type of serializable object this is + * @return The serializable object type + */ + Serialize::Type* GetSerializableType() const; - virtual Serialize::Data serialize() const = 0; + virtual Serialize::Data Serialize() const = 0; static const std::list<Serializable *> &GetItems(); }; -class CoreExport SerializeType +/* A serializable type. There should be one of these classes for each type + * of class that inherits from Serialiable. Used for unserializing objects + * of this type, as it requires a function pointer to a static member function. + */ +class CoreExport Serialize::Type { typedef Serializable* (*unserialize_func)(Serializable *obj, Serialize::Data &); - static std::vector<Anope::string> type_order; - static std::map<Anope::string, SerializeType *> types; + static std::vector<Anope::string> TypeOrder; + static std::map<Anope::string, Serialize::Type *> Types; + /* The name of this type, should be a class name */ Anope::string name; unserialize_func unserialize; + /* Owner of this type. Used for placing objects of this type in separate databases + * based on what module, if any, owns it. + */ Module *owner; + /* The timesatmp for this type. All objects of this type are as up to date as + * this timestamp. if curtime == timestamp then we have the most up to date + * version of every object of this type. + */ time_t timestamp; public: + /* Map of Serializable::id to Serializable objects */ std::map<unsigned int, Serializable *> objects; /** Creates a new serializable type @@ -125,44 +158,67 @@ class CoreExport SerializeType * @param f Func to unserialize objects * @param owner Owner of this type. Leave NULL for the core. */ - SerializeType(const Anope::string &n, unserialize_func f, Module *owner = NULL); - ~SerializeType(); + Type(const Anope::string &n, unserialize_func f, Module *owner = NULL); + ~Type(); + /** Gets the name for this type + * @return The name, eg "NickAlias" + */ const Anope::string &GetName(); + /** Unserialized an object. + * @param obj NULL if this object doesn't yet exist. If this isn't NULL, instead + * update the contents of this object. + * @param data The data to unserialize + * @return The unserialized object. If obj != NULL this should be obj. + */ Serializable *Unserialize(Serializable *obj, Serialize::Data &data); + /** Check if this object type has any pending changes and update them. + */ void Check(); + /** Gets the timestamp for the object type. That is, the time we know + * all objects of this type are updated at least to. + */ time_t GetTimestamp() const; + + /** Bumps object type timestamp to current time + */ void UpdateTimestamp(); Module* GetOwner() const; - static SerializeType *Find(const Anope::string &name); + static Serialize::Type *Find(const Anope::string &name); static const std::vector<Anope::string> &GetTypeOrder(); }; +/** Should be used to hold lists and other objects of a specific type, + * but not a specific object. Used for ensuring that any access to + * this object type is always up to date. These are usually constructed + * at run time, before main is called, so no types are registered. This + * is why there are static Serialize::Type* variables in every function. + */ template<typename T> -class serialize_checker +class Serialize::Checker { Anope::string name; T obj; public: - serialize_checker(const Anope::string &n) : name(n) { } + Checker(const Anope::string &n) : name(n) { } inline const T* operator->() const { - static SerializeType *type = SerializeType::Find(this->name); + static Serialize::Type *type = Serialize::Type::Find(this->name); if (type) type->Check(); return &this->obj; } inline T* operator->() { - static SerializeType *type = SerializeType::Find(this->name); + static Serialize::Type *type = Serialize::Type::Find(this->name); if (type) type->Check(); return &this->obj; @@ -170,14 +226,14 @@ class serialize_checker inline const T& operator*() const { - static SerializeType *type = SerializeType::Find(this->name); + static Serialize::Type *type = Serialize::Type::Find(this->name); if (type) type->Check(); return this->obj; } inline T& operator*() { - static SerializeType *type = SerializeType::Find(this->name); + static Serialize::Type *type = Serialize::Type::Find(this->name); if (type) type->Check(); return this->obj; @@ -185,44 +241,50 @@ class serialize_checker inline operator const T&() const { - static SerializeType *type = SerializeType::Find(this->name); + static Serialize::Type *type = Serialize::Type::Find(this->name); if (type) type->Check(); return this->obj; } inline operator T&() { - static SerializeType *type = SerializeType::Find(this->name); + static Serialize::Type *type = Serialize::Type::Find(this->name); if (type) type->Check(); return this->obj; } }; +/** Used to hold references to serializable objects. Reference should always be + * used when holding references to serializable objects for extended periods of time + * to ensure that the object it refers to it always up to date. This also behaves like + * Reference in that it will invalidate itself if the object it refers to is + * destructed. + */ template<typename T> -class serialize_obj : public dynamic_reference_base +class Serialize::Reference : public ReferenceBase { protected: T *ref; public: - serialize_obj() : ref(NULL) + Reference() : ref(NULL) { } - serialize_obj(T *obj) : ref(obj) + Reference(T *obj) : ref(obj) { if (obj) obj->AddReference(this); } - serialize_obj(const serialize_obj<T> &other) : ref(other.ref) + Reference(const Reference<T> &other) : ref(other.ref) { if (*this) this->ref->AddReference(this); } - ~serialize_obj() + ~Reference() { if (*this) this->ref->DelReference(this); diff --git a/include/servers.h b/include/servers.h index 339b4db19..216679cc0 100644 --- a/include/servers.h +++ b/include/servers.h @@ -1,3 +1,15 @@ +/* + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + #ifndef SERVERS_H #define SERVERS_H @@ -5,13 +17,25 @@ #include "anope.h" #include "extensible.h" -/* Anope */ +/* Anope. We are at the top of the server tree, our uplink is + * almost always me->GetLinks()[0]. We never have an uplink. */ extern CoreExport Server *Me; -extern CoreExport const Anope::string ts6_uid_retrieve(); -extern CoreExport const Anope::string ts6_sid_retrieve(); +namespace Servers +{ + /* Retrieves the next free TS6 UID or SID */ + extern CoreExport const Anope::string TS6_UID_Retrieve(); + extern CoreExport const Anope::string TS6_SID_Retrieve(); + + /* Gets our uplink. Note we don't actually have an "uplink", this is just + * the only server whose uplink *is* Me that is not a juped server. + * @return Our uplink, or NULL if not uplinked to anything + */ + extern CoreExport Server* GetUplink(); -extern CoreExport std::set<Anope::string> Capab; + /* CAPAB/PROTOCTL given by the uplink */ + extern CoreExport std::set<Anope::string> Capab; +} /** Flags set on servers */ @@ -24,28 +48,26 @@ enum ServerFlag SERVER_JUPED }; -const Anope::string ServerFlagStrings[] = { "SERVER_NONE", "SERVER_SYNCING", "SERVER_JUPED", "" }; - /** Class representing a server */ class CoreExport Server : public Flags<ServerFlag>, public Extensible { private: /* Server name */ - Anope::string Name; + Anope::string name; /* Hops between services and server */ - unsigned int Hops; + unsigned int hops; /* Server description */ - Anope::string Description; + Anope::string description; /* Server ID */ - Anope::string SID; + Anope::string sid; /* Links for this server */ - std::vector<Server *> Links; + std::vector<Server *> links; /* Uplink for this server */ - Server *UplinkServer; + Server *uplink; /* Reason this server was quit */ - Anope::string QReason; + Anope::string quit_reason; public: /** Constructor @@ -65,7 +87,7 @@ class CoreExport Server : public Flags<ServerFlag>, public Extensible public: /* Number of users on the server */ - unsigned Users; + unsigned users; /** Delete this server with a reason * @param reason The reason @@ -125,7 +147,7 @@ class CoreExport Server : public Flags<ServerFlag>, public Extensible /** Finish syncing this server and optionally all links to it * @param SyncLinks True to sync the links for this server too (if any) */ - void Sync(bool SyncLinks); + void Sync(bool sync_links); /** Check if this server is synced * @return true or false diff --git a/include/service.h b/include/service.h index 95c650076..f2f553eb2 100644 --- a/include/service.h +++ b/include/service.h @@ -1,4 +1,5 @@ /* + * * (C) 2003-2012 Anope Team * Contact us at team@anope.org * @@ -6,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #ifndef SERVICE_H @@ -15,18 +17,34 @@ #include "anope.h" #include "modules.h" +/** Anything that inherits from this class can be referred to + * using ServiceReference. Any interfaces provided by modules, + * such as commands, use this. This is also used for modules + * that publish a service (m_ssl, etc). + */ class CoreExport Service : public virtual Base { - static std::map<Anope::string, std::map<Anope::string, Service *> > services; + static std::map<Anope::string, std::map<Anope::string, Service *> > Services; + static std::map<Anope::string, std::map<Anope::string, Anope::string> > Aliases; public: static Service *FindService(const Anope::string &t, const Anope::string &n) { - std::map<Anope::string, std::map<Anope::string, Service *> >::iterator it = services.find(t); - if (it != services.end()) + std::map<Anope::string, std::map<Anope::string, Service *> >::iterator it = Services.find(t); + if (it != Services.end()) { - std::map<Anope::string, Service *>::iterator it2 = it->second.find(n); - if (it2 != it->second.end()) - return it2->second; + Anope::string name = n; + + std::map<Anope::string, std::map<Anope::string, Anope::string> >::iterator it2 = Aliases.find(t); + if (it2 != Aliases.end()) + { + std::map<Anope::string, Anope::string>::iterator it3 = it2->second.find(n); + if (it3 != it2->second.end()) + name = it3->second; + } + + std::map<Anope::string, Service *>::iterator it4 = it->second.find(name); + if (it4 != it->second.end()) + return it4->second; } return NULL; @@ -35,15 +53,31 @@ class CoreExport Service : public virtual Base static std::vector<Anope::string> GetServiceKeys(const Anope::string &t) { std::vector<Anope::string> keys; - std::map<Anope::string, std::map<Anope::string, Service *> >::iterator it = services.find(t); - if (it != services.end()) + std::map<Anope::string, std::map<Anope::string, Service *> >::iterator it = Services.find(t); + if (it != Services.end()) for (std::map<Anope::string, Service *>::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) keys.push_back(it2->first); return keys; } + static void AddAlias(const Anope::string &t, const Anope::string &n, const Anope::string &v) + { + std::map<Anope::string, Anope::string> &smap = Aliases[t]; + smap[n] = v; + } + + static void DelAlias(const Anope::string &t, const Anope::string &n) + { + std::map<Anope::string, Anope::string> &smap = Aliases[t]; + smap.erase(n); + if (smap.empty()) + Aliases.erase(t); + } + Module *owner; + /* Service type, which should be the class name (eg "Command") */ Anope::string type; + /* Service name, commands are usually named service/command */ Anope::string name; Service(Module *o, const Anope::string &t, const Anope::string &n) : owner(o), type(t), name(n) @@ -58,7 +92,7 @@ class CoreExport Service : public virtual Base void Register() { - std::map<Anope::string, Service *> &smap = services[this->type]; + std::map<Anope::string, Service *> &smap = Services[this->type]; if (smap.find(this->name) != smap.end()) throw ModuleException("Service " + this->type + " with name " + this->name + " already exists"); smap[this->name] = this; @@ -66,29 +100,32 @@ class CoreExport Service : public virtual Base void Unregister() { - std::map<Anope::string, Service *> &smap = services[this->type]; + std::map<Anope::string, Service *> &smap = Services[this->type]; smap.erase(this->name); if (smap.empty()) - services.erase(this->type); + Services.erase(this->type); } }; +/** Like Reference, but used to refer to Services. + */ template<typename T> -class service_reference : public dynamic_reference<T> +class ServiceReference : public Reference<T> { Anope::string type; Anope::string name; public: - service_reference() : dynamic_reference<T>(NULL) { } + ServiceReference() { } - service_reference(const Anope::string &t, const Anope::string &n) : dynamic_reference<T>(NULL), type(t), name(n) + ServiceReference(const Anope::string &t, const Anope::string &n) : type(t), name(n) { } inline void operator=(const Anope::string &n) { this->name = n; + this->invalid = true; } operator bool() anope_override @@ -100,6 +137,10 @@ class service_reference : public dynamic_reference<T> } if (!this->ref) { + /* This really could be dynamic_cast in every case, except for when a module + * creates its own service type (that other modules must include the header file + * for), as the core is not compiled with it so there is no RTTI for it. + */ this->ref = static_cast<T *>(Service::FindService(this->type, this->name)); if (this->ref) this->ref->AddReference(this); @@ -108,5 +149,20 @@ class service_reference : public dynamic_reference<T> } }; +class ServiceAlias +{ + Anope::string t, f; + public: + ServiceAlias(const Anope::string &type, const Anope::string &from, const Anope::string &to) : t(type), f(from) + { + Service::AddAlias(type, from, to); + } + + ~ServiceAlias() + { + Service::DelAlias(t, f); + } +}; + #endif // SERVICE_H diff --git a/include/services.h b/include/services.h index 4b21bac2a..0405206d2 100644 --- a/include/services.h +++ b/include/services.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef SERVICES_H @@ -66,13 +65,4 @@ # include "anope_windows.h" #endif -/** - * RFC: defination of a valid nick - * nickname = ( letter / special ) *8( letter / digit / special / "-" ) - * letter = %x41-5A / %x61-7A ; A-Z / a-z - * digit = %x30-39 ; 0-9 - * special = %x5B-60 / %x7B-7D ; "[", "]", "\", "`", "_", "^", "{", "|", "}" - **/ -#define isvalidnick(c) (isalnum(c) || ((c) >= '\x5B' && (c) <= '\x60') || ((c) >= '\x7B' && (c) <= '\x7D') || (c) == '-') - #endif // SERVICES_H diff --git a/include/signals.h b/include/signals.h index f057bdfee..771404f52 100644 --- a/include/signals.h +++ b/include/signals.h @@ -8,7 +8,6 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * */ #ifndef SIGNAL_H diff --git a/include/socketengine.h b/include/socketengine.h index 8effb79f1..5f4bc5980 100644 --- a/include/socketengine.h +++ b/include/socketengine.h @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #ifndef SOCKETENGINE_H @@ -17,7 +18,7 @@ class CoreExport SocketEngine { - static const int DefaultSize = 4; // Uplink, DNS, Signal handler, Mode stacker + static const int DefaultSize = 8; // Uplink, DNS, Signal handlers, Mode stacker public: /* Map of sockets */ static std::map<int, Socket *> Sockets; diff --git a/include/sockets.h b/include/sockets.h index 6fa6c4075..24c993d9e 100644 --- a/include/sockets.h +++ b/include/sockets.h @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #ifndef SOCKETS_H @@ -104,12 +105,12 @@ class CoreExport cidr class SocketException : public CoreException { public: - /** Default constructor for socket exceptions + /** Constructor for socket exceptions * @param message Error message */ SocketException(const Anope::string &message) : CoreException(message) { } - /** Default destructor + /** Destructor * @throws Nothing */ virtual ~SocketException() throw() { } @@ -126,9 +127,6 @@ enum SocketFlag SF_ACCEPTED }; -static const Anope::string SocketFlagStrings[] = { "SF_DEAD", "SF_WRITABLE", "SF_CONNECTING", "SF_CONNECTED", "SF_ACCEPTING", "SF_ACCEPTED", "" }; - - class CoreExport SocketIO { public: @@ -189,29 +187,29 @@ class CoreExport Socket : public Flags<SocketFlag> { protected: /* Socket FD */ - int Sock; + int sock; /* Is this an IPv6 socket? */ - bool IPv6; + bool ipv6; public: /* Sockaddrs for bind() (if it's bound) */ sockaddrs bindaddr; /* I/O functions used for this socket */ - SocketIO *IO; + SocketIO *io; /** Empty constructor, should not be called. */ Socket(); - /** Default constructor + /** Constructor, possibly creates the socket and adds it to the engine * @param sock The socket to use, -1 if we need to create our own * @param ipv6 true if using ipv6 * @param type The socket type, defaults to SOCK_STREAM */ Socket(int sock, bool ipv6 = false, int type = SOCK_STREAM); - /** Default destructor + /** Destructor, closes the socket and removes it from the engine */ virtual ~Socket(); @@ -225,7 +223,7 @@ class CoreExport Socket : public Flags<SocketFlag> */ bool IsIPv6() const; - /** Mark a socket as blockig + /** Mark a socket as blocking * @return true if the socket is now blocking */ bool SetBlocking(); @@ -266,19 +264,14 @@ class CoreExport BufferedSocket : public virtual Socket { protected: /* Things to be written to the socket */ - Anope::string WriteBuffer; + Anope::string write_buffer; /* Part of a message sent from the server, but not totally received */ - Anope::string extrabuf; - /* How much data was received from this socket */ - int RecvLen; + Anope::string extra_buf; + /* How much data was received from this socket on this recv() */ + int recv_len; public: - /** Constructor - */ BufferedSocket(); - - /** Default destructor - */ virtual ~BufferedSocket(); /** Called when there is something to be received for this socket @@ -330,15 +323,11 @@ class CoreExport BinarySocket : public virtual Socket ~DataBlock(); }; - std::deque<DataBlock *> WriteBuffer; + /* Data to be written out */ + std::deque<DataBlock *> write_buffer; public: - /** Constructor - */ BinarySocket(); - - /** Default destructor - */ virtual ~BinarySocket(); /** Called when there is something to be received for this socket @@ -376,9 +365,6 @@ class CoreExport ListenSocket : public virtual Socket * @param ipv6 true for ipv6 */ ListenSocket(const Anope::string &bindip, int port, bool ipv6); - - /** Destructor - */ virtual ~ListenSocket(); /** Process what has come in from the connection @@ -435,7 +421,7 @@ class CoreExport ClientSocket : public virtual Socket { public: /* Listen socket this connection came from */ - ListenSocket *LS; + ListenSocket *ls; /* Clients address */ sockaddrs clientaddr; @@ -469,19 +455,14 @@ class CoreExport Pipe : public Socket { public: /** The FD of the write pipe (if this isn't evenfd) - * this->Sock is the readfd + * this->sock is the readfd */ - int WritePipe; + int write_pipe; - /** Constructor - */ Pipe(); - - /** Destructor - */ ~Pipe(); - /** Called when data is to be read + /** Called when data is to be read, reads the data then calls OnNotify */ bool ProcessRead() anope_override; @@ -489,13 +470,13 @@ class CoreExport Pipe : public Socket */ void Notify(); - /** Overload to do something useful + /** Called after ProcessRead comes back from Notify(), overload to do something useful */ virtual void OnNotify() = 0; }; extern CoreExport uint32_t TotalRead; extern CoreExport uint32_t TotalWritten; -extern CoreExport SocketIO normalSocketIO; +extern CoreExport SocketIO NormalSocketIO; #endif // SOCKET_H diff --git a/include/threadengine.h b/include/threadengine.h index 5d1752a8f..7eebed22f 100644 --- a/include/threadengine.h +++ b/include/threadengine.h @@ -1,3 +1,15 @@ +/* + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + #ifndef THREADENGINE_H #define THREADENGINE_H @@ -12,7 +24,7 @@ class CoreExport Thread : public Pipe, public Extensible public: /* Handle for this thread */ - pthread_t Handle; + pthread_t handle; /** Threads constructor */ diff --git a/include/timers.h b/include/timers.h index d5fc66fb0..d2597178b 100644 --- a/include/timers.h +++ b/include/timers.h @@ -4,8 +4,10 @@ * Contact us at team@anope.org * * Please read COPYING and README for further details. + * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #ifndef TIMERS_H @@ -33,14 +35,14 @@ class CoreExport Timer bool repeat; public: - /** Default constructor, initializes the triggering time + /** Constructor, initializes the triggering time * @param time_from_now The number of seconds from now to trigger the timer * @param now The time now * @param repeating Repeat this timer every time_from_now if this is true */ Timer(long time_from_now, time_t now = Anope::CurTime, bool repeating = false); - /** Default destructor, removes the timer from the list + /** Destructor, removes the timer from the list */ virtual ~Timer(); @@ -91,14 +93,14 @@ class CoreExport TimerManager static std::vector<Timer *> Timers; public: /** Add a timer to the list - * @param T A Timer derived class to add + * @param t A Timer derived class to add */ - static void AddTimer(Timer *T); + static void AddTimer(Timer *t); /** Deletes a timer - * @param T A Timer derived class to delete + * @param t A Timer derived class to delete */ - static void DelTimer(Timer *T); + static void DelTimer(Timer *t); /** Tick all pending timers * @param ctime The current time diff --git a/include/uplink.h b/include/uplink.h index 617a8aa1a..d635bd7d3 100644 --- a/include/uplink.h +++ b/include/uplink.h @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #ifndef UPLINK_H @@ -14,6 +15,12 @@ #include "sockets.h" +namespace Uplink +{ + extern void Connect(); +} + +/* This is the socket to our uplink */ class UplinkSocket : public ConnectionSocket, public BufferedSocket { public: @@ -22,10 +29,12 @@ class UplinkSocket : public ConnectionSocket, public BufferedSocket bool Read(const Anope::string &); void OnConnect(); void OnError(const Anope::string &); - + + /* A message sent over the uplink socket */ class CoreExport Message { private: + /* The source of the message, can be a server (Me), or any user (one of our bots) */ const Server *server; const User *user; std::stringstream buffer; diff --git a/include/users.h b/include/users.h index 17f3fac9f..ab7edeee3 100644 --- a/include/users.h +++ b/include/users.h @@ -1,8 +1,14 @@ /* - * Copyright (C) 2008-2011 Robin Burchell <w00t@inspircd.org> - * Copyright (C) 2008-2012 Anope Team <team@anope.org> + * + * (C) 2008-2011 Robin Burchell <w00t@inspircd.org> + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org * * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * */ #ifndef USERS_H @@ -19,18 +25,15 @@ typedef Anope::hash_map<User *> user_map; extern CoreExport user_map UserListByNick, UserListByUID; -class CoreExport ChannelStatus : public Flags<ChannelModeName, CMODE_END * 2> -{ - public: - ChannelStatus(); - Anope::string BuildCharPrefixList() const; - Anope::string BuildModePrefixList() const; -}; +extern CoreExport int OperCount; +extern CoreExport unsigned MaxUserCount; +extern CoreExport time_t MaxUserTime; +/* One per channel per user. Channel and status */ struct ChannelContainer { Channel *chan; - ChannelStatus *Status; + ChannelStatus *status; ChannelContainer(Channel *c) : chan(c) { } virtual ~ChannelContainer() { } @@ -38,7 +41,6 @@ struct ChannelContainer typedef std::list<ChannelContainer *> UChannelList; - /* Online user and channel data. */ class CoreExport User : public virtual Base, public Extensible, public CommandReply { @@ -46,36 +48,55 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe Anope::string vident; Anope::string ident; Anope::string uid; - bool OnAccess; /* If the user is on the access list of the nick theyre on */ - Flags<UserModeName, UMODE_END * 2> modes; /* Bitset of mode names the user has set on them */ - std::map<UserModeName, Anope::string> Params; /* Map of user modes and the params this user has */ - serialize_obj<NickCore> nc; /* NickCore account the user is currently loggged in as */ + /* If the user is on the access list of the nick theyre on */ + bool on_access; + /* Bitset of mode names the user has set on them */ + Flags<UserModeName> modes; + /* Map of user modes and the params this user has */ + std::map<UserModeName, Anope::string> mode_params; + /* NickCore account the user is currently loggged in as, if they are logged in */ + Serialize::Reference<NickCore> nc; + + /* # of invalid password attempts */ + unsigned short invalid_pw_count; + /* Time of last invalid password */ + time_t invalid_pw_time; + public: // XXX: exposing a tiny bit too much - Anope::string nick; /* User's current nick */ - - Anope::string host; /* User's real hostname */ - Anope::string vhost; /* User's virtual hostname */ - Anope::string chost; /* User's cloaked hostname */ - Anope::string realname; /* Realname */ - Anope::string fingerprint; /* SSL Fingerprint */ - Anope::string ip; /* User's IP */ - Server *server; /* Server user is connected to */ - time_t signon; /* When the user signed on. Set on connect and never modified. */ - time_t timestamp; /* Timestamp of the nick. Updated when the nick changes. */ - bool SuperAdmin; /* is SuperAdmin on or off? */ + /* User's current nick */ + Anope::string nick; + + /* User's real hostname */ + Anope::string host; + /* User's virtual hostname */ + Anope::string vhost; + /* User's cloaked hostname */ + Anope::string chost; + /* Realname */ + Anope::string realname; + /* SSL Fingerprint */ + Anope::string fingerprint; + /* User's IP */ + Anope::string ip; + /* Server user is connected to */ + Server *server; + /* When the user signed on. Set on connect and never modified. */ + time_t signon; + /* Timestamp of the nick. Updated when the nick changes. */ + time_t timestamp; + /* Is the user as super admin? */ + bool super_admin; /* Channels the user is in */ UChannelList chans; - unsigned short invalid_pw_count; /* # of invalid password attempts */ - time_t invalid_pw_time; /* Time of last invalid password */ - - time_t lastmemosend; /* Last time MS SEND command used */ - time_t lastnickreg; /* Last time NS REGISTER cmd used */ - time_t lastmail; /* Last time this user sent a mail */ - - /****************************************************************/ + /* Last time this user sent a memo command used */ + time_t lastmemosend; + /* Last time this user registered */ + time_t lastnickreg; + /* Last time this user sent an email */ + time_t lastmail; /** Create a new user object, initialising necessary fields and * adds it to the hash @@ -152,7 +173,7 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe */ const Anope::string &GetIdent() const; - /** Get the full mask ( nick!ident@realhost ) of a user + /** Get the full mask (nick!ident@realhost) of a user */ Anope::string GetMask() const; @@ -201,16 +222,16 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe virtual NickCore *Account() const; /** Check if the user is identified for their nick - * @param CheckNick True to check if the user is identified to the nickname they are on too + * @param check_nick True to check if the user is identified to the nickname they are on too * @return true or false */ - bool IsIdentified(bool CheckNick = false) const; + bool IsIdentified(bool check_nick = false) const; /** Check if the user is recognized for their nick (on the nicks access list) - * @param CheckSecure Only returns true if the user has secure off + * @param check_nick Only returns true if the user has secure off * @return true or false */ - bool IsRecognized(bool CheckSecure = true) const; + bool IsRecognized(bool check_nick = true) const; /** Check if the user is a services oper * @return true if they are an oper @@ -243,7 +264,7 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe * @param um The user mode * @param Param The param, if there is one */ - void SetModeInternal(UserMode *um, const Anope::string &Param = ""); + void SetModeInternal(UserMode *um, const Anope::string ¶m = ""); /** Remove a mode internally on the user, the IRCd is not informed * @param um The user mode @@ -255,14 +276,14 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe * @param um The user mode * @param Param Optional param for the mode */ - void SetMode(const BotInfo *bi, UserMode *um, const Anope::string &Param = ""); + void SetMode(const BotInfo *bi, UserMode *um, const Anope::string ¶m = ""); /** Set a mode on the user * @param bi The client setting the mode - * @param Name The mode name + * @param name The mode name * @param Param Optional param for the mode */ - void SetMode(const BotInfo *bi, UserModeName Name, const Anope::string &Param = ""); + void SetMode(const BotInfo *bi, UserModeName name, const Anope::string ¶m = ""); /** Remove a mode on the user * @param bi The client setting the mode @@ -272,9 +293,9 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe /** Remove a mode from the user * @param bi The client setting the mode - * @param Name The mode name + * @param name The mode name */ - void RemoveMode(const BotInfo *bi, UserModeName Name); + void RemoveMode(const BotInfo *bi, UserModeName name); /** Set a string of modes on a user * @param bi The client setting the modes @@ -316,16 +337,28 @@ class CoreExport User : public virtual Base, public Extensible, public CommandRe * @param reason The reason for the kill */ void KillInternal(const Anope::string &source, const Anope::string &reason); -}; - -extern CoreExport int32_t opcnt; -extern CoreExport uint32_t maxusercnt, usercnt; -extern CoreExport time_t maxusertime; -extern CoreExport User *finduser(const Anope::string &nick); + /* Returns a mask that will most likely match any address the + * user will have from that location. For IP addresses, wildcards the + * appropriate subnet mask (e.g. 35.1.1.1 -> 35.*; 128.2.1.1 -> 128.2.*); + * for named addresses, wildcards the leftmost part of the name unless the + * name only contains two parts. If the username begins with a ~, delete + * it. + */ + Anope::string Mask() const; -extern CoreExport bool matches_list(Channel *c, User *user, ChannelModeName mode); + /** Notes the usage of an incorrect password. If too many + * incorrect passwords are used the user might be killed. + * @return true if the user was killed + */ + bool BadPassword(); -extern CoreExport Anope::string create_mask(User *u); + /** Finds a user by nick, or possibly UID + * @param name The nick, or possibly UID, to lookup + * @param nick_only set to true to only look up by nick, not UID + * @return the user, if they exist + */ + static User* Find(const Anope::string &name, bool nick_only = false); +}; #endif // USERS_H diff --git a/include/oper.h b/include/xline.h index 6a18d3e2b..5d407d4ba 100644 --- a/include/oper.h +++ b/include/xline.h @@ -1,29 +1,31 @@ -/* OperServ support +/* * * (C) 2008-2012 Anope Team * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ -#ifndef OPER_H -#define OPER_H +#ifndef XLINE_H +#define XLINE_H #include "serialize.h" #include "service.h" +/* An Xline, eg, anything added with operserv/akill, or any of the operserv/sxline commands */ class CoreExport XLine : public Serializable { void InitRegex(); public: - Anope::string Mask; + Anope::string mask; Regex *regex; - Anope::string By; - time_t Created; - time_t Expires; - Anope::string Reason; + Anope::string by; + time_t created; + time_t expires; + Anope::string reason; XLineManager *manager; - Anope::string UID; + Anope::string id; XLine(const Anope::string &mask, const Anope::string &reason = "", const Anope::string &uid = ""); @@ -40,17 +42,18 @@ class CoreExport XLine : public Serializable bool HasNickOrReal() const; bool IsRegex() const; - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &data); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data); }; +/* Managers XLines. There is one XLineManager per type of XLine. */ class CoreExport XLineManager : public Service { char type; /* List of XLines in this XLineManager */ - serialize_checker<std::vector<XLine *> > XLines; + Serialize::Checker<std::vector<XLine *> > xlines; /* Akills can have the same IDs, sometimes */ - static serialize_checker<std::multimap<Anope::string, XLine *, ci::less> > XLinesByUID; + static Serialize::Checker<std::multimap<Anope::string, XLine *, ci::less> > XLinesByUID; public: /* List of XLine managers we check users against in XLineManager::CheckAll */ static std::list<XLineManager *> XLineManagers; @@ -174,4 +177,4 @@ class CoreExport XLineManager : public Service virtual void SendDel(XLine *x) = 0; }; -#endif // OPER_H +#endif // XLINE_H diff --git a/modules/commands/bs_assign.cpp b/modules/commands/bs_assign.cpp index 874c40015..ac809b952 100644 --- a/modules/commands/bs_assign.cpp +++ b/modules/commands/bs_assign.cpp @@ -27,20 +27,20 @@ class CommandBSAssign : public Command const Anope::string &chan = params[0]; const Anope::string &nick = params[1]; - if (readonly) + if (Anope::ReadOnly) { source.Reply(BOT_ASSIGN_READONLY); return; } - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); return; } - BotInfo *bi = findbot(nick); + BotInfo *bi = BotInfo::Find(nick, true); if (!bi) { source.Reply(BOT_DOES_NOT_EXIST, nick.c_str()); @@ -95,13 +95,13 @@ class CommandBSUnassign : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (readonly) + if (Anope::ReadOnly) { source.Reply(BOT_ASSIGN_READONLY); return; } - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/bs_badwords.cpp b/modules/commands/bs_badwords.cpp index ad7a49085..36a83b717 100644 --- a/modules/commands/bs_badwords.cpp +++ b/modules/commands/bs_badwords.cpp @@ -19,10 +19,10 @@ class BadwordsDelCallback : public NumberList CommandSource &source; ChannelInfo *ci; Command *c; - unsigned Deleted; + unsigned deleted; bool override; public: - BadwordsDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, const Anope::string &list) : NumberList(list, true), source(_source), ci(_ci), c(_c), Deleted(0), override(false) + BadwordsDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, const Anope::string &list) : NumberList(list, true), source(_source), ci(_ci), c(_c), deleted(0), override(false) { if (!source.AccessFor(ci).HasPriv("BADWORDS") && source.HasPriv("botserv/administration")) this->override = true; @@ -30,12 +30,12 @@ class BadwordsDelCallback : public NumberList ~BadwordsDelCallback() { - if (!Deleted) + if (!deleted) source.Reply(_("No matching entries on %s bad words list."), ci->name.c_str()); - else if (Deleted == 1) + else if (deleted == 1) source.Reply(_("Deleted 1 entry from %s bad words list."), ci->name.c_str()); else - source.Reply(_("Deleted %d entries from %s bad words list."), Deleted, ci->name.c_str()); + source.Reply(_("Deleted %d entries from %s bad words list."), deleted, ci->name.c_str()); } void HandleNumber(unsigned Number) anope_override @@ -44,7 +44,7 @@ class BadwordsDelCallback : public NumberList return; Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, c, ci) << "DEL " << ci->GetBadWord(Number - 1)->word; - ++Deleted; + ++deleted; ci->EraseBadWord(Number - 1); } }; @@ -58,7 +58,7 @@ class CommandBSBadwords : public Command Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "LIST"; ListFormatter list; - list.addColumn("Number").addColumn("Word").addColumn("Type"); + list.AddColumn("Number").AddColumn("Word").AddColumn("Type"); if (!ci->GetBadWordCount()) { @@ -86,7 +86,7 @@ class CommandBSBadwords : public Command entry["Number"] = stringify(Number); entry["Word"] = bw->word; entry["Type"] = bw->type == BW_SINGLE ? "(SINGLE)" : (bw->type == BW_START ? "(START)" : (bw->type == BW_END ? "(END)" : "")); - this->list.addEntry(entry); + this->list.AddEntry(entry); } } nl_list(list, ci, word); @@ -105,11 +105,11 @@ class CommandBSBadwords : public Command entry["Number"] = stringify(i + 1); entry["Word"] = bw->word; entry["Type"] = bw->type == BW_SINGLE ? "(SINGLE)" : (bw->type == BW_START ? "(START)" : (bw->type == BW_END ? "(END)" : "")); - list.addEntry(entry); + list.AddEntry(entry); } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on %s badword list."), ci->name.c_str()); else { @@ -241,7 +241,7 @@ class CommandBSBadwords : public Command return; } - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -254,7 +254,7 @@ class CommandBSBadwords : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, channel bad words list modification is temporarily disabled.")); return; diff --git a/modules/commands/bs_bot.cpp b/modules/commands/bs_bot.cpp index de7fa1128..8246692d0 100644 --- a/modules/commands/bs_bot.cpp +++ b/modules/commands/bs_bot.cpp @@ -23,7 +23,7 @@ class CommandBSBot : public Command const Anope::string &host = params[3]; const Anope::string &real = params[4]; - if (findbot(nick)) + if (BotInfo::Find(nick, true)) { source.Reply(_("Bot \002%s\002 already exists."), nick.c_str()); return; @@ -47,46 +47,30 @@ class CommandBSBot : public Command return; } - /* Check the nick is valid re RFC 2812 */ - if (isdigit(nick[0]) || nick[0] == '-') + if (!IRCD->IsNickValid(nick)) { source.Reply(_("Bot Nicks may only contain valid nick characters.")); return; } - for (unsigned i = 0, end = nick.length(); i < end && i < Config->NickLen; ++i) - if (!isvalidnick(nick[i])) - { - source.Reply(_("Bot Nicks may only contain valid nick characters.")); - return; - } - - /* check for hardcored ircd forbidden nicks */ - if (!ircdproto->IsNickValid(nick)) + /* Check the host is valid */ + if (!IRCD->IsHostValid(host)) { - source.Reply(_("Bot Nicks may only contain valid nick characters.")); + source.Reply(_("Bot Hosts may only contain valid host characters.")); return; } - /* Check the host is valid */ - if (!IsValidHost(host)) + if (!IRCD->IsIdentValid(user)) { - source.Reply(_("Bot Hosts may only contain valid host characters.")); + source.Reply(_("Bot Idents may only contain valid characters.")); return; } - for (unsigned i = 0, end = user.length(); i < end && i < Config->UserLen; ++i) - if (!isalnum(user[i])) - { - source.Reply(_("Bot Idents may only contain valid characters."), Config->UserLen); - return; - } - /* We check whether the nick is registered, and inform the user * if so. You need to drop the nick manually before you can use * it as a bot nick from now on -GD */ - if (findnick(nick)) + if (NickAlias::Find(nick)) { source.Reply(NICK_ALREADY_REGISTERED, nick.c_str()); return; @@ -116,16 +100,16 @@ class CommandBSBot : public Command return; } - BotInfo *bi = findbot(oldnick); + BotInfo *bi = BotInfo::Find(oldnick, true); if (!bi) { source.Reply(BOT_DOES_NOT_EXIST, oldnick.c_str()); return; } - if (!oldnick.equals_ci(nick) && nickIsServices(oldnick, false)) + if (bi->HasFlag(BI_CONF)) { - source.Reply(BOT_DOES_NOT_EXIST, oldnick.c_str()); + source.Reply(_("Bot %s is not changable."), bi->nick.c_str()); return; } @@ -147,12 +131,6 @@ class CommandBSBot : public Command return; } - if (!oldnick.equals_ci(nick) && nickIsServices(nick, false)) - { - source.Reply(BOT_DOES_NOT_EXIST, oldnick.c_str()); - return; - } - /* Checks whether there *are* changes. * Case sensitive because we may want to change just the case. * And we must finally check that the nick is not already @@ -164,42 +142,25 @@ class CommandBSBot : public Command return; } - /* Check the nick is valid re RFC 2812 */ - if (isdigit(nick[0]) || nick[0] == '-') + if (!IRCD->IsNickValid(nick)) { source.Reply(_("Bot Nicks may only contain valid nick characters.")); return; } - for (unsigned i = 0, end = nick.length(); i < end && i < Config->NickLen; ++i) - if (!isvalidnick(nick[i])) - { - source.Reply(_("Bot Nicks may only contain valid nick characters.")); - return; - } - - /* check for hardcored ircd forbidden nicks */ - if (!ircdproto->IsNickValid(nick)) + if (!host.empty() && !IRCD->IsHostValid(host)) { - source.Reply(_("Bot Nicks may only contain valid nick characters.")); + source.Reply(_("Bot Hosts may only contain valid host characters.")); return; } - if (!host.empty() && !IsValidHost(host)) + if (!user.empty() && !IRCD->IsIdentValid(user)) { - source.Reply(_("Bot Hosts may only contain valid host characters.")); + source.Reply(_("Bot Idents may only contain valid characters."), Config->UserLen); return; } - if (!user.empty()) - for (unsigned i = 0, end = user.length(); i < end && i < Config->UserLen; ++i) - if (!isalnum(user[i])) - { - source.Reply(_("Bot Idents may only contain valid characters."), Config->UserLen); - return; - } - - if (!nick.equals_ci(bi->nick) && findbot(nick)) + if (!nick.equals_ci(bi->nick) && BotInfo::Find(nick, true)) { source.Reply(_("Bot \002%s\002 already exists."), nick.c_str()); return; @@ -211,7 +172,7 @@ class CommandBSBot : public Command * if so. You need to drop the nick manually before you can use * it as a bot nick from now on -GD */ - if (findnick(nick)) + if (NickAlias::Find(nick)) { source.Reply(NICK_ALREADY_REGISTERED, nick.c_str()); return; @@ -219,19 +180,17 @@ class CommandBSBot : public Command /* The new nick is really different, so we remove the Q line for the old nick. */ XLine x_del(bi->nick); - ircdproto->SendSQLineDel(&x_del); + IRCD->SendSQLineDel(&x_del); /* Add a Q line for the new nick */ XLine x(nick, "Reserved for services"); - ircdproto->SendSQLine(NULL, &x); + IRCD->SendSQLine(NULL, &x); } if (!user.empty()) - ircdproto->SendQuit(bi, "Quit: Be right back"); + IRCD->SendQuit(bi, "Quit: Be right back"); else - { - ircdproto->SendChangeBotNick(bi, nick); - } + IRCD->SendNickChange(bi, nick); if (!nick.equals_cs(bi->nick)) bi->SetNewNick(nick); @@ -245,7 +204,7 @@ class CommandBSBot : public Command if (!user.empty()) { - ircdproto->SendClientIntroduction(bi); + IRCD->SendClientIntroduction(bi); bi->RejoinAll(); } @@ -266,16 +225,16 @@ class CommandBSBot : public Command return; } - BotInfo *bi = findbot(nick); + BotInfo *bi = BotInfo::Find(nick, true); if (!bi) { source.Reply(BOT_DOES_NOT_EXIST, nick.c_str()); return; } - if (nickIsServices(nick, false)) + if (bi->HasFlag(BI_CONF)) { - source.Reply(BOT_DOES_NOT_EXIST, nick.c_str()); + source.Reply(_("Bot %s is not deletable."), bi->nick.c_str()); return; } @@ -284,7 +243,7 @@ class CommandBSBot : public Command Log(LOG_ADMIN, source, this) << "DEL " << bi->nick; source.Reply(_("Bot \002%s\002 has been deleted."), nick.c_str()); - bi->destroy(); + bi->Destroy(); return; } public: @@ -300,7 +259,7 @@ class CommandBSBot : public Command { const Anope::string &cmd = params[0]; - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, bot modification is temporarily disabled.")); return; diff --git a/modules/commands/bs_botlist.cpp b/modules/commands/bs_botlist.cpp index a4a7c2586..1cdd93c45 100644 --- a/modules/commands/bs_botlist.cpp +++ b/modules/commands/bs_botlist.cpp @@ -27,7 +27,7 @@ class CommandBSBotList : public Command unsigned count = 0; ListFormatter list; - list.addColumn("Nick").addColumn("Mask"); + list.AddColumn("Nick").AddColumn("Mask"); for (botinfo_map::const_iterator it = BotListByNick->begin(), it_end = BotListByNick->end(); it != it_end; ++it) { @@ -39,7 +39,7 @@ class CommandBSBotList : public Command ListFormatter::ListEntry entry; entry["Nick"] = (bi->HasFlag(BI_PRIVATE) ? "* " : "") + bi->nick; entry["Mask"] = bi->GetIdent() + "@" + bi->host; - list.addEntry(entry); + list.AddEntry(entry); } } diff --git a/modules/commands/bs_control.cpp b/modules/commands/bs_control.cpp index 6957d0a78..3ee0401d6 100644 --- a/modules/commands/bs_control.cpp +++ b/modules/commands/bs_control.cpp @@ -26,7 +26,7 @@ class CommandBSSay : public Command { const Anope::string &text = params[1]; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -57,7 +57,7 @@ class CommandBSSay : public Command return; } - ircdproto->SendPrivmsg(ci->bi, ci->name, "%s", text.c_str()); + IRCD->SendPrivmsg(ci->bi, ci->name, "%s", text.c_str()); ci->bi->lastmsg = Anope::CurTime; // XXX need a way to find if someone is overriding this @@ -88,7 +88,7 @@ class CommandBSAct : public Command { Anope::string message = params[1]; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -117,7 +117,7 @@ class CommandBSAct : public Command while ((i = message.find(1)) && i != Anope::string::npos) message.erase(i, 1); - ircdproto->SendAction(ci->bi, ci->name, "%s", message.c_str()); + IRCD->SendAction(ci->bi, ci->name, "%s", message.c_str()); ci->bi->lastmsg = Anope::CurTime; // XXX Need to be able to find if someone is overriding this. diff --git a/modules/commands/bs_info.cpp b/modules/commands/bs_info.cpp index 199b17e3e..a4312cea6 100644 --- a/modules/commands/bs_info.cpp +++ b/modules/commands/bs_info.cpp @@ -44,7 +44,7 @@ class CommandBSInfo : public Command { if (!buf.empty()) buf += ", "; - buf += translate(nc, option); + buf += Language::Translate(nc, option); } } @@ -59,7 +59,7 @@ class CommandBSInfo : public Command { const Anope::string &query = params[0]; - const BotInfo *bi = findbot(query); + const BotInfo *bi = BotInfo::Find(query, true); ChannelInfo *ci; InfoFormatter info(source.nc); @@ -68,7 +68,7 @@ class CommandBSInfo : public Command source.Reply(_("Information for bot \002%s\002:"), bi->nick.c_str()); info[_("Mask")] = bi->GetIdent() + "@" + bi->host; info[_("Real name")] = bi->realname; - info[_("Created")] = do_strftime(bi->created); + info[_("Created")] = Anope::strftime(bi->created); info[_("Options")] = bi->HasFlag(BI_PRIVATE) ? _("Private") : _("None"); info[_("Used on")] = stringify(bi->GetChannelCount()) + " channel(s)"; @@ -87,7 +87,7 @@ class CommandBSInfo : public Command } } - else if ((ci = cs_findchan(query))) + else if ((ci = ChannelInfo::Find(query))) { if (!source.AccessFor(ci).HasPriv("FOUNDER") && !source.HasPriv("botserv/administration")) { @@ -98,8 +98,8 @@ class CommandBSInfo : public Command source.Reply(CHAN_INFO_HEADER, ci->name.c_str()); info[_("Bot nick")] = ci->bi ? ci->bi->nick : "not assigned yet"; - Anope::string enabled = translate(source.nc, _("Enabled")); - Anope::string disabled = translate(source.nc, _("Disabled")); + Anope::string enabled = Language::Translate(source.nc, _("Enabled")); + Anope::string disabled = Language::Translate(source.nc, _("Disabled")); if (ci->botflags.HasFlag(BS_KICK_BADWORDS)) { diff --git a/modules/commands/bs_kick.cpp b/modules/commands/bs_kick.cpp index eeaccd5f9..3e569696e 100644 --- a/modules/commands/bs_kick.cpp +++ b/modules/commands/bs_kick.cpp @@ -30,9 +30,9 @@ class CommandBSKick : public Command const Anope::string &value = params[2]; const Anope::string &ttb = params.size() > 3 ? params[3] : ""; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); - if (readonly) + if (Anope::ReadOnly) source.Reply(_("Sorry, kicker configuration is temporarily disabled.")); else if (ci == NULL) source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -736,14 +736,12 @@ class BSKick : public Module /* Should not use == here because bd.ttb[ttbtype] could possibly be > ci->ttb[ttbtype] * if the TTB was changed after it was not set (0) before and the user had already been * kicked a few times. Bug #1056 - Adam */ - Anope::string mask; bd.ttb[ttbtype] = 0; - get_idealban(ci, u, mask); + Anope::string mask = ci->GetIdealBan(u); - if (ci->c) - ci->c->SetMode(NULL, CMODE_BAN, mask); + ci->c->SetMode(NULL, CMODE_BAN, mask); FOREACH_MOD(I_OnBotBan, OnBotBan(u, ci, mask)); } } @@ -756,7 +754,7 @@ class BSKick : public Module if (!ci || !ci->bi || !ci->c || !u || u->server->IsULined() || !ci->c->FindUser(u)) return; - Anope::string fmt = translate(u, message); + Anope::string fmt = Language::Translate(u, message); va_start(args, message); vsnprintf(buf, sizeof(buf), fmt.c_str(), args); va_end(args); @@ -895,7 +893,7 @@ class BSKick : public Module bool mustkick = false; /* Normalize the buffer */ - Anope::string nbuf = normalizeBuffer(realbuf); + Anope::string nbuf = Anope::NormalizeBuffer(realbuf); for (unsigned i = 0, end = ci->GetBadWordCount(); i < end; ++i) { diff --git a/modules/commands/bs_set.cpp b/modules/commands/bs_set.cpp index e169f3c83..6f458bec0 100644 --- a/modules/commands/bs_set.cpp +++ b/modules/commands/bs_set.cpp @@ -41,7 +41,7 @@ class CommandBSSet : public Command const CommandInfo &info = it->second; if (c_name.find_ci(this_name + " ") == 0) { - service_reference<Command> command("Command", info.name); + ServiceReference<Command> command("Command", info.name); if (command) { source.command = it->first; diff --git a/modules/commands/bs_set_dontkickops.cpp b/modules/commands/bs_set_dontkickops.cpp index 598dfdcea..5346074a6 100644 --- a/modules/commands/bs_set_dontkickops.cpp +++ b/modules/commands/bs_set_dontkickops.cpp @@ -24,7 +24,7 @@ class CommandBSSetDontKickOps : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -38,7 +38,7 @@ class CommandBSSetDontKickOps : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, bot option setting is temporarily disabled.")); return; diff --git a/modules/commands/bs_set_dontkickvoices.cpp b/modules/commands/bs_set_dontkickvoices.cpp index 05453296b..b4b0cd7ec 100644 --- a/modules/commands/bs_set_dontkickvoices.cpp +++ b/modules/commands/bs_set_dontkickvoices.cpp @@ -24,7 +24,7 @@ class CommandBSSetDontKickVoices : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -38,7 +38,7 @@ class CommandBSSetDontKickVoices : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, bot option setting is temporarily disabled.")); return; diff --git a/modules/commands/bs_set_fantasy.cpp b/modules/commands/bs_set_fantasy.cpp index 03bd40c70..29c722026 100644 --- a/modules/commands/bs_set_fantasy.cpp +++ b/modules/commands/bs_set_fantasy.cpp @@ -24,7 +24,7 @@ class CommandBSSetFantasy : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); const Anope::string &value = params[1]; if (ci == NULL) @@ -39,7 +39,7 @@ class CommandBSSetFantasy : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, bot option setting is temporarily disabled.")); return; diff --git a/modules/commands/bs_set_greet.cpp b/modules/commands/bs_set_greet.cpp index b74b0e5dd..ad5220203 100644 --- a/modules/commands/bs_set_greet.cpp +++ b/modules/commands/bs_set_greet.cpp @@ -24,7 +24,7 @@ class CommandBSSetGreet : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); const Anope::string &value = params[1]; if (ci == NULL) @@ -39,7 +39,7 @@ class CommandBSSetGreet : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, bot option setting is temporarily disabled.")); return; diff --git a/modules/commands/bs_set_nobot.cpp b/modules/commands/bs_set_nobot.cpp index 246864953..f3f749aa5 100644 --- a/modules/commands/bs_set_nobot.cpp +++ b/modules/commands/bs_set_nobot.cpp @@ -24,7 +24,7 @@ class CommandBSSetNoBot : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); const Anope::string &value = params[1]; if (ci == NULL) diff --git a/modules/commands/bs_set_private.cpp b/modules/commands/bs_set_private.cpp index 0cd055d00..920c97d37 100644 --- a/modules/commands/bs_set_private.cpp +++ b/modules/commands/bs_set_private.cpp @@ -24,7 +24,7 @@ class CommandBSSetPrivate : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - BotInfo *bi = findbot(params[0]); + BotInfo *bi = BotInfo::Find(params[0], true); const Anope::string &value = params[1]; if (bi == NULL) diff --git a/modules/commands/cs_access.cpp b/modules/commands/cs_access.cpp index 40414a336..ed6f4f7fa 100644 --- a/modules/commands/cs_access.cpp +++ b/modules/commands/cs_access.cpp @@ -36,12 +36,12 @@ class AccessChanAccess : public ChanAccess return this->ci->GetLevel(name) != ACCESS_INVALID && this->level >= this->ci->GetLevel(name); } - Anope::string Serialize() const + Anope::string AccessSerialize() const { return stringify(this->level); } - void Unserialize(const Anope::string &data) anope_override + void AccessUnserialize(const Anope::string &data) anope_override { this->level = convertTo<int>(data); } @@ -119,7 +119,7 @@ class CommandCSAccess : public Command bool override = false; - if ((!highest || *highest <= tmp_access) && !u_access.Founder) + if ((!highest || *highest <= tmp_access) && !u_access.founder) { if (source.HasPriv("chanserv/access/modify")) override = true; @@ -130,9 +130,9 @@ class CommandCSAccess : public Command } } - if (mask.find_first_of("!*@") == Anope::string::npos && !findnick(mask)) + if (mask.find_first_of("!*@") == Anope::string::npos && !NickAlias::Find(mask)) { - User *targ = finduser(mask); + User *targ = User::Find(mask, true); if (targ != NULL) mask = "*!*@" + targ->GetDisplayedHost(); else @@ -148,7 +148,7 @@ class CommandCSAccess : public Command if (mask.equals_ci(access->mask)) { /* Don't allow lowering from a level >= u_level */ - if ((!highest || *access >= *highest) && !u_access.Founder && !source.HasPriv("chanserv/access/modify")) + if ((!highest || *access >= *highest) && !u_access.founder && !source.HasPriv("chanserv/access/modify")) { source.Reply(ACCESS_DENIED); return; @@ -164,7 +164,7 @@ class CommandCSAccess : public Command return; } - service_reference<AccessProvider> provider("AccessProvider", "access/access"); + ServiceReference<AccessProvider> provider("AccessProvider", "access/access"); if (!provider) return; AccessChanAccess *access = anope_dynamic_static_cast<AccessChanAccess *>(provider->Create()); @@ -188,9 +188,9 @@ class CommandCSAccess : public Command { Anope::string mask = params[2]; - if (mask.find_first_of("!*@") == Anope::string::npos && !findnick(mask)) + if (mask.find_first_of("!*@") == Anope::string::npos && !NickAlias::Find(mask)) { - User *targ = finduser(mask); + User *targ = User::Find(mask, true); if (targ != NULL) mask = "*!*@" + targ->GetDisplayedHost(); else @@ -209,12 +209,12 @@ class CommandCSAccess : public Command CommandSource &source; ChannelInfo *ci; Command *c; - unsigned Deleted; + unsigned deleted; Anope::string Nicks; bool Denied; bool override; public: - AccessDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, const Anope::string &numlist) : NumberList(numlist, true), source(_source), ci(_ci), c(_c), Deleted(0), Denied(false), override(false) + AccessDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, const Anope::string &numlist) : NumberList(numlist, true), source(_source), ci(_ci), c(_c), deleted(0), Denied(false), override(false) { if (!source.AccessFor(ci).HasPriv("ACCESS_CHANGE") && source.HasPriv("chanserv/access/modify")) this->override = true; @@ -222,18 +222,18 @@ class CommandCSAccess : public Command ~AccessDelCallback() { - if (Denied && !Deleted) + if (Denied && !deleted) source.Reply(ACCESS_DENIED); - else if (!Deleted) + else if (!deleted) source.Reply(_("No matching entries on %s access list."), ci->name.c_str()); else { Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, c, ci) << "to delete " << Nicks; - if (Deleted == 1) + if (deleted == 1) source.Reply(_("Deleted 1 entry from %s access list."), ci->name.c_str()); else - source.Reply(_("Deleted %d entries from %s access list."), Deleted, ci->name.c_str()); + source.Reply(_("Deleted %d entries from %s access list."), deleted, ci->name.c_str()); } } @@ -247,13 +247,13 @@ class CommandCSAccess : public Command AccessGroup u_access = source.AccessFor(ci); const ChanAccess *u_highest = u_access.Highest(); - if ((!u_highest || *u_highest <= *access) && !u_access.Founder && !this->override && !access->mask.equals_ci(source.nc->display)) + if ((!u_highest || *u_highest <= *access) && !u_access.founder && !this->override && !access->mask.equals_ci(source.nc->display)) { Denied = true; return; } - ++Deleted; + ++deleted; if (!Nicks.empty()) Nicks += ", " + access->mask; else @@ -277,12 +277,12 @@ class CommandCSAccess : public Command ChanAccess *access = ci->GetAccess(i - 1); if (mask.equals_ci(access->mask)) { - if (!access->mask.equals_ci(source.nc->display) && !u_access.Founder && (!highest || *highest <= *access) && !source.HasPriv("chanserv/access/modify")) + if (!access->mask.equals_ci(source.nc->display) && !u_access.founder && (!highest || *highest <= *access) && !source.HasPriv("chanserv/access/modify")) source.Reply(ACCESS_DENIED); else { source.Reply(_("\002%s\002 deleted from %s access list."), access->mask.c_str(), ci->name.c_str()); - bool override = !u_access.Founder && !u_access.HasPriv("ACCESS_CHANGE") && !access->mask.equals_ci(source.nc->display); + bool override = !u_access.founder && !u_access.HasPriv("ACCESS_CHANGE") && !access->mask.equals_ci(source.nc->display); Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to delete " << access->mask; FOREACH_MOD(I_OnAccessDel, OnAccessDel(ci, source, access)); @@ -333,7 +333,7 @@ class CommandCSAccess : public Command if (access->last_seen == 0) timebuf = "Never"; else - timebuf = do_strftime(access->last_seen, NULL, true); + timebuf = Anope::strftime(access->last_seen, NULL, true); } ListFormatter::ListEntry entry; @@ -342,7 +342,7 @@ class CommandCSAccess : public Command entry["Mask"] = access->mask; entry["By"] = access->creator; entry["Last seen"] = timebuf; - this->list.addEntry(entry); + this->list.AddEntry(entry); } } nl_list(list, ci, nick); @@ -367,7 +367,7 @@ class CommandCSAccess : public Command if (access->last_seen == 0) timebuf = "Never"; else - timebuf = do_strftime(access->last_seen, NULL, true); + timebuf = Anope::strftime(access->last_seen, NULL, true); } ListFormatter::ListEntry entry; @@ -376,11 +376,11 @@ class CommandCSAccess : public Command entry["Mask"] = access->mask; entry["By"] = access->creator; entry["Last seen"] = timebuf; - list.addEntry(entry); + list.AddEntry(entry); } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on %s access list."), ci->name.c_str()); else { @@ -407,7 +407,7 @@ class CommandCSAccess : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Level").addColumn("Mask"); + list.AddColumn("Number").AddColumn("Level").AddColumn("Mask"); this->ProcessList(source, ci, params, list); } @@ -420,7 +420,7 @@ class CommandCSAccess : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Level").addColumn("Mask").addColumn("By").addColumn("Last seen"); + list.AddColumn("Number").AddColumn("Level").AddColumn("Mask").AddColumn("By").AddColumn("Last seen"); this->ProcessList(source, ci, params, list); } @@ -460,7 +460,7 @@ class CommandCSAccess : public Command const Anope::string &nick = params.size() > 2 ? params[2] : ""; const Anope::string &s = params.size() > 3 ? params[3] : ""; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -480,7 +480,7 @@ class CommandCSAccess : public Command has_access = true; else if (is_del) { - const NickAlias *na = findnick(nick); + const NickAlias *na = NickAlias::Find(nick); if (na && na->nc == source.GetAccount()) has_access = true; } @@ -492,7 +492,7 @@ class CommandCSAccess : public Command this->OnSyntaxError(source, cmd); else if (!has_access) source.Reply(ACCESS_DENIED); - else if (readonly && !is_list) + else if (Anope::ReadOnly && !is_list) source.Reply(_("Sorry, channel access list modification is temporarily disabled.")); else if (cmd.equals_ci("ADD")) this->DoAdd(source, ci, params); @@ -652,7 +652,7 @@ class CommandCSLevels : public Command source.Reply(_("Access level settings for channel %s:"), ci->name.c_str()); ListFormatter list; - list.addColumn("Name").addColumn("Level"); + list.AddColumn("Name").AddColumn("Level"); const std::vector<Privilege> &privs = PrivilegeManager::GetPrivileges(); @@ -671,7 +671,7 @@ class CommandCSLevels : public Command else entry["Level"] = stringify(j); - list.addEntry(entry); + list.AddEntry(entry); } std::vector<Anope::string> replies; @@ -709,7 +709,7 @@ class CommandCSLevels : public Command const Anope::string &what = params.size() > 2 ? params[2] : ""; const Anope::string &s = params.size() > 3 ? params[3] : ""; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -744,7 +744,7 @@ class CommandCSLevels : public Command source.Reply(_("The following feature/function names are understood.")); ListFormatter list; - list.addColumn("Name").addColumn("Description"); + list.AddColumn("Name").AddColumn("Description"); const std::vector<Privilege> &privs = PrivilegeManager::GetPrivileges(); for (unsigned i = 0; i < privs.size(); ++i) @@ -752,8 +752,8 @@ class CommandCSLevels : public Command const Privilege &p = privs[i]; ListFormatter::ListEntry entry; entry["Name"] = p.name; - entry["Description"] = translate(source.nc, p.desc.c_str()); - list.addEntry(entry); + entry["Description"] = Language::Translate(source.nc, p.desc.c_str()); + list.AddEntry(entry); } std::vector<Anope::string> replies; diff --git a/modules/commands/cs_akick.cpp b/modules/commands/cs_akick.cpp index 1425d1636..29959bf32 100644 --- a/modules/commands/cs_akick.cpp +++ b/modules/commands/cs_akick.cpp @@ -52,7 +52,7 @@ class CommandCSAKick : public Command { Anope::string mask = params[2]; Anope::string reason = params.size() > 3 ? params[3] : ""; - const NickAlias *na = findnick(mask); + const NickAlias *na = NickAlias::Find(mask); NickCore *nc = NULL; const AutoKick *akick; @@ -178,34 +178,34 @@ class CommandCSAKick : public Command CommandSource &source; ChannelInfo *ci; Command *c; - unsigned Deleted; + unsigned deleted; public: - AkickDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, const Anope::string &list) : NumberList(list, true), source(_source), ci(_ci), c(_c), Deleted(0) + AkickDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, const Anope::string &list) : NumberList(list, true), source(_source), ci(_ci), c(_c), deleted(0) { } ~AkickDelCallback() { bool override = !source.AccessFor(ci).HasPriv("AKICK"); - Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, c, ci) << "to delete " << Deleted << (Deleted == 1 ? " entry" : " entries"); + Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, c, ci) << "to delete " << deleted << (deleted == 1 ? " entry" : " entries"); - if (!Deleted) + if (!deleted) source.Reply(_("No matching entries on %s autokick list."), ci->name.c_str()); - else if (Deleted == 1) + else if (deleted == 1) source.Reply(_("Deleted 1 entry from %s autokick list."), ci->name.c_str()); else - source.Reply(_("Deleted %d entries from %s autokick list."), Deleted, ci->name.c_str()); + source.Reply(_("Deleted %d entries from %s autokick list."), deleted, ci->name.c_str()); } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number || Number > ci->GetAkickCount()) + if (!number || number > ci->GetAkickCount()) return; - FOREACH_MOD(I_OnAkickDel, OnAkickDel(source, ci, ci->GetAkick(Number - 1))); + FOREACH_MOD(I_OnAkickDel, OnAkickDel(source, ci, ci->GetAkick(number - 1))); - ++Deleted; - ci->EraseAkick(Number - 1); + ++deleted; + ci->EraseAkick(number - 1); } } delcallback(source, ci, this, mask); @@ -213,7 +213,7 @@ class CommandCSAKick : public Command } else { - const NickAlias *na = findnick(mask); + const NickAlias *na = NickAlias::Find(mask); const NickCore *nc = na ? *na->nc : NULL; for (i = 0, end = ci->GetAkickCount(); i < end; ++i) @@ -266,11 +266,11 @@ class CommandCSAKick : public Command Anope::string timebuf, lastused; if (akick->addtime) - timebuf = do_strftime(akick->addtime, NULL, false); + timebuf = Anope::strftime(akick->addtime, NULL, false); else timebuf = UNKNOWN; if (akick->last_used) - lastused = do_strftime(akick->last_used, NULL, false); + lastused = Anope::strftime(akick->last_used, NULL, false); else lastused = UNKNOWN; @@ -281,7 +281,7 @@ class CommandCSAKick : public Command entry["Created"] = timebuf; entry["Last used"] = lastused; entry["Reason"] = akick->reason; - this->list.addEntry(entry); + this->list.AddEntry(entry); } } nl_list(list, ci, mask); @@ -303,11 +303,11 @@ class CommandCSAKick : public Command Anope::string timebuf, lastused; if (akick->addtime) - timebuf = do_strftime(akick->addtime); + timebuf = Anope::strftime(akick->addtime); else timebuf = UNKNOWN; if (akick->last_used) - lastused = do_strftime(akick->last_used); + lastused = Anope::strftime(akick->last_used); else lastused = UNKNOWN; @@ -318,11 +318,11 @@ class CommandCSAKick : public Command entry["Created"] = timebuf; entry["Last used"] = lastused; entry["Reason"] = akick->reason; - list.addEntry(entry); + list.AddEntry(entry); } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on %s autokick list."), ci->name.c_str()); else { @@ -347,7 +347,7 @@ class CommandCSAKick : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("Reason"); this->ProcessList(source, ci, params, list); } @@ -360,7 +360,7 @@ class CommandCSAKick : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("Creator").addColumn("Created").addColumn("Last used").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("Creator").AddColumn("Created").AddColumn("Last used").AddColumn("Reason"); this->ProcessList(source, ci, params, list); } @@ -416,7 +416,7 @@ class CommandCSAKick : public Command Anope::string cmd = params[1]; Anope::string mask = params.size() > 2 ? params[2] : ""; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -427,7 +427,7 @@ class CommandCSAKick : public Command this->OnSyntaxError(source, cmd); else if (!source.AccessFor(ci).HasPriv("AKICK") && !source.HasPriv("chanserv/access/modify")) source.Reply(ACCESS_DENIED); - else if (!cmd.equals_ci("LIST") && !cmd.equals_ci("VIEW") && !cmd.equals_ci("ENFORCE") && readonly) + else if (!cmd.equals_ci("LIST") && !cmd.equals_ci("VIEW") && !cmd.equals_ci("ENFORCE") && Anope::ReadOnly) source.Reply(_("Sorry, channel autokick list modification is temporarily disabled.")); else if (cmd.equals_ci("ADD")) this->DoAdd(source, ci, params); diff --git a/modules/commands/cs_appendtopic.cpp b/modules/commands/cs_appendtopic.cpp index 70cde7b7b..2d7c0f278 100644 --- a/modules/commands/cs_appendtopic.cpp +++ b/modules/commands/cs_appendtopic.cpp @@ -52,7 +52,7 @@ class CommandCSAppendTopic : public Command { const Anope::string &newtopic = params[1]; - Channel *c = findchan(params[0]);; + Channel *c = Channel::Find(params[0]);; if (!c) source.Reply(CHAN_X_NOT_IN_USE, params[0].c_str()); diff --git a/modules/commands/cs_ban.cpp b/modules/commands/cs_ban.cpp index 063d98ab5..e857243f9 100644 --- a/modules/commands/cs_ban.cpp +++ b/modules/commands/cs_ban.cpp @@ -29,7 +29,7 @@ class CommandCSBan : public Command const Anope::string &target = params[1]; const Anope::string &reason = params.size() > 2 ? params[2] : "Requested"; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -38,7 +38,7 @@ class CommandCSBan : public Command Channel *c = ci->c; User *u = source.GetUser(); - User *u2 = finduser(target); + User *u2 = User::Find(target, true); AccessGroup u_access = source.AccessFor(ci); @@ -56,14 +56,13 @@ class CommandCSBan : public Command if (u != u2 && ci->HasFlag(CI_PEACE) && u2_access >= u_access) source.Reply(ACCESS_DENIED); - else if (matches_list(ci->c, u2, CMODE_EXCEPT)) + else if (ci->c->MatchesList(u2, CMODE_EXCEPT)) source.Reply(CHAN_EXCEPTED, u2->nick.c_str(), ci->name.c_str()); else if (u2->IsProtected()) source.Reply(ACCESS_DENIED); else { - Anope::string mask; - get_idealban(ci, u2, mask); + Anope::string mask = ci->GetIdealBan(u2); // XXX need a way to detect if someone is overriding Log(LOG_COMMAND, source, this, ci) << "for " << mask; @@ -99,7 +98,7 @@ class CommandCSBan : public Command if (u != uc->user && ci->HasFlag(CI_PEACE) && u2_access >= u_access) continue; - else if (matches_list(ci->c, uc->user, CMODE_EXCEPT)) + else if (ci->c->MatchesList(uc->user, CMODE_EXCEPT)) continue; else if (uc->user->IsProtected()) continue; diff --git a/modules/commands/cs_clearusers.cpp b/modules/commands/cs_clearusers.cpp index d6eed6e4d..3a424e4ce 100644 --- a/modules/commands/cs_clearusers.cpp +++ b/modules/commands/cs_clearusers.cpp @@ -26,7 +26,7 @@ class CommandCSClearUsers : public Command { const Anope::string &chan = params[0]; - Channel *c = findchan(chan); + Channel *c = Channel::Find(chan); Anope::string modebuf; if (!c) diff --git a/modules/commands/cs_clone.cpp b/modules/commands/cs_clone.cpp index aef48ea4c..19a8ad436 100644 --- a/modules/commands/cs_clone.cpp +++ b/modules/commands/cs_clone.cpp @@ -29,7 +29,7 @@ public: Anope::string what = params.size() > 2 ? params[2] : ""; User *u = source.GetUser(); - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -42,7 +42,7 @@ public: return; } - ChannelInfo *target_ci = cs_findchan(target); + ChannelInfo *target_ci = ChannelInfo::Find(target); if (!target_ci) { source.Reply(CHAN_X_NOT_REGISTERED, target.c_str()); @@ -59,11 +59,11 @@ public: if (what.empty()) { - target_ci->destroy(); + target_ci->Destroy(); target_ci = new ChannelInfo(*ci); target_ci->name = target; (*RegisteredChannelList)[target_ci->name] = target_ci; - target_ci->c = findchan(target_ci->name); + target_ci->c = Channel::Find(target_ci->name); if (target_ci->c) { target_ci->c->ci = target_ci; @@ -88,7 +88,7 @@ public: target_ci->c->SetMode(NULL, CMODE_PERM); if (target_ci->bi && target_ci->c->FindUser(target_ci->bi) == NULL) - target_ci->bi->Join(target_ci->c, &Config->BotModeList); + target_ci->bi->Join(target_ci->c, &ModeManager::DefaultBotModes); } if (target_ci->c && !target_ci->c->topic.empty()) @@ -117,7 +117,7 @@ public: newaccess->creator = taccess->creator; newaccess->last_seen = taccess->last_seen; newaccess->created = taccess->created; - newaccess->Unserialize(taccess->Serialize()); + newaccess->AccessUnserialize(taccess->AccessSerialize()); target_ci->AddAccess(newaccess); } diff --git a/modules/commands/cs_drop.cpp b/modules/commands/cs_drop.cpp index cf8c5040e..829f44026 100644 --- a/modules/commands/cs_drop.cpp +++ b/modules/commands/cs_drop.cpp @@ -26,13 +26,13 @@ class CommandCSDrop : public Command { const Anope::string &chan = params[0]; - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, channel de-registration is temporarily disabled.")); // XXX: READ_ONLY_MODE? return; } - ChannelInfo *ci = cs_findchan(chan); + ChannelInfo *ci = ChannelInfo::Find(chan); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -57,7 +57,7 @@ class CommandCSDrop : public Command FOREACH_MOD(I_OnChanDrop, OnChanDrop(ci)); Channel *c = ci->c; - ci->destroy(); + ci->Destroy(); source.Reply(_("Channel \002%s\002 has been dropped."), chan.c_str()); diff --git a/modules/commands/cs_enforce.cpp b/modules/commands/cs_enforce.cpp index 755cd55b4..4622af04b 100644 --- a/modules/commands/cs_enforce.cpp +++ b/modules/commands/cs_enforce.cpp @@ -50,7 +50,7 @@ class CommandCSEnforce : public Command Log(LOG_COMMAND, source, this) << "to enforce secureops"; - /* Dirty hack to allow chan_set_correct_modes to work ok. + /* Dirty hack to allow Channel::SetCorrectModes to work ok. * We pretend like SECUREOPS is on so it doesn't ignore that * part of the code. This way we can enforce SECUREOPS even * if it's off. @@ -66,7 +66,7 @@ class CommandCSEnforce : public Command { UserContainer *uc = *it; - chan_set_correct_modes(uc->user, c, 0, false); + c->SetCorrectModes(uc->user, false, false); } if (hadsecureops) @@ -95,9 +95,8 @@ class CommandCSEnforce : public Command { User *user = users[i]; - Anope::string mask; - get_idealban(ci, user, mask); - Anope::string reason = translate(user, CHAN_NOT_ALLOWED_TO_JOIN); + Anope::string mask = ci->GetIdealBan(user); + Anope::string reason = Language::Translate(user, CHAN_NOT_ALLOWED_TO_JOIN); c->SetMode(NULL, CMODE_BAN, mask); c->Kick(NULL, user, "%s", reason.c_str()); } @@ -106,7 +105,6 @@ class CommandCSEnforce : public Command void DoCModeR(CommandSource &source, Channel *c) { ChannelInfo *ci = c->ci; - Anope::string mask; if (!ci) return; @@ -127,8 +125,8 @@ class CommandCSEnforce : public Command { User *user = users[i]; - get_idealban(ci, user, mask); - Anope::string reason = translate(user, CHAN_NOT_ALLOWED_TO_JOIN); + Anope::string mask = ci->GetIdealBan(user); + Anope::string reason = Language::Translate(user, CHAN_NOT_ALLOWED_TO_JOIN); if (!c->HasMode(CMODE_REGISTEREDONLY)) c->SetMode(NULL, CMODE_BAN, mask); c->Kick(NULL, user, "%s", reason.c_str()); @@ -145,7 +143,7 @@ class CommandCSEnforce : public Command { const Anope::string &what = params.size() > 1 ? params[1] : ""; - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (!c) source.Reply(CHAN_X_NOT_IN_USE, params[0].c_str()); diff --git a/modules/commands/cs_entrymsg.cpp b/modules/commands/cs_entrymsg.cpp index 1fce5fac0..85e428cc1 100644 --- a/modules/commands/cs_entrymsg.cpp +++ b/modules/commands/cs_entrymsg.cpp @@ -15,7 +15,7 @@ struct EntryMsg : Serializable { - serialize_obj<ChannelInfo> ci; + Serialize::Reference<ChannelInfo> ci; Anope::string creator; Anope::string message; time_t when; @@ -28,31 +28,31 @@ struct EntryMsg : Serializable this->when = ct; } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data data; data["ci"] << this->ci->name; data["creator"] << this->creator; data["message"] << this->message; - data["when"].setType(Serialize::DT_INT) << this->when; + data["when"].SetType(Serialize::DT_INT) << this->when; return data; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data); + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data); }; static unsigned MaxEntries = 0; -struct EntryMessageList : serialize_checker<std::vector<EntryMsg *> >, ExtensibleItem +struct EntryMessageList : Serialize::Checker<std::vector<EntryMsg *> >, ExtensibleItem { - EntryMessageList() : serialize_checker<std::vector<EntryMsg *> >("EntryMsg") { } + EntryMessageList() : Serialize::Checker<std::vector<EntryMsg *> >("EntryMsg") { } }; -Serializable* EntryMsg::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* EntryMsg::Unserialize(Serializable *obj, Serialize::Data &data) { - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (!ci) return NULL; @@ -99,7 +99,7 @@ class CommandEntryMessage : public Command source.Reply(_("Entry message list for \002%s\002:"), ci->name.c_str()); ListFormatter list; - list.addColumn("Number").addColumn("Creator").addColumn("Created").addColumn("Message"); + list.AddColumn("Number").AddColumn("Creator").AddColumn("Created").AddColumn("Message"); for (unsigned i = 0; i < (*messages)->size(); ++i) { EntryMsg *msg = (*messages)->at(i); @@ -107,9 +107,9 @@ class CommandEntryMessage : public Command ListFormatter::ListEntry entry; entry["Number"] = stringify(i + 1); entry["Creator"] = msg->creator; - entry["Created"] = do_strftime(msg->when); + entry["Created"] = Anope::strftime(msg->when); entry["Message"] = msg->message; - list.addEntry(entry); + list.AddEntry(entry); } std::vector<Anope::string> replies; @@ -159,7 +159,7 @@ class CommandEntryMessage : public Command unsigned i = convertTo<unsigned>(message); if (i > 0 && i <= (*messages)->size()) { - (*messages)->at(i - 1)->destroy(); + (*messages)->at(i - 1)->Destroy(); (*messages)->erase((*messages)->begin() + i - 1); if ((*messages)->empty()) ci->Shrink("cs_entrymsg"); @@ -182,7 +182,7 @@ class CommandEntryMessage : public Command if (messages != NULL) { for (unsigned i = 0; i < (*messages)->size(); ++i) - (*messages)->at(i)->destroy(); + (*messages)->at(i)->Destroy(); (*messages)->clear(); ci->Shrink("cs_entrymsg"); } @@ -203,7 +203,7 @@ class CommandEntryMessage : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -258,11 +258,11 @@ class CommandEntryMessage : public Command class CSEntryMessage : public Module { - SerializeType entrymsg_type; + Serialize::Type entrymsg_type; CommandEntryMessage commandentrymsg; public: - CSEntryMessage(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), entrymsg_type("EntryMsg", EntryMsg::unserialize), commandentrymsg(this) + CSEntryMessage(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), entrymsg_type("EntryMsg", EntryMsg::Unserialize), commandentrymsg(this) { this->SetAuthor("Anope"); diff --git a/modules/commands/cs_fantasy_stats.cpp b/modules/commands/cs_fantasy_stats.cpp index 7c79593a2..bbe135298 100644 --- a/modules/commands/cs_fantasy_stats.cpp +++ b/modules/commands/cs_fantasy_stats.cpp @@ -66,7 +66,7 @@ class CSStats : public Module { CommandCSStats commandcsstats; CommandCSGStats commandcsgstats; - service_reference<SQLProvider> sql; + ServiceReference<SQLProvider> sql; MySQLInterface sqlinterface; Anope::string prefix; public: @@ -86,7 +86,7 @@ class CSStats : public Module ConfigReader config; prefix = config.ReadValue("chanstats", "prefix", "anope_", 0); Anope::string engine = config.ReadValue("chanstats", "engine", "", 0); - this->sql = service_reference<SQLProvider>("SQLProvider", engine); + this->sql = ServiceReference<SQLProvider>("SQLProvider", engine); } SQLResult RunQuery(const SQLQuery &query) @@ -108,7 +108,7 @@ class CSStats : public Module Anope::string display; if (params.empty()) display = source.nc->display; - else if (const NickAlias *na = findnick(params[0])) + else if (const NickAlias *na = NickAlias::Find(params[0])) display = na->nc->display; else { diff --git a/modules/commands/cs_fantasy_top.cpp b/modules/commands/cs_fantasy_top.cpp index 587b4c525..86e25f122 100644 --- a/modules/commands/cs_fantasy_top.cpp +++ b/modules/commands/cs_fantasy_top.cpp @@ -93,7 +93,7 @@ class CSTop : public Module CommandCSGTop commandcsgtop; CommandCSTop10 commandcstop10; CommandCSGTop10 commandcsgtop10; - service_reference<SQLProvider> sql; + ServiceReference<SQLProvider> sql; MySQLInterface sqlinterface; Anope::string prefix; @@ -115,7 +115,7 @@ class CSTop : public Module ConfigReader config; prefix = config.ReadValue("chanstats", "prefix", "anope_", 0); Anope::string engine = config.ReadValue("chanstats", "engine", "", 0); - this->sql = service_reference<SQLProvider>("SQLProvider", engine); + this->sql = ServiceReference<SQLProvider>("SQLProvider", engine); } SQLResult RunQuery(const SQLQuery &query) diff --git a/modules/commands/cs_flags.cpp b/modules/commands/cs_flags.cpp index c137b55b1..65ae33f2f 100644 --- a/modules/commands/cs_flags.cpp +++ b/modules/commands/cs_flags.cpp @@ -32,12 +32,12 @@ class FlagsChanAccess : public ChanAccess return false; } - Anope::string Serialize() const + Anope::string AccessSerialize() const { return Anope::string(this->flags.begin(), this->flags.end()); } - void Unserialize(const Anope::string &data) anope_override + void AccessUnserialize(const Anope::string &data) anope_override { for (unsigned i = data.length(); i > 0; --i) this->flags.insert(data[i - 1]); @@ -46,7 +46,7 @@ class FlagsChanAccess : public ChanAccess static Anope::string DetermineFlags(const ChanAccess *access) { if (access->provider->name == "access/flags") - return access->Serialize(); + return access->AccessSerialize(); std::set<char> buffer; @@ -86,9 +86,9 @@ class CommandCSFlags : public Command AccessGroup u_access = source.AccessFor(ci); - if (mask.find_first_of("!*@") == Anope::string::npos && !findnick(mask)) + if (mask.find_first_of("!*@") == Anope::string::npos && !NickAlias::Find(mask)) { - User *targ = finduser(mask); + User *targ = User::Find(mask, true); if (targ != NULL) mask = "*!*@" + targ->GetDisplayedHost(); else @@ -191,7 +191,7 @@ class CommandCSFlags : public Command return; } - service_reference<AccessProvider> provider("AccessProvider", "access/flags"); + ServiceReference<AccessProvider> provider("AccessProvider", "access/flags"); if (!provider) return; FlagsChanAccess *access = anope_dynamic_static_cast<FlagsChanAccess *>(provider->Create()); @@ -209,8 +209,8 @@ class CommandCSFlags : public Command FOREACH_MOD(I_OnAccessAdd, OnAccessAdd(ci, source, access)); - Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to modify " << mask << "'s flags to " << access->Serialize(); - source.Reply(_("Access for \002%s\002 on %s set to +\002%s\002"), access->mask.c_str(), ci->name.c_str(), access->Serialize().c_str()); + Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to modify " << mask << "'s flags to " << access->AccessSerialize(); + source.Reply(_("Access for \002%s\002 on %s set to +\002%s\002"), access->mask.c_str(), ci->name.c_str(), access->AccessSerialize().c_str()); return; } @@ -227,7 +227,7 @@ class CommandCSFlags : public Command ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("Flags").addColumn("Creator").addColumn("Created"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("Flags").AddColumn("Creator").AddColumn("Created"); unsigned count = 0; for (unsigned i = 0, end = ci->GetAccessCount(); i < end; ++i) @@ -257,11 +257,11 @@ class CommandCSFlags : public Command entry["Mask"] = access->mask; entry["Flags"] = FlagsChanAccess::DetermineFlags(access); entry["Creator"] = access->creator; - entry["Created"] = do_strftime(access->created, source.nc, true); - list.addEntry(entry); + entry["Created"] = Anope::strftime(access->created, source.nc, true); + list.AddEntry(entry); } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on %s access list."), ci->name.c_str()); else { @@ -311,7 +311,7 @@ class CommandCSFlags : public Command const Anope::string &chan = params[0]; const Anope::string &cmd = params[1]; - ChannelInfo *ci = cs_findchan(chan); + ChannelInfo *ci = ChannelInfo::Find(chan); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str()); @@ -329,7 +329,7 @@ class CommandCSFlags : public Command if (!has_access) source.Reply(ACCESS_DENIED); - else if (readonly && !is_list) + else if (Anope::ReadOnly && !is_list) source.Reply(_("Sorry, channel access list modification is temporarily disabled.")); else if (cmd.equals_ci("MODIFY")) this->DoModify(source, ci, params); @@ -374,7 +374,7 @@ class CommandCSFlags : public Command Privilege *p = PrivilegeManager::FindPrivilege(it->second); if (p == NULL) continue; - source.Reply(" %c - %s", it->first, translate(source.nc, p->desc.c_str())); + source.Reply(" %c - %s", it->first, Language::Translate(source.nc, p->desc.c_str())); } return true; diff --git a/modules/commands/cs_getkey.cpp b/modules/commands/cs_getkey.cpp index e0205ad03..212388e3f 100644 --- a/modules/commands/cs_getkey.cpp +++ b/modules/commands/cs_getkey.cpp @@ -26,7 +26,7 @@ class CommandCSGetKey : public Command { const Anope::string &chan = params[0]; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_info.cpp b/modules/commands/cs_info.cpp index 310879135..c485c3cb4 100644 --- a/modules/commands/cs_info.cpp +++ b/modules/commands/cs_info.cpp @@ -22,7 +22,7 @@ class CommandCSInfo : public Command if (!buf.empty()) buf += ", "; - buf += translate(nc, str); + buf += Language::Translate(nc, str); } } @@ -39,7 +39,7 @@ class CommandCSInfo : public Command const Anope::string &chan = params[0]; NickCore *nc = source.nc; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -65,8 +65,8 @@ class CommandCSInfo : public Command if (!ci->desc.empty()) info["Description"] = ci->desc; - info["Registered"] = do_strftime(ci->time_registered); - info["Last used"] = do_strftime(ci->last_used); + info["Registered"] = Anope::strftime(ci->time_registered); + info["Last used"] = Anope::strftime(ci->last_used); const ModeLock *secret = ci->GetMLock(CMODE_SECRET); if (!ci->last_topic.empty() && (show_all || ((!secret || secret->set == false) && (!ci->c || !ci->c->HasMode(CMODE_SECRET))))) @@ -103,7 +103,7 @@ class CommandCSInfo : public Command info["Mode lock"] = ml; if (!ci->HasFlag(CI_NO_EXPIRE)) - info["Expires on"] = do_strftime(ci->last_used + Config->CSExpire); + info["Expires on"] = Anope::strftime(ci->last_used + Config->CSExpire); } if (ci->HasFlag(CI_SUSPENDED)) { diff --git a/modules/commands/cs_invite.cpp b/modules/commands/cs_invite.cpp index 32ef87e3e..1085947a2 100644 --- a/modules/commands/cs_invite.cpp +++ b/modules/commands/cs_invite.cpp @@ -27,7 +27,7 @@ class CommandCSInvite : public Command const Anope::string &chan = params[0]; User *u = source.GetUser(); - Channel *c = findchan(chan); + Channel *c = Channel::Find(chan); if (!c) { @@ -52,7 +52,7 @@ class CommandCSInvite : public Command if (params.size() == 1) u2 = u; else - u2 = finduser(params[1]); + u2 = User::Find(params[1], true); if (!u2) { @@ -71,7 +71,7 @@ class CommandCSInvite : public Command { bool override = !source.AccessFor(ci).HasPriv("INVITE"); - ircdproto->SendInvite(ci->WhoSends(), c, u2); + IRCD->SendInvite(ci->WhoSends(), c, u2); if (u2 != u) { source.Reply(_("\002%s\002 has been invited to \002%s\002."), u2->nick.c_str(), c->name.c_str()); diff --git a/modules/commands/cs_kick.cpp b/modules/commands/cs_kick.cpp index 97d879416..4073f3fe8 100644 --- a/modules/commands/cs_kick.cpp +++ b/modules/commands/cs_kick.cpp @@ -30,9 +30,9 @@ class CommandCSKick : public Command const Anope::string &reason = params.size() > 2 ? params[2] : "Requested"; User *u = source.GetUser(); - ChannelInfo *ci = cs_findchan(params[0]); - Channel *c = findchan(params[0]); - User *u2 = finduser(target); + ChannelInfo *ci = ChannelInfo::Find(params[0]); + Channel *c = Channel::Find(params[0]); + User *u2 = User::Find(target, true); if (!c) { diff --git a/modules/commands/cs_list.cpp b/modules/commands/cs_list.cpp index db5a5136a..9132d07a8 100644 --- a/modules/commands/cs_list.cpp +++ b/modules/commands/cs_list.cpp @@ -33,8 +33,9 @@ class CommandCSList : public Command if (pattern[0] == '#') { - Anope::string n1 = myStrGetToken(pattern.substr(1), '-', 0), /* Read FROM out */ - n2 = myStrGetTokenRemainder(pattern, '-', 1); + Anope::string n1, n2; + sepstream(pattern.substr(1), '-').GetToken(n1, 0); + sepstream(pattern, '-').GetToken(n2, 1); try { @@ -72,7 +73,7 @@ class CommandCSList : public Command source.Reply(_("List of entries matching \002%s\002:"), pattern.c_str()); ListFormatter list; - list.addColumn("Name").addColumn("Description"); + list.AddColumn("Name").AddColumn("Description"); for (registered_channel_map::const_iterator it = RegisteredChannelList->begin(), it_end = RegisteredChannelList->end(); it != it_end; ++it) { @@ -99,7 +100,7 @@ class CommandCSList : public Command entry["Description"] = "[Suspended]"; else entry["Description"] = ci->desc; - list.addEntry(entry); + list.AddEntry(entry); } ++count; } diff --git a/modules/commands/cs_log.cpp b/modules/commands/cs_log.cpp index bd630b4e2..4965ab561 100644 --- a/modules/commands/cs_log.cpp +++ b/modules/commands/cs_log.cpp @@ -28,7 +28,7 @@ public: { const Anope::string &channel = params[0]; - ChannelInfo *ci = cs_findchan(channel); + ChannelInfo *ci = ChannelInfo::Find(channel); if (ci == NULL) source.Reply(CHAN_X_NOT_REGISTERED, channel.c_str()); else if (!source.AccessFor(ci).HasPriv("SET") && !source.HasPriv("chanserv/set")) @@ -40,7 +40,7 @@ public: else { ListFormatter list; - list.addColumn("Number").addColumn("Service").addColumn("Command").addColumn("Method").addColumn(""); + list.AddColumn("Number").AddColumn("Service").AddColumn("Command").AddColumn("Method").AddColumn(""); for (unsigned i = 0; i < ci->log_settings->size(); ++i) { @@ -52,7 +52,7 @@ public: entry["Command"] = log->command_name; entry["Method"] = log->method; entry[""] = log->extra; - list.addEntry(entry); + list.AddEntry(entry); } source.Reply(_("Log list for %s:"), ci->name.c_str()); @@ -79,7 +79,7 @@ public: Anope::string service = command.substr(0, sl), command_name = command.substr(sl + 1); - BotInfo *bi = findbot(service); + BotInfo *bi = BotInfo::Find(service, true); if (bi == NULL || bi->commands.count(command_name) == 0) { @@ -87,7 +87,7 @@ public: return; } - service_reference<Command> c_service("Command", bi->commands[command_name].name); + ServiceReference<Command> c_service("Command", bi->commands[command_name].name); if (!c_service) { source.Reply(_("%s is not a valid command."), command.c_str()); @@ -117,7 +117,7 @@ public: { if (log->extra == extra) { - log->destroy(); + log->Destroy(); ci->log_settings->erase(ci->log_settings->begin() + i - 1); Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to remove logging for " << command << " with method " << method << (extra == "" ? "" : " ") << extra; source.Reply(_("Logging for command %s on %s with log method %s%s%s has been removed."), command_name.c_str(), bi->nick.c_str(), method.c_str(), extra.empty() ? "" : " ", extra.empty() ? "" : extra.c_str()); @@ -194,7 +194,7 @@ class CSLog : public Module void OnLog(Log *l) anope_override { - if (l->Type != LOG_COMMAND || l->u == NULL || l->c == NULL || l->ci == NULL || !Me || !Me->IsSynced()) + if (l->type != LOG_COMMAND || l->u == NULL || l->c == NULL || l->ci == NULL || !Me || !Me->IsSynced()) return; for (unsigned i = l->ci->log_settings->size(); i > 0; --i) @@ -207,13 +207,13 @@ class CSLog : public Module if (log->method.equals_ci("MESSAGE") && l->ci->c && l->ci->bi && l->ci->c->FindUser(l->ci->bi) != NULL) { - ircdproto->SendPrivmsg(l->ci->bi, log->extra + l->ci->c->name, "%s", buffer.c_str()); + IRCD->SendPrivmsg(l->ci->bi, log->extra + l->ci->c->name, "%s", buffer.c_str()); l->ci->bi->lastmsg = Anope::CurTime; } else if (log->method.equals_ci("NOTICE") && l->ci->c && l->ci->bi && l->ci->c->FindUser(l->ci->bi) != NULL) - ircdproto->SendNotice(l->ci->bi, log->extra + l->ci->c->name, "%s", buffer.c_str()); - else if (log->method.equals_ci("MEMO") && memoserv && l->ci->WhoSends() != NULL) - memoserv->Send(l->ci->WhoSends()->nick, l->ci->name, buffer, true); + IRCD->SendNotice(l->ci->bi, log->extra + l->ci->c->name, "%s", buffer.c_str()); + else if (log->method.equals_ci("MEMO") && MemoServService && l->ci->WhoSends() != NULL) + MemoServService->Send(l->ci->WhoSends()->nick, l->ci->name, buffer, true); } } } diff --git a/modules/commands/cs_mode.cpp b/modules/commands/cs_mode.cpp index 840912aaf..c33b317a2 100644 --- a/modules/commands/cs_mode.cpp +++ b/modules/commands/cs_mode.cpp @@ -17,7 +17,7 @@ class CommandCSMode : public Command { bool CanSet(CommandSource &source, ChannelInfo *ci, ChannelMode *cm) { - if (!ci || !cm || cm->Type != MODE_STATUS) + if (!ci || !cm || cm->type != MODE_STATUS) return false; const Anope::string accesses[] = { "VOICE", "HALFOP", "OPDEOP", "PROTECT", "OWNER", "" }; @@ -30,7 +30,7 @@ class CommandCSMode : public Command if (access.HasPriv(accesses[i])) { ChannelMode *cm2 = ModeManager::FindChannelModeByName(modes[i]); - if (cm2 == NULL || cm2->Type != MODE_STATUS) + if (cm2 == NULL || cm2->type != MODE_STATUS) continue; ChannelModeStatus *cms2 = anope_dynamic_static_cast<ChannelModeStatus *>(cm2); if (cms2->Level > u_level) @@ -82,15 +82,15 @@ class CommandCSMode : public Command } Anope::string mode_param; - if (((cm->Type == MODE_STATUS || cm->Type == MODE_LIST) && !sep.GetToken(mode_param)) || (cm->Type == MODE_PARAM && adding && !sep.GetToken(mode_param))) - source.Reply(_("Missing parameter for mode %c."), cm->ModeChar); + if (((cm->type == MODE_STATUS || cm->type == MODE_LIST) && !sep.GetToken(mode_param)) || (cm->type == MODE_PARAM && adding && !sep.GetToken(mode_param))) + source.Reply(_("Missing parameter for mode %c."), cm->mchar); else { ci->SetMLock(cm, adding, mode_param, source.GetNick()); if (!mode_param.empty()) mode_param = " " + mode_param; - source.Reply(_("%c%c%s locked on %s"), adding ? '+' : '-', cm->ModeChar, mode_param.c_str(), ci->name.c_str()); - Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to lock " << (adding ? '+' : '-') << cm->ModeChar << mode_param; + source.Reply(_("%c%c%s locked on %s"), adding ? '+' : '-', cm->mchar, mode_param.c_str(), ci->name.c_str()); + Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to lock " << (adding ? '+' : '-') << cm->mchar << mode_param; } } } @@ -132,19 +132,19 @@ class CommandCSMode : public Command } Anope::string mode_param; - if (!cm->Type == MODE_REGULAR && !sep.GetToken(mode_param)) - source.Reply(_("Missing parameter for mode %c."), cm->ModeChar); + if (!cm->type == MODE_REGULAR && !sep.GetToken(mode_param)) + source.Reply(_("Missing parameter for mode %c."), cm->mchar); else { if (ci->RemoveMLock(cm, adding, mode_param)) { if (!mode_param.empty()) mode_param = " " + mode_param; - source.Reply(_("%c%c%s has been unlocked from %s."), adding == 1 ? '+' : '-', cm->ModeChar, mode_param.c_str(), ci->name.c_str()); - Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to unlock " << (adding ? '+' : '-') << cm->ModeChar << mode_param; + source.Reply(_("%c%c%s has been unlocked from %s."), adding == 1 ? '+' : '-', cm->mchar, mode_param.c_str(), ci->name.c_str()); + Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, this, ci) << "to unlock " << (adding ? '+' : '-') << cm->mchar << mode_param; } else - source.Reply(_("%c%c is not locked on %s."), adding == 1 ? '+' : '-', cm->ModeChar, ci->name.c_str()); + source.Reply(_("%c%c is not locked on %s."), adding == 1 ? '+' : '-', cm->mchar, ci->name.c_str()); } } } @@ -159,7 +159,7 @@ class CommandCSMode : public Command else { ListFormatter list; - list.addColumn("Mode").addColumn("Param").addColumn("Creator").addColumn("Created"); + list.AddColumn("Mode").AddColumn("Param").AddColumn("Creator").AddColumn("Created"); for (ChannelInfo::ModeList::const_iterator it = mlocks.begin(), it_end = mlocks.end(); it != it_end; ++it) { @@ -169,11 +169,11 @@ class CommandCSMode : public Command continue; ListFormatter::ListEntry entry; - entry["Mode"] = Anope::printf("%c%c", ml->set ? '+' : '-', cm->ModeChar); + entry["Mode"] = Anope::printf("%c%c", ml->set ? '+' : '-', cm->mchar); entry["Param"] = ml->param; entry["Creator"] = ml->setter; - entry["Created"] = do_strftime(ml->created, source.nc, false); - list.addEntry(entry); + entry["Created"] = Anope::strftime(ml->created, source.nc, false); + list.AddEntry(entry); } source.Reply(_("Mode locks for %s:"), ci->name.c_str()); @@ -218,7 +218,7 @@ class CommandCSMode : public Command ChannelMode *cm = ModeManager::ChannelModes[j]; if (!u || cm->CanSet(u)) { - if (cm->Type == MODE_REGULAR || (!adding && cm->Type == MODE_PARAM)) + if (cm->type == MODE_REGULAR || (!adding && cm->type == MODE_PARAM)) { if (adding) ci->c->SetMode(NULL, cm); @@ -234,7 +234,7 @@ class CommandCSMode : public Command ChannelMode *cm = ModeManager::FindChannelModeByChar(modes[i]); if (!cm || (u && !cm->CanSet(u))) continue; - switch (cm->Type) + switch (cm->type) { case MODE_REGULAR: if (adding) @@ -257,13 +257,13 @@ class CommandCSMode : public Command if (!this->CanSet(source, ci, cm)) { - source.Reply(_("You do not have access to set mode %c."), cm->ModeChar); + source.Reply(_("You do not have access to set mode %c."), cm->mchar); break; } AccessGroup u_access = source.AccessFor(ci); - if (str_is_wildcard(param)) + if (param.find_first_of("*?") != Anope::string::npos) { for (CUserList::const_iterator it = ci->c->users.begin(), it_end = ci->c->users.end(); it != it_end; ++it) { @@ -288,7 +288,7 @@ class CommandCSMode : public Command } else { - User *target = finduser(param); + User *target = User::Find(param, true); if (target == NULL) { source.Reply(NICK_X_NOT_IN_USE, param.c_str()); @@ -316,7 +316,7 @@ class CommandCSMode : public Command ci->c->SetMode(NULL, cm, param); else { - std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> its = ci->c->GetModeList(cm->Name); + std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> its = ci->c->GetModeList(cm->name); for (; its.first != its.second;) { const Anope::string &mask = its.first->second; @@ -343,7 +343,7 @@ class CommandCSMode : public Command { const Anope::string &subcommand = params[1]; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (!ci || !ci->c) source.Reply(CHAN_X_NOT_IN_USE, params[0].c_str()); diff --git a/modules/commands/cs_modes.cpp b/modules/commands/cs_modes.cpp index 2775e92bc..696c38dde 100644 --- a/modules/commands/cs_modes.cpp +++ b/modules/commands/cs_modes.cpp @@ -18,8 +18,8 @@ class CommandModeBase : public Command void do_mode(CommandSource &source, Command *com, ChannelMode *cm, const Anope::string &chan, const Anope::string &nick, bool set, const Anope::string &level, const Anope::string &levelself) { User *u = source.GetUser(); - User *u2 = finduser(nick); - Channel *c = findchan(chan); + User *u2 = User::Find(nick, true); + Channel *c = Channel::Find(chan); if (!c) { diff --git a/modules/commands/cs_register.cpp b/modules/commands/cs_register.cpp index 28fb931f5..e756482c7 100644 --- a/modules/commands/cs_register.cpp +++ b/modules/commands/cs_register.cpp @@ -29,10 +29,10 @@ class CommandCSRegister : public Command User *u = source.GetUser(); NickCore *nc = source.nc; - Channel *c = findchan(params[0]); - ChannelInfo *ci = cs_findchan(params[0]); + Channel *c = Channel::Find(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); - if (readonly) + if (Anope::ReadOnly) source.Reply(_("Sorry, channel registration is temporarily disabled.")); else if (nc->HasFlag(NI_UNCONFIRMED)) source.Reply(_("You must confirm your account before you can register a channel.")); @@ -40,7 +40,7 @@ class CommandCSRegister : public Command source.Reply(_("Local channels cannot be registered.")); else if (chan[0] != '#') source.Reply(CHAN_SYMBOL_REQUIRED); - else if (!ircdproto->IsChannelValid(chan)) + else if (!IRCD->IsChannelValid(chan)) source.Reply(CHAN_X_INVALID, chan.c_str()); else if (ci) source.Reply(_("Channel \002%s\002 is already registered!"), chan.c_str()); @@ -55,7 +55,7 @@ class CommandCSRegister : public Command if (!chdesc.empty()) ci->desc = chdesc; - for (ChannelInfo::ModeList::iterator it = def_mode_locks.begin(), it_end = def_mode_locks.end(); it != it_end; ++it) + for (ChannelInfo::ModeList::iterator it = ModeManager::DefaultModeLocks.begin(), it_end = ModeManager::DefaultModeLocks.end(); it != it_end; ++it) { ModeLock *ml = new ModeLock(*it->second); ml->setter = source.GetNick(); diff --git a/modules/commands/cs_saset.cpp b/modules/commands/cs_saset.cpp index a4a72ee76..211148e13 100644 --- a/modules/commands/cs_saset.cpp +++ b/modules/commands/cs_saset.cpp @@ -43,7 +43,7 @@ class CommandCSSASet : public Command const CommandInfo &info = it->second; if (c_name.find_ci(this_name + " ") == 0) { - service_reference<Command> command("Command", info.name); + ServiceReference<Command> command("Command", info.name); if (command) { source.command = it->first; diff --git a/modules/commands/cs_saset_noexpire.cpp b/modules/commands/cs_saset_noexpire.cpp index 78d8641d4..1c7b260ec 100644 --- a/modules/commands/cs_saset_noexpire.cpp +++ b/modules/commands/cs_saset_noexpire.cpp @@ -24,7 +24,7 @@ class CommandCSSASetNoexpire : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_seen.cpp b/modules/commands/cs_seen.cpp index d2686e013..18a21d35e 100644 --- a/modules/commands/cs_seen.cpp +++ b/modules/commands/cs_seen.cpp @@ -38,7 +38,7 @@ struct SeenInfo : Serializable { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data data; @@ -48,12 +48,12 @@ struct SeenInfo : Serializable data["nick2"] << nick2; data["channel"] << channel; data["message"] << message; - data["last"].setType(Serialize::DT_INT) << last; + data["last"].SetType(Serialize::DT_INT) << last; return data; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { SeenInfo *s; if (obj) @@ -95,8 +95,8 @@ static SeenInfo *FindInfo(const Anope::string &nick) static bool ShouldHide(const Anope::string &channel, User *u) { - Channel *targetchan = findchan(channel); - const ChannelInfo *targetchan_ci = targetchan ? *targetchan->ci : cs_findchan(channel); + Channel *targetchan = Channel::Find(channel); + const ChannelInfo *targetchan_ci = targetchan ? *targetchan->ci : ChannelInfo::Find(channel); if (targetchan && targetchan->HasMode(CMODE_SECRET)) return true; @@ -137,7 +137,7 @@ class CommandOSSeen : public Command else if (params[0].equals_ci("CLEAR")) { time_t time = 0; - if ((params.size() < 2) || (0 >= (time = dotime(params[1])))) + if ((params.size() < 2) || (0 >= (time = Anope::DoTime(params[1])))) { this->OnSyntaxError(source, params[0]); return; @@ -151,14 +151,14 @@ class CommandOSSeen : public Command ++it; if (time < buf->second->last) { - Log(LOG_DEBUG) << buf->first << " was last seen " << do_strftime(buf->second->last) << ", deleting entry"; - buf->second->destroy(); + Log(LOG_DEBUG) << buf->first << " was last seen " << Anope::strftime(buf->second->last) << ", deleting entry"; + buf->second->Destroy(); database.erase(buf); counter++; } } - Log(LOG_ADMIN, source, this) << "CLEAR and removed " << counter << " nicks that were added after " << do_strftime(time, NULL, true); - source.Reply(_("Database cleared, removed %lu nicks that were added after %s"), counter, do_strftime(time, source.nc, true).c_str()); + Log(LOG_ADMIN, source, this) << "CLEAR and removed " << counter << " nicks that were added after " << Anope::strftime(time, NULL, true); + source.Reply(_("Database cleared, removed %lu nicks that were added after %s"), counter, Anope::strftime(time, source.nc, true).c_str()); } else this->SendSyntax(source); @@ -199,7 +199,7 @@ class CommandSeen : public Command return; } - if (findbot(target) != NULL) + if (BotInfo::Find(target, true) != NULL) { source.Reply(_("%s is a client on services."), target.c_str()); return; @@ -218,15 +218,15 @@ class CommandSeen : public Command return; } - User *u2 = finduser(target); + User *u2 = User::Find(target, true); Anope::string onlinestatus; if (u2) onlinestatus = "."; else onlinestatus = Anope::printf(_(" but %s mysteriously dematerialized."), target.c_str()); - Anope::string timebuf = duration(Anope::CurTime - info->last, source.nc); - Anope::string timebuf2 = do_strftime(info->last, source.nc, true); + Anope::string timebuf = Anope::Duration(Anope::CurTime - info->last, source.nc); + Anope::string timebuf2 = Anope::strftime(info->last, source.nc, true); if (info->type == NEW) { @@ -235,7 +235,7 @@ class CommandSeen : public Command } else if (info->type == NICK_TO) { - u2 = finduser(info->nick2); + u2 = User::Find(info->nick2, true); if (u2) onlinestatus = Anope::printf( _(". %s is still online."), u2->nick.c_str()); else @@ -309,8 +309,8 @@ class DataBasePurger : public CallBack if ((Anope::CurTime - cur->second->last) > purgetime) { - Log(LOG_DEBUG) << cur->first << " was last seen " << do_strftime(cur->second->last) << ", purging entry"; - cur->second->destroy(); + Log(LOG_DEBUG) << cur->first << " was last seen " << Anope::strftime(cur->second->last) << ", purging entry"; + cur->second->Destroy(); database.erase(cur); } } @@ -320,12 +320,12 @@ class DataBasePurger : public CallBack class CSSeen : public Module { - SerializeType seeninfo_type; + Serialize::Type seeninfo_type; CommandSeen commandseen; CommandOSSeen commandosseen; DataBasePurger purger; public: - CSSeen(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), seeninfo_type("SeenInfo", SeenInfo::unserialize), commandseen(this), commandosseen(this), purger(this) + CSSeen(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), seeninfo_type("SeenInfo", SeenInfo::Unserialize), commandseen(this), commandosseen(this), purger(this) { this->SetAuthor("Anope"); @@ -344,14 +344,14 @@ class CSSeen : public Module void OnReload() anope_override { ConfigReader config; - purgetime = dotime(config.ReadValue("cs_seen", "purgetime", "30d", 0)); - expiretimeout = dotime(config.ReadValue("cs_seen", "expiretimeout", "1d", 0)); + purgetime = Anope::DoTime(config.ReadValue("cs_seen", "purgetime", "30d", 0)); + expiretimeout = Anope::DoTime(config.ReadValue("cs_seen", "expiretimeout", "1d", 0)); if (purger.GetSecs() != expiretimeout) purger.SetSecs(expiretimeout); } - void OnUserConnect(dynamic_reference<User> &u, bool &exempt) anope_override + void OnUserConnect(Reference<User> &u, bool &exempt) anope_override { if (u) UpdateUser(u, NEW, u->nick, "", "", ""); diff --git a/modules/commands/cs_set.cpp b/modules/commands/cs_set.cpp index 9851a27a1..0ac07e2b2 100644 --- a/modules/commands/cs_set.cpp +++ b/modules/commands/cs_set.cpp @@ -43,7 +43,7 @@ class CommandCSSet : public Command const CommandInfo &info = it->second; if (c_name.find_ci(this_name + " ") == 0) { - service_reference<Command> command("Command", info.name); + ServiceReference<Command> command("Command", info.name); if (command) { source.command = it->first; diff --git a/modules/commands/cs_set_autoop.cpp b/modules/commands/cs_set_autoop.cpp index 8e576be3d..0b00b151b 100644 --- a/modules/commands/cs_set_autoop.cpp +++ b/modules/commands/cs_set_autoop.cpp @@ -24,7 +24,7 @@ class CommandCSSetAutoOp : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_bantype.cpp b/modules/commands/cs_set_bantype.cpp index a963720ff..e7dfc52ee 100644 --- a/modules/commands/cs_set_bantype.cpp +++ b/modules/commands/cs_set_bantype.cpp @@ -24,7 +24,7 @@ class CommandCSSetBanType : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_chanstats.cpp b/modules/commands/cs_set_chanstats.cpp index 904d7fb22..118387ee4 100644 --- a/modules/commands/cs_set_chanstats.cpp +++ b/modules/commands/cs_set_chanstats.cpp @@ -24,7 +24,7 @@ class CommandCSSetChanstats : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (!ci) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_description.cpp b/modules/commands/cs_set_description.cpp index b72c2cf8e..a5ad525ab 100644 --- a/modules/commands/cs_set_description.cpp +++ b/modules/commands/cs_set_description.cpp @@ -24,7 +24,7 @@ class CommandCSSetDescription : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_founder.cpp b/modules/commands/cs_set_founder.cpp index a1be1ba91..25b43d481 100644 --- a/modules/commands/cs_set_founder.cpp +++ b/modules/commands/cs_set_founder.cpp @@ -24,7 +24,7 @@ class CommandCSSetFounder : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -48,7 +48,7 @@ class CommandCSSetFounder : public Command return; } - const NickAlias *na = findnick(params[1]); + const NickAlias *na = NickAlias::Find(params[1]); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, params[1].c_str()); diff --git a/modules/commands/cs_set_keeptopic.cpp b/modules/commands/cs_set_keeptopic.cpp index d95d4ac2b..24b3d4f03 100644 --- a/modules/commands/cs_set_keeptopic.cpp +++ b/modules/commands/cs_set_keeptopic.cpp @@ -24,7 +24,7 @@ class CommandCSSetKeepTopic : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_misc.cpp b/modules/commands/cs_set_misc.cpp index b5a01174e..3bf0e9bbd 100644 --- a/modules/commands/cs_set_misc.cpp +++ b/modules/commands/cs_set_misc.cpp @@ -14,7 +14,7 @@ struct CSMiscData : ExtensibleItem, Serializable { - serialize_obj<ChannelInfo> ci; + Serialize::Reference<ChannelInfo> ci; Anope::string name; Anope::string data; @@ -22,7 +22,7 @@ struct CSMiscData : ExtensibleItem, Serializable { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data sdata; @@ -33,9 +33,9 @@ struct CSMiscData : ExtensibleItem, Serializable return sdata; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (ci == NULL) return NULL; @@ -75,7 +75,7 @@ class CommandCSSetMisc : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -108,12 +108,12 @@ class CommandCSSetMisc : public Command class CSSetMisc : public Module { - SerializeType csmiscdata_type; + Serialize::Type csmiscdata_type; CommandCSSetMisc commandcssetmisc; public: CSSetMisc(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - csmiscdata_type("CSMiscData", CSMiscData::unserialize), commandcssetmisc(this) + csmiscdata_type("CSMiscData", CSMiscData::Unserialize), commandcssetmisc(this) { this->SetAuthor("Anope"); diff --git a/modules/commands/cs_set_peace.cpp b/modules/commands/cs_set_peace.cpp index f7eb8af6b..35459b59b 100644 --- a/modules/commands/cs_set_peace.cpp +++ b/modules/commands/cs_set_peace.cpp @@ -24,7 +24,7 @@ class CommandCSSetPeace : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_persist.cpp b/modules/commands/cs_set_persist.cpp index bdd3b9004..03e5d3a84 100644 --- a/modules/commands/cs_set_persist.cpp +++ b/modules/commands/cs_set_persist.cpp @@ -24,7 +24,7 @@ class CommandCSSetPersist : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -60,21 +60,19 @@ class CommandCSSetPersist : public Command ci->bi->Join(c); } - /* No botserv bot, no channel mode */ - /* Give them ChanServ - * Yes, this works fine with no Config->s_BotServ + /* No botserv bot, no channel mode, give them ChanServ. + * Yes, this works fine with no Config->BotServ. */ if (!ci->bi && !cm) { - BotInfo *bi = findbot(Config->ChanServ); - if (!bi) + if (!ChanServ) { source.Reply(_("ChanServ is required to enable persist on this network.")); return; } - bi->Assign(NULL, ci); - if (!ci->c->FindUser(bi)) - bi->Join(ci->c); + ChanServ->Assign(NULL, ci); + if (!ci->c->FindUser(ChanServ)) + ChanServ->Join(ci->c); } /* Set the perm mode */ @@ -111,14 +109,13 @@ class CommandCSSetPersist : public Command */ if (!cm && Config->BotServ.empty() && ci->bi) { - BotInfo *bi = findbot(Config->ChanServ); - if (!bi) + if (!ChanServ) { source.Reply(_("ChanServ is required to enable persist on this network.")); return; } /* Unassign bot */ - bi->UnAssign(NULL, ci); + ChanServ->UnAssign(NULL, ci); } } diff --git a/modules/commands/cs_set_private.cpp b/modules/commands/cs_set_private.cpp index 45741eb20..a677aaf38 100644 --- a/modules/commands/cs_set_private.cpp +++ b/modules/commands/cs_set_private.cpp @@ -24,7 +24,7 @@ class CommandCSSetPrivate : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_restricted.cpp b/modules/commands/cs_set_restricted.cpp index 8b520006a..45a9b188e 100644 --- a/modules/commands/cs_set_restricted.cpp +++ b/modules/commands/cs_set_restricted.cpp @@ -23,7 +23,7 @@ class CommandCSSetRestricted : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_secure.cpp b/modules/commands/cs_set_secure.cpp index 84ea75121..7659c8674 100644 --- a/modules/commands/cs_set_secure.cpp +++ b/modules/commands/cs_set_secure.cpp @@ -24,7 +24,7 @@ class CommandCSSetSecure : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_securefounder.cpp b/modules/commands/cs_set_securefounder.cpp index b8d7ac14f..d3d22f294 100644 --- a/modules/commands/cs_set_securefounder.cpp +++ b/modules/commands/cs_set_securefounder.cpp @@ -24,7 +24,7 @@ class CommandCSSetSecureFounder : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_secureops.cpp b/modules/commands/cs_set_secureops.cpp index c92401e59..9a95735be 100644 --- a/modules/commands/cs_set_secureops.cpp +++ b/modules/commands/cs_set_secureops.cpp @@ -24,7 +24,7 @@ class CommandCSSetSecureOps : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_signkick.cpp b/modules/commands/cs_set_signkick.cpp index 52d3934af..f3b482a67 100644 --- a/modules/commands/cs_set_signkick.cpp +++ b/modules/commands/cs_set_signkick.cpp @@ -24,7 +24,7 @@ class CommandCSSetSignKick : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_set_successor.cpp b/modules/commands/cs_set_successor.cpp index 64f875dce..8b36d6853 100644 --- a/modules/commands/cs_set_successor.cpp +++ b/modules/commands/cs_set_successor.cpp @@ -24,7 +24,7 @@ class CommandCSSetSuccessor : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -55,7 +55,7 @@ class CommandCSSetSuccessor : public Command if (params.size() > 1) { - const NickAlias *na = findnick(params[1]); + const NickAlias *na = NickAlias::Find(params[1]); if (!na) { diff --git a/modules/commands/cs_set_topiclock.cpp b/modules/commands/cs_set_topiclock.cpp index eb0d75e2a..9212d291d 100644 --- a/modules/commands/cs_set_topiclock.cpp +++ b/modules/commands/cs_set_topiclock.cpp @@ -24,7 +24,7 @@ class CommandCSSetTopicLock : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_status.cpp b/modules/commands/cs_status.cpp index b8ac38f77..4d609eb8d 100644 --- a/modules/commands/cs_status.cpp +++ b/modules/commands/cs_status.cpp @@ -26,7 +26,7 @@ public: { const Anope::string &channel = params[0]; - ChannelInfo *ci = cs_findchan(channel); + ChannelInfo *ci = ChannelInfo::Find(channel); if (ci == NULL) source.Reply(CHAN_X_NOT_REGISTERED, channel.c_str()); else if (!source.AccessFor(ci).HasPriv("ACCESS_CHANGE") && !source.HasPriv("chanserv/access/modify")) @@ -38,20 +38,20 @@ public: nick = params[1]; AccessGroup ag; - User *u = finduser(nick); + User *u = User::Find(nick, true); NickAlias *na = NULL; if (u != NULL) ag = ci->AccessFor(u); else { - na = findnick(nick); + na = NickAlias::Find(nick); if (na != NULL) ag = ci->AccessFor(na->nc); } - if (ag.SuperAdmin) + if (ag.super_admin) source.Reply(_("\2%s\2 is a super administrator."), nick.c_str()); - else if (ag.Founder) + else if (ag.founder) source.Reply(_("\2%s\2 is the channel founder."), nick.c_str()); else if (ag.empty()) source.Reply(_("\2%s\2 has no access on \2%s\2."), nick.c_str(), ci->name.c_str()); @@ -63,7 +63,7 @@ public: { ChanAccess *acc = ag[i]; - source.Reply(_("\2%s\2 matches access entry %s, which has privilege %s."), nick.c_str(), acc->mask.c_str(), acc->Serialize().c_str()); + source.Reply(_("\2%s\2 matches access entry %s, which has privilege %s."), nick.c_str(), acc->mask.c_str(), acc->AccessSerialize().c_str()); } } diff --git a/modules/commands/cs_suspend.cpp b/modules/commands/cs_suspend.cpp index bce549e79..b380d4c97 100644 --- a/modules/commands/cs_suspend.cpp +++ b/modules/commands/cs_suspend.cpp @@ -22,7 +22,7 @@ struct ChanSuspend : ExtensibleItem, Serializable { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data sd; @@ -32,9 +32,9 @@ struct ChanSuspend : ExtensibleItem, Serializable return sd; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &sd) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &sd) { - ChannelInfo *ci = cs_findchan(sd["chan"].astr()); + ChannelInfo *ci = ChannelInfo::Find(sd["chan"].astr()); if (ci == NULL) return NULL; @@ -77,7 +77,7 @@ class CommandCSSuspend : public Command expiry.clear(); } else - expiry_secs = dotime(expiry); + expiry_secs = Anope::DoTime(expiry); if (Config->ForceForbidReason && reason.empty()) { @@ -85,10 +85,10 @@ class CommandCSSuspend : public Command return; } - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); - ChannelInfo *ci = cs_findchan(chan); + ChannelInfo *ci = ChannelInfo::Find(chan); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str()); @@ -113,7 +113,7 @@ class CommandCSSuspend : public Command } for (unsigned i = 0; i < users.size(); ++i) - ci->c->Kick(NULL, users[i], "%s", !reason.empty() ? reason.c_str() : translate(users[i], _("This channel has been suspended."))); + ci->c->Kick(NULL, users[i], "%s", !reason.empty() ? reason.c_str() : Language::Translate(users[i], _("This channel has been suspended."))); } if (expiry_secs > 0) @@ -125,7 +125,7 @@ class CommandCSSuspend : public Command ci->Extend("cs_suspend_expire", cs); } - Log(LOG_ADMIN, source, this, ci) << (!reason.empty() ? reason : "No reason") << ", expires in " << (expiry_secs ? do_strftime(Anope::CurTime + expiry_secs) : "never"); + Log(LOG_ADMIN, source, this, ci) << (!reason.empty() ? reason : "No reason") << ", expires in " << (expiry_secs ? Anope::strftime(Anope::CurTime + expiry_secs) : "never"); source.Reply(_("Channel \002%s\002 is now suspended."), ci->name.c_str()); FOREACH_MOD(I_OnChanSuspend, OnChanSuspend(ci)); @@ -161,10 +161,10 @@ class CommandCSUnSuspend : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -206,13 +206,13 @@ class CommandCSUnSuspend : public Command class CSSuspend : public Module { - SerializeType chansuspend_type; + Serialize::Type chansuspend_type; CommandCSSuspend commandcssuspend; CommandCSUnSuspend commandcsunsuspend; public: CSSuspend(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - chansuspend_type("ChanSuspend", ChanSuspend::unserialize), commandcssuspend(this), commandcsunsuspend(this) + chansuspend_type("ChanSuspend", ChanSuspend::Unserialize), commandcssuspend(this), commandcsunsuspend(this) { this->SetAuthor("Anope"); @@ -247,7 +247,7 @@ class CSSuspend : public Module ci->Shrink("suspend_by"); ci->Shrink("suspend_reason"); - Log(LOG_NORMAL, "expire", findbot(Config->ChanServ)) << "Expiring suspend for " << ci->name; + Log(LOG_NORMAL, "expire", ChanServ) << "Expiring suspend for " << ci->name; } } }; diff --git a/modules/commands/cs_sync.cpp b/modules/commands/cs_sync.cpp index e55864f1b..23d6928a1 100644 --- a/modules/commands/cs_sync.cpp +++ b/modules/commands/cs_sync.cpp @@ -22,7 +22,7 @@ class CommandCSSync : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -35,7 +35,7 @@ class CommandCSSync : public Command Log(LOG_COMMAND, source, this, ci); for (CUserList::iterator it = ci->c->users.begin(), it_end = ci->c->users.end(); it != it_end; ++it) - chan_set_correct_modes((*it)->user, ci->c, 1, false); + ci->c->SetCorrectModes((*it)->user, true, false); source.Reply(_("All user modes on \002%s\002 have been synced."), ci->name.c_str()); } diff --git a/modules/commands/cs_tban.cpp b/modules/commands/cs_tban.cpp index 1120d05d4..40fdfedb9 100644 --- a/modules/commands/cs_tban.cpp +++ b/modules/commands/cs_tban.cpp @@ -22,7 +22,7 @@ static Module *me; class TempBan : public CallBack { private: - dynamic_reference<Channel> chan; + Reference<Channel> chan; Anope::string mask; public: @@ -46,7 +46,7 @@ class CommandCSTBan : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); const Anope::string &nick = params[1]; const Anope::string &time = params[2]; @@ -58,23 +58,22 @@ class CommandCSTBan : public Command source.Reply(CHAN_X_NOT_REGISTERED, c->name.c_str()); else if (!source.AccessFor(c->ci).HasPriv("BAN")) source.Reply(ACCESS_DENIED); - else if (!(u2 = finduser(nick))) + else if (!(u2 = User::Find(nick, true))) source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); - else if (matches_list(c, u2, CMODE_EXCEPT)) + else if (c->MatchesList(u2, CMODE_EXCEPT)) source.Reply(CHAN_EXCEPTED, u2->nick.c_str(), c->ci->name.c_str()); else if (u2->IsProtected()) source.Reply(ACCESS_DENIED); else { - time_t t = dotime(time); - Anope::string mask; - get_idealban(c->ci, u2, mask); + time_t t = Anope::DoTime(time); + Anope::string mask = c->ci->GetIdealBan(u2); c->SetMode(NULL, CMODE_BAN, mask); new TempBan(t, c, mask); - Log(LOG_COMMAND, source, this, c->ci) << "for " << mask << " to expire in " << duration(t); + Log(LOG_COMMAND, source, this, c->ci) << "for " << mask << " to expire in " << Anope::Duration(t); - source.Reply(_("%s banned from %s, will auto-expire in %s."), mask.c_str(), c->name.c_str(), duration(t).c_str()); + source.Reply(_("%s banned from %s, will auto-expire in %s."), mask.c_str(), c->name.c_str(), Anope::Duration(t).c_str()); } return; diff --git a/modules/commands/cs_topic.cpp b/modules/commands/cs_topic.cpp index 3474874d6..eccb8b2f6 100644 --- a/modules/commands/cs_topic.cpp +++ b/modules/commands/cs_topic.cpp @@ -27,7 +27,7 @@ class CommandCSTopic : public Command const Anope::string &topic = params.size() > 1 ? params[1] : ""; - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/cs_unban.cpp b/modules/commands/cs_unban.cpp index b60dfebcf..affe8eae9 100644 --- a/modules/commands/cs_unban.cpp +++ b/modules/commands/cs_unban.cpp @@ -24,7 +24,7 @@ class CommandCSUnban : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); @@ -45,7 +45,7 @@ class CommandCSUnban : public Command User *u2 = source.GetUser(); if (params.size() > 1) - u2 = finduser(params[1]); + u2 = User::Find(params[1], true); if (!u2) { @@ -55,7 +55,7 @@ class CommandCSUnban : public Command Log(LOG_COMMAND, source, this, ci) << "to unban " << u2->nick; - common_unban(ci, u2, source.GetUser() == u2); + ci->c->Unban(u2, source.GetUser() == u2); if (u2 == source.GetUser()) source.Reply(_("You have been unbanned from \002%s\002."), ci->c->name.c_str()); else diff --git a/modules/commands/cs_updown.cpp b/modules/commands/cs_updown.cpp index 4d84ff5f5..6d46c873e 100644 --- a/modules/commands/cs_updown.cpp +++ b/modules/commands/cs_updown.cpp @@ -32,19 +32,19 @@ class CommandCSUp : public Command for (UChannelList::iterator it = u->chans.begin(); it != u->chans.end(); ++it) { Channel *c = (*it)->chan; - chan_set_correct_modes(u, c, 1, false); + c->SetCorrectModes(u, true, false); } else { const Anope::string &channel = params[0]; - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c == NULL) source.Reply(CHAN_X_NOT_IN_USE, channel.c_str()); else if (!c->ci) source.Reply(CHAN_X_NOT_REGISTERED, channel.c_str()); else - chan_set_correct_modes(u, c, 1, false); + c->SetCorrectModes(u, true, false); } } @@ -67,7 +67,7 @@ class CommandCSDown : public Command { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (cm != NULL && cm->Type == MODE_STATUS) + if (cm != NULL && cm->type == MODE_STATUS) c->RemoveMode(NULL, cm, u->nick); } } @@ -94,7 +94,7 @@ class CommandCSDown : public Command else { const Anope::string &channel = params[0]; - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c == NULL) source.Reply(CHAN_X_NOT_IN_USE, channel.c_str()); diff --git a/modules/commands/cs_xop.cpp b/modules/commands/cs_xop.cpp index 1fc3cbdf0..77f6cb5a0 100644 --- a/modules/commands/cs_xop.cpp +++ b/modules/commands/cs_xop.cpp @@ -118,7 +118,7 @@ class XOPChanAccess : public ChanAccess return false; } - Anope::string Serialize() const + Anope::string AccessSerialize() const { for (int i = 0; xopAccess[i].type != XOP_UNKNOWN; ++i) { @@ -131,7 +131,7 @@ class XOPChanAccess : public ChanAccess return ""; } - void Unserialize(const Anope::string &data) anope_override + void AccessUnserialize(const Anope::string &data) anope_override { for (int i = 0; xopAccess[i].type != XOP_UNKNOWN; ++i) { @@ -210,7 +210,7 @@ class XOPBase : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, channel %s list modification is temporarily disabled."), source.command.c_str()); return; @@ -224,7 +224,7 @@ class XOPBase : public Command const ChanAccess *highest = access.Highest(); bool override = false; - if ((!access.Founder && !access.HasPriv("ACCESS_CHANGE")) || ((!highest || *highest <= tmp_access) && !access.Founder)) + if ((!access.founder && !access.HasPriv("ACCESS_CHANGE")) || ((!highest || *highest <= tmp_access) && !access.founder)) { if (source.HasPriv("chanserv/access/modify")) override = true; @@ -235,9 +235,9 @@ class XOPBase : public Command } } - if (mask.find_first_of("!*@") == Anope::string::npos && !findnick(mask)) + if (mask.find_first_of("!*@") == Anope::string::npos && !NickAlias::Find(mask)) { - User *targ = finduser(mask); + User *targ = User::Find(mask, true); if (targ != NULL) mask = "*!*@" + targ->GetDisplayedHost(); else @@ -253,7 +253,7 @@ class XOPBase : public Command if (a->mask.equals_ci(mask)) { - if ((!highest || *a >= *highest) && !access.Founder && !source.HasPriv("chanserv/access/modify")) + if ((!highest || *a >= *highest) && !access.founder && !source.HasPriv("chanserv/access/modify")) { source.Reply(ACCESS_DENIED); return; @@ -270,7 +270,7 @@ class XOPBase : public Command return; } - service_reference<AccessProvider> provider("AccessProvider", "access/xop"); + ServiceReference<AccessProvider> provider("AccessProvider", "access/xop"); if (!provider) return; XOPChanAccess *acc = anope_dynamic_static_cast<XOPChanAccess *>(provider->Create()); @@ -299,7 +299,7 @@ class XOPBase : public Command return; } - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, channel %s list modification is temporarily disabled."), source.command.c_str()); return; @@ -319,9 +319,9 @@ class XOPBase : public Command const ChanAccess *highest = access.Highest(); bool override = false; - if (mask.find_first_of("!*@") == Anope::string::npos && !findnick(mask)) + if (mask.find_first_of("!*@") == Anope::string::npos && !NickAlias::Find(mask)) { - User *targ = finduser(mask); + User *targ = User::Find(mask, true); if (targ != NULL) mask = "*!*@" + targ->GetDisplayedHost(); else @@ -331,7 +331,7 @@ class XOPBase : public Command } } - if ((!mask.equals_ci(nc->display) && !access.HasPriv("ACCESS_CHANGE") && !access.Founder) || ((!highest || tmp_access >= *highest) && !access.Founder)) + if ((!mask.equals_ci(nc->display) && !access.HasPriv("ACCESS_CHANGE") && !access.founder) || ((!highest || tmp_access >= *highest) && !access.founder)) { if (source.HasPriv("chanserv/access/modify")) override = true; @@ -350,49 +350,49 @@ class XOPBase : public Command CommandSource &source; ChannelInfo *ci; Command *c; - unsigned Deleted; - Anope::string Nicks; + unsigned deleted; + Anope::string nicks; bool override; XOPType type; public: - XOPDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, bool _override, XOPType _type, const Anope::string &numlist) : NumberList(numlist, true), source(_source), ci(_ci), c(_c), Deleted(0), override(_override), type(_type) + XOPDelCallback(CommandSource &_source, ChannelInfo *_ci, Command *_c, bool _override, XOPType _type, const Anope::string &numlist) : NumberList(numlist, true), source(_source), ci(_ci), c(_c), deleted(0), override(_override), type(_type) { } ~XOPDelCallback() { - if (!Deleted) + if (!deleted) source.Reply(_("No matching entries on %s %s list."), ci->name.c_str(), source.command.c_str()); else { - Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, c, ci) << "to delete " << Nicks; + Log(override ? LOG_OVERRIDE : LOG_COMMAND, source, c, ci) << "to delete " << nicks; - if (Deleted == 1) + if (deleted == 1) source.Reply(_("Deleted one entry from %s %s list."), ci->name.c_str(), source.command.c_str()); else - source.Reply(_("Deleted %d entries from %s %s list."), Deleted, ci->name.c_str(), source.command.c_str()); + source.Reply(_("Deleted %d entries from %s %s list."), deleted, ci->name.c_str(), source.command.c_str()); } } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number || Number > ci->GetAccessCount()) + if (!number || number > ci->GetAccessCount()) return; - ChanAccess *caccess = ci->GetAccess(Number - 1); + ChanAccess *caccess = ci->GetAccess(number - 1); if (this->type != XOPChanAccess::DetermineLevel(caccess)) return; - ++Deleted; - if (!Nicks.empty()) - Nicks += ", " + caccess->mask; + ++deleted; + if (!nicks.empty()) + nicks += ", " + caccess->mask; else - Nicks = caccess->mask; + nicks = caccess->mask; FOREACH_MOD(I_OnAccessDel, OnAccessDel(ci, source, caccess)); - ci->EraseAccess(Number - 1); + ci->EraseAccess(number - 1); } } delcallback(source, ci, this, override, level, mask); @@ -441,7 +441,7 @@ class XOPBase : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Mask"); + list.AddColumn("Number").AddColumn("Mask"); if (!nick.empty() && nick.find_first_not_of("1234567890,-") == Anope::string::npos) { @@ -468,7 +468,7 @@ class XOPBase : public Command ListFormatter::ListEntry entry; entry["Number"] = stringify(Number); entry["Mask"] = a->mask; - this->list.addEntry(entry); + this->list.AddEntry(entry); } } nl_list(list, ci, nick, level); nl_list.Process(); @@ -487,11 +487,11 @@ class XOPBase : public Command ListFormatter::ListEntry entry; entry["Number"] = stringify(i + 1); entry["Mask"] = a->mask; - list.addEntry(entry); + list.AddEntry(entry); } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on %s access list."), ci->name.c_str()); else { @@ -507,7 +507,7 @@ class XOPBase : public Command void DoClear(CommandSource &source, ChannelInfo *ci, XOPType level) { - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, channel %s list modification is temporarily disabled."), source.command.c_str()); return; @@ -545,7 +545,7 @@ class XOPBase : public Command protected: void DoXop(CommandSource &source, const std::vector<Anope::string> ¶ms, XOPType level) { - ChannelInfo *ci = cs_findchan(params[0]); + ChannelInfo *ci = ChannelInfo::Find(params[0]); if (ci == NULL) { source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/gl_global.cpp b/modules/commands/gl_global.cpp index 09d44f9a0..2be0164e3 100644 --- a/modules/commands/gl_global.cpp +++ b/modules/commands/gl_global.cpp @@ -27,12 +27,12 @@ class CommandGLGlobal : public Command { const Anope::string &msg = params[0]; - if (!global) + if (!GlobalService) source.Reply("No global reference, is gl_main loaded?"); else { Log(LOG_ADMIN, source, this); - global->SendGlobal(findbot(Config->Global), source.GetNick(), msg); + GlobalService->SendGlobal(Global, source.GetNick(), msg); } } diff --git a/modules/commands/help.cpp b/modules/commands/help.cpp index de80a6ec1..252406590 100644 --- a/modules/commands/help.cpp +++ b/modules/commands/help.cpp @@ -41,11 +41,12 @@ class CommandHelp : public Command const CommandInfo &info = it->second; // Smaller command exists - Anope::string cmd = myStrGetToken(c_name, ' ', 0); + Anope::string cmd; + spacesepstream(c_name).GetToken(cmd, 0); if (cmd != it->first && map.count(cmd)) continue; - service_reference<Command> c("Command", info.name); + ServiceReference<Command> c("Command", info.name); if (!c) continue; else if (!Config->HidePrivilegedCommands) @@ -76,7 +77,7 @@ class CommandHelp : public Command const CommandInfo &info = it->second; - service_reference<Command> c("Command", info.name); + ServiceReference<Command> c("Command", info.name); if (!c) continue; else if (!Config->HidePrivilegedCommands) diff --git a/modules/commands/hs_del.cpp b/modules/commands/hs_del.cpp index 9ad39a95d..4e2cdc8b7 100644 --- a/modules/commands/hs_del.cpp +++ b/modules/commands/hs_del.cpp @@ -25,7 +25,7 @@ class CommandHSDel : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { const Anope::string &nick = params[0]; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (na) { Log(LOG_ADMIN, source, this) << "for user " << na->nick; @@ -59,12 +59,12 @@ class CommandHSDelAll : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { const Anope::string &nick = params[0]; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (na) { FOREACH_MOD(I_OnDeleteVhost, OnDeleteVhost(na)); const NickCore *nc = na->nc; - for (std::list<serialize_obj<NickAlias> >::const_iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end; ++it) + for (std::list<Serialize::Reference<NickAlias> >::const_iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end; ++it) { na = *it; na->RemoveVhost(); diff --git a/modules/commands/hs_group.cpp b/modules/commands/hs_group.cpp index 22538ed1a..5d8bc069e 100644 --- a/modules/commands/hs_group.cpp +++ b/modules/commands/hs_group.cpp @@ -20,7 +20,7 @@ class CommandHSGroup : public Command if (!na || !na->HasVhost()) return; - for (std::list<serialize_obj<NickAlias> >::const_iterator it = na->nc->aliases.begin(), it_end = na->nc->aliases.end(); it != it_end;) + for (std::list<Serialize::Reference<NickAlias> >::const_iterator it = na->nc->aliases.begin(), it_end = na->nc->aliases.end(); it != it_end;) { NickAlias *nick = *it++; if (nick) @@ -37,7 +37,7 @@ class CommandHSGroup : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - NickAlias *na = findnick(source.GetNick()); + NickAlias *na = NickAlias::Find(source.GetNick()); if (na && source.GetAccount() == na->nc && na->HasVhost()) { this->Sync(na); diff --git a/modules/commands/hs_list.cpp b/modules/commands/hs_list.cpp index 9e708f0b4..29fa145b3 100644 --- a/modules/commands/hs_list.cpp +++ b/modules/commands/hs_list.cpp @@ -57,7 +57,7 @@ class CommandHSList : public Command unsigned display_counter = 0; ListFormatter list; - list.addColumn("Number").addColumn("Nick").addColumn("Vhost").addColumn("Creator").addColumn("Created"); + list.AddColumn("Number").AddColumn("Nick").AddColumn("Vhost").AddColumn("Creator").AddColumn("Created"); for (nickalias_map::const_iterator it = NickAliasList->begin(), it_end = NickAliasList->end(); it != it_end; ++it) { @@ -80,8 +80,8 @@ class CommandHSList : public Command else entry["Vhost"] = na->GetVhostHost(); entry["Creator"] = na->GetVhostCreator(); - entry["Created"] = do_strftime(na->GetVhostCreated()); - list.addEntry(entry); + entry["Created"] = Anope::strftime(na->GetVhostCreated()); + list.AddEntry(entry); } } else @@ -101,8 +101,8 @@ class CommandHSList : public Command else entry["Vhost"] = na->GetVhostHost(); entry["Creator"] = na->GetVhostCreator(); - entry["Created"] = do_strftime(na->GetVhostCreated()); - list.addEntry(entry); + entry["Created"] = Anope::strftime(na->GetVhostCreated()); + list.AddEntry(entry); } } ++counter; diff --git a/modules/commands/hs_off.cpp b/modules/commands/hs_off.cpp index 39b701fed..27c6c0756 100644 --- a/modules/commands/hs_off.cpp +++ b/modules/commands/hs_off.cpp @@ -28,13 +28,13 @@ class CommandHSOff : public Command if (!u) return; - const NickAlias *na = findnick(u->nick); + const NickAlias *na = NickAlias::Find(u->nick); if (!na || !na->HasVhost()) source.Reply(HOST_NOT_ASSIGNED); else { - ircdproto->SendVhostDel(u); + IRCD->SendVhostDel(u); Log(LOG_COMMAND, source, this) << "to disable their vhost"; source.Reply(_("Your vhost was removed and the normal cloaking restored.")); } diff --git a/modules/commands/hs_on.cpp b/modules/commands/hs_on.cpp index d02dd7dfe..c4cf2fee8 100644 --- a/modules/commands/hs_on.cpp +++ b/modules/commands/hs_on.cpp @@ -27,10 +27,10 @@ class CommandHSOn : public Command User *u = source.GetUser(); if (!u) return; - else if (!ircdproto->CanSetVHost) + else if (!IRCD->CanSetVHost) return; // HostServ wouldn't even be loaded at this point - const NickAlias *na = findnick(u->nick); + const NickAlias *na = NickAlias::Find(u->nick); if (na && u->Account() == na->nc && na->HasVhost()) { if (!na->GetVhostIdent().empty()) @@ -38,9 +38,9 @@ class CommandHSOn : public Command else source.Reply(_("Your vhost of \002%s\002 is now activated."), na->GetVhostHost().c_str()); Log(LOG_COMMAND, source, this) << "to enable their vhost of " << (!na->GetVhostIdent().empty() ? na->GetVhostIdent() + "@" : "") << na->GetVhostHost(); - ircdproto->SendVhost(u, na->GetVhostIdent(), na->GetVhostHost()); + IRCD->SendVhost(u, na->GetVhostIdent(), na->GetVhostHost()); u->vhost = na->GetVhostHost(); - if (ircdproto->CanSetVIdent && !na->GetVhostIdent().empty()) + if (IRCD->CanSetVIdent && !na->GetVhostIdent().empty()) u->SetVIdent(na->GetVhostIdent()); u->UpdateHost(); } diff --git a/modules/commands/hs_request.cpp b/modules/commands/hs_request.cpp index 8a9de386b..b11059f90 100644 --- a/modules/commands/hs_request.cpp +++ b/modules/commands/hs_request.cpp @@ -32,21 +32,21 @@ struct HostRequest : ExtensibleItem, Serializable HostRequest() : Serializable("HostRequest") { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data data; data["nick"] << this->nick; data["ident"] << this->ident; data["host"] << this->host; - data["time"].setType(Serialize::DT_INT) << this->time; + data["time"].SetType(Serialize::DT_INT) << this->time; return data; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { - NickAlias *na = findnick(data["nick"].astr()); + NickAlias *na = NickAlias::Find(data["nick"].astr()); if (na == NULL) return NULL; @@ -85,7 +85,7 @@ class CommandHSRequest : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { User *u = source.GetUser(); - NickAlias *na = findnick(source.GetNick()); + NickAlias *na = NickAlias::Find(source.GetNick()); if (!na || na->nc != source.GetAccount()) { source.Reply(ACCESS_DENIED); @@ -118,7 +118,7 @@ class CommandHSRequest : public Command source.Reply(HOST_SET_IDENTTOOLONG, Config->UserLen); return; } - else if (!ircdproto->CanSetVIdent) + else if (!IRCD->CanSetVIdent) { source.Reply(HOST_NO_VIDENT); return; @@ -137,7 +137,7 @@ class CommandHSRequest : public Command return; } - if (!IsValidHost(host)) + if (!IRCD->IsHostValid(host)) { source.Reply(HOST_SET_ERROR); return; @@ -190,15 +190,15 @@ class CommandHSActivate : public Command const Anope::string &nick = params[0]; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); HostRequest *req = na ? na->GetExt<HostRequest *>("hs_request") : NULL; if (req) { na->SetVhost(req->ident, req->host, source.GetNick(), req->time); FOREACH_MOD(I_OnSetVhost, OnSetVhost(na)); - if (HSRequestMemoUser && memoserv) - memoserv->Send(Config->HostServ, na->nick, _("[auto memo] Your requested vHost has been approved."), true); + if (HSRequestMemoUser && MemoServService) + MemoServService->Send(Config->HostServ, na->nick, _("[auto memo] Your requested vHost has been approved."), true); source.Reply(_("vHost for %s has been activated"), na->nick.c_str()); Log(LOG_COMMAND, source, this) << "for " << na->nick << " for vhost " << (!req->ident.empty() ? req->ident + "@" : "") << req->host; @@ -234,13 +234,13 @@ class CommandHSReject : public Command const Anope::string &nick = params[0]; const Anope::string &reason = params.size() > 1 ? params[1] : ""; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); HostRequest *req = na ? na->GetExt<HostRequest *>("hs_request") : NULL; if (req) { na->Shrink("hs_request"); - if (HSRequestMemoUser && memoserv) + if (HSRequestMemoUser && MemoServService) { Anope::string message; if (!reason.empty()) @@ -248,7 +248,7 @@ class CommandHSReject : public Command else message = _("[auto memo] Your requested vHost has been rejected."); - memoserv->Send(Config->HostServ, nick, message, true); + MemoServService->Send(Config->HostServ, nick, message, true); } source.Reply(_("vHost for %s has been rejected"), nick.c_str()); @@ -281,7 +281,7 @@ class CommandHSWaiting : public Command unsigned display_counter = 0; ListFormatter list; - list.addColumn("Number").addColumn("Nick").addColumn("Vhost").addColumn("Created"); + list.AddColumn("Number").AddColumn("Nick").AddColumn("Vhost").AddColumn("Created"); for (nickalias_map::const_iterator it = NickAliasList->begin(), it_end = NickAliasList->end(); it != it_end; ++it) { @@ -301,8 +301,8 @@ class CommandHSWaiting : public Command entry["Vhost"] = hr->ident + "@" + hr->host; else entry["Vhost"] = hr->host; - entry["Created"] = do_strftime(hr->time); - list.addEntry(entry); + entry["Created"] = Anope::strftime(hr->time); + list.AddEntry(entry); } ++counter; } @@ -339,7 +339,7 @@ class CommandHSWaiting : public Command class HSRequest : public Module { - SerializeType request_type; + Serialize::Type request_type; CommandHSRequest commandhsrequest; CommandHSActivate commandhsactive; CommandHSReject commandhsreject; @@ -347,11 +347,11 @@ class HSRequest : public Module public: HSRequest(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - request_type("HostRequest", HostRequest::unserialize), commandhsrequest(this), commandhsactive(this), commandhsreject(this), commandhswaiting(this) + request_type("HostRequest", HostRequest::Unserialize), commandhsrequest(this), commandhsactive(this), commandhsreject(this), commandhswaiting(this) { this->SetAuthor("Anope"); - if (!ircdproto || !ircdproto->CanSetVHost) + if (!IRCD || !IRCD->CanSetVHost) throw ModuleException("Your IRCd does not support vhosts"); Implementation i[] = { I_OnReload }; @@ -389,18 +389,18 @@ void req_send_memos(CommandSource &source, const Anope::string &vIdent, const An else host = vHost; - if (HSRequestMemoOper == 1 && memoserv) + if (HSRequestMemoOper == 1 && MemoServService) for (unsigned i = 0; i < Config->Opers.size(); ++i) { Oper *o = Config->Opers[i]; - const NickAlias *na = findnick(o->name); + const NickAlias *na = NickAlias::Find(o->name); if (!na) continue; Anope::string message = Anope::printf(_("[auto memo] vHost \002%s\002 has been requested by %s."), host.c_str(), source.GetNick().c_str()); - memoserv->Send(Config->HostServ, na->nick, message, true); + MemoServService->Send(Config->HostServ, na->nick, message, true); } } diff --git a/modules/commands/hs_set.cpp b/modules/commands/hs_set.cpp index 2189f2483..bb4091da4 100644 --- a/modules/commands/hs_set.cpp +++ b/modules/commands/hs_set.cpp @@ -27,7 +27,7 @@ class CommandHSSet : public Command const Anope::string &nick = params[0]; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (na == NULL) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -55,12 +55,12 @@ class CommandHSSet : public Command if (!user.empty()) { - if (!ircdproto->CanSetVIdent) + if (!IRCD->CanSetVIdent) { source.Reply(HOST_NO_VIDENT); return; } - else if (!IsValidIdent(user)) + else if (!IRCD->IsIdentValid(user)) { source.Reply(HOST_SET_IDENT_ERROR); return; @@ -73,7 +73,7 @@ class CommandHSSet : public Command return; } - if (!IsValidHost(host)) + if (!IRCD->IsHostValid(host)) { source.Reply(HOST_SET_ERROR); return; @@ -108,7 +108,7 @@ class CommandHSSetAll : public Command if (!na || !na->HasVhost()) return; - for (std::list<serialize_obj<NickAlias> >::const_iterator it = na->nc->aliases.begin(), it_end = na->nc->aliases.end(); it != it_end;) + for (std::list<Serialize::Reference<NickAlias> >::const_iterator it = na->nc->aliases.begin(), it_end = na->nc->aliases.end(); it != it_end;) { NickAlias *nick = *it++; if (nick) @@ -128,7 +128,7 @@ class CommandHSSetAll : public Command Anope::string nick = params[0]; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (na == NULL) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -156,12 +156,12 @@ class CommandHSSetAll : public Command if (!user.empty()) { - if (!ircdproto->CanSetVIdent) + if (!IRCD->CanSetVIdent) { source.Reply(HOST_NO_VIDENT); return; } - else if (!IsValidIdent(user)) + else if (!IRCD->IsIdentValid(user)) { source.Reply(HOST_SET_IDENT_ERROR); return; @@ -174,7 +174,7 @@ class CommandHSSetAll : public Command return; } - if (!IsValidHost(host)) + if (!IRCD->IsHostValid(host)) { source.Reply(HOST_SET_ERROR); return; diff --git a/modules/commands/ms_cancel.cpp b/modules/commands/ms_cancel.cpp index e4ee9375e..8949baf17 100644 --- a/modules/commands/ms_cancel.cpp +++ b/modules/commands/ms_cancel.cpp @@ -25,14 +25,14 @@ class CommandMSCancel : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!memoserv) + if (!MemoServService) return; const Anope::string &nname = params[0]; bool ischan; - MemoInfo *mi = memoserv->GetMemoInfo(nname, ischan); + MemoInfo *mi = MemoServService->GetMemoInfo(nname, ischan); if (mi == NULL) source.Reply(ischan ? CHAN_X_NOT_REGISTERED : _(NICK_X_NOT_REGISTERED), nname.c_str()); @@ -41,9 +41,9 @@ class CommandMSCancel : public Command ChannelInfo *ci = NULL; NickAlias *na = NULL; if (ischan) - ci = cs_findchan(nname); + ci = ChannelInfo::Find(nname); else - na = findnick(nname); + na = NickAlias::Find(nname); for (int i = mi->memos->size() - 1; i >= 0; --i) if (mi->GetMemo(i)->HasFlag(MF_UNREAD) && source.nc->display.equals_ci(mi->GetMemo(i)->sender)) { @@ -81,7 +81,7 @@ class MSCancel : public Module { this->SetAuthor("Anope"); - if (!memoserv) + if (!MemoServService) throw ModuleException("No MemoServ!"); } }; diff --git a/modules/commands/ms_check.cpp b/modules/commands/ms_check.cpp index 59340b6d7..8f34e7b9a 100644 --- a/modules/commands/ms_check.cpp +++ b/modules/commands/ms_check.cpp @@ -29,7 +29,7 @@ class CommandMSCheck : public Command bool found = false; - const NickAlias *na = findnick(recipient); + const NickAlias *na = NickAlias::Find(recipient); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, recipient.c_str()); @@ -48,9 +48,9 @@ class CommandMSCheck : public Command found = true; /* Yes, we've found the memo */ if (mi->GetMemo(i)->HasFlag(MF_UNREAD)) - source.Reply(_("The last memo you sent to %s (sent on %s) has not yet been read."), na->nick.c_str(), do_strftime(mi->GetMemo(i)->time).c_str()); + source.Reply(_("The last memo you sent to %s (sent on %s) has not yet been read."), na->nick.c_str(), Anope::strftime(mi->GetMemo(i)->time).c_str()); else - source.Reply(_("The last memo you sent to %s (sent on %s) has been read."), na->nick.c_str(), do_strftime(mi->GetMemo(i)->time).c_str()); + source.Reply(_("The last memo you sent to %s (sent on %s) has been read."), na->nick.c_str(), Anope::strftime(mi->GetMemo(i)->time).c_str()); break; } } diff --git a/modules/commands/ms_del.cpp b/modules/commands/ms_del.cpp index 330f45e87..99b388e52 100644 --- a/modules/commands/ms_del.cpp +++ b/modules/commands/ms_del.cpp @@ -23,18 +23,18 @@ class MemoDelCallback : public NumberList { } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number || Number > mi->memos->size()) + if (!number || number > mi->memos->size()) return; if (ci) - FOREACH_MOD(I_OnMemoDel, OnMemoDel(ci, mi, mi->GetMemo(Number - 1))); + FOREACH_MOD(I_OnMemoDel, OnMemoDel(ci, mi, mi->GetMemo(number - 1))); else - FOREACH_MOD(I_OnMemoDel, OnMemoDel(source.nc, mi, mi->GetMemo(Number - 1))); + FOREACH_MOD(I_OnMemoDel, OnMemoDel(source.nc, mi, mi->GetMemo(number - 1))); - mi->Del(Number - 1); - source.Reply(_("Memo %d has been deleted."), Number); + mi->Del(number - 1); + source.Reply(_("Memo %d has been deleted."), number); } }; @@ -59,13 +59,13 @@ class CommandMSDel : public Command chan = numstr; numstr = params.size() > 1 ? params[1] : ""; - ci = cs_findchan(chan); + ci = ChannelInfo::Find(chan); if (!ci) { source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str()); return; } - else if (readonly) + else if (Anope::ReadOnly) { source.Reply(READ_ONLY_MODE); return; @@ -114,7 +114,7 @@ class CommandMSDel : public Command FOREACH_MOD(I_OnMemoDel, OnMemoDel(ci, mi, mi->GetMemo(i))); else FOREACH_MOD(I_OnMemoDel, OnMemoDel(source.nc, mi, mi->GetMemo(i))); - mi->GetMemo(i)->destroy(); + mi->GetMemo(i)->Destroy(); } mi->memos->clear(); if (!chan.empty()) diff --git a/modules/commands/ms_ignore.cpp b/modules/commands/ms_ignore.cpp index 84ce540a8..465714852 100644 --- a/modules/commands/ms_ignore.cpp +++ b/modules/commands/ms_ignore.cpp @@ -26,7 +26,7 @@ class CommandMSIgnore : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!memoserv) + if (!MemoServService) return; @@ -42,8 +42,8 @@ class CommandMSIgnore : public Command } bool ischan; - MemoInfo *mi = memoserv->GetMemoInfo(channel, ischan); - ChannelInfo *ci = cs_findchan(channel); + MemoInfo *mi = MemoServService->GetMemoInfo(channel, ischan); + ChannelInfo *ci = ChannelInfo::Find(channel); if (!mi) source.Reply(ischan ? CHAN_X_NOT_REGISTERED : _(NICK_X_NOT_REGISTERED), channel.c_str()); else if (ischan && !source.AccessFor(ci).HasPriv("MEMO")) @@ -77,12 +77,12 @@ class CommandMSIgnore : public Command else { ListFormatter list; - list.addColumn("Mask"); + list.AddColumn("Mask"); for (unsigned i = 0; i < mi->ignores.size(); ++i) { ListFormatter::ListEntry entry; entry["Mask"] = mi->ignores[i]; - list.addEntry(entry); + list.AddEntry(entry); } source.Reply(_("Ignore list:")); @@ -120,7 +120,7 @@ class MSIgnore : public Module { this->SetAuthor("Anope"); - if (!memoserv) + if (!MemoServService) throw ModuleException("No MemoServ!"); } }; diff --git a/modules/commands/ms_info.cpp b/modules/commands/ms_info.cpp index d2c7eea3b..b209d0bf4 100644 --- a/modules/commands/ms_info.cpp +++ b/modules/commands/ms_info.cpp @@ -33,7 +33,7 @@ class CommandMSInfo : public Command if (!nname.empty() && nname[0] != '#' && source.HasPriv("memoserv/info")) { - na = findnick(nname); + na = NickAlias::Find(nname); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, nname.c_str()); @@ -44,7 +44,7 @@ class CommandMSInfo : public Command } else if (!nname.empty() && nname[0] == '#') { - ci = cs_findchan(nname); + ci = ChannelInfo::Find(nname); if (!ci) { source.Reply(CHAN_X_NOT_REGISTERED, nname.c_str()); diff --git a/modules/commands/ms_list.cpp b/modules/commands/ms_list.cpp index f6a92e9df..91196cfee 100644 --- a/modules/commands/ms_list.cpp +++ b/modules/commands/ms_list.cpp @@ -34,7 +34,7 @@ class CommandMSList : public Command chan = param; param = params.size() > 1 ? params[1] : ""; - ci = cs_findchan(chan); + ci = ChannelInfo::Find(chan); if (!ci) { source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str()); @@ -63,7 +63,7 @@ class CommandMSList : public Command { ListFormatter list; - list.addColumn("Number").addColumn("Sender").addColumn("Date/Time"); + list.AddColumn("Number").AddColumn("Sender").AddColumn("Date/Time"); if (!param.empty() && isdigit(param[0])) { @@ -77,18 +77,18 @@ class CommandMSList : public Command { } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number || Number > mi->memos->size()) + if (!number || number > mi->memos->size()) return; - const Memo *m = mi->GetMemo(Number); + const Memo *m = mi->GetMemo(number); ListFormatter::ListEntry entry; - entry["Number"] = (m->HasFlag(MF_UNREAD) ? "* " : " ") + stringify(Number + 1); + entry["Number"] = (m->HasFlag(MF_UNREAD) ? "* " : " ") + stringify(number + 1); entry["Sender"] = m->sender; - entry["Date/Time"] = do_strftime(m->time); - this->list.addEntry(entry); + entry["Date/Time"] = Anope::strftime(m->time); + this->list.AddEntry(entry); } } mlc(list, source, mi, param); @@ -122,8 +122,8 @@ class CommandMSList : public Command ListFormatter::ListEntry entry; entry["Number"] = (m->HasFlag(MF_UNREAD) ? "* " : " ") + stringify(i + 1); entry["Sender"] = m->sender; - entry["Date/Time"] = do_strftime(m->time); - list.addEntry(entry); + entry["Date/Time"] = Anope::strftime(m->time); + list.AddEntry(entry); } } diff --git a/modules/commands/ms_read.cpp b/modules/commands/ms_read.cpp index 5b46ef0dd..6d5adfb05 100644 --- a/modules/commands/ms_read.cpp +++ b/modules/commands/ms_read.cpp @@ -17,10 +17,10 @@ static void rsend_notify(CommandSource &source, MemoInfo *mi, Memo *m, const Anope::string &targ) { /* Only send receipt if memos are allowed */ - if (memoserv && !readonly) + if (MemoServService && !Anope::ReadOnly) { /* Get nick alias for sender */ - const NickAlias *na = findnick(m->sender); + const NickAlias *na = NickAlias::Find(m->sender); if (!na) return; @@ -33,10 +33,10 @@ static void rsend_notify(CommandSource &source, MemoInfo *mi, Memo *m, const Ano /* Text of the memo varies if the recepient was a nick or channel */ - Anope::string text = Anope::printf(translate(na->nc, _("\002[auto-memo]\002 The memo you sent to %s has been viewed.")), targ.c_str()); + Anope::string text = Anope::printf(Language::Translate(na->nc, _("\002[auto-memo]\002 The memo you sent to %s has been viewed.")), targ.c_str()); /* Send notification */ - memoserv->Send(source.GetNick(), m->sender, text, true); + MemoServService->Send(source.GetNick(), m->sender, text, true); /* Notify recepient of the memo that a notification has been sent to the sender */ @@ -58,21 +58,21 @@ class MemoListCallback : public NumberList { } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number || Number > mi->memos->size()) + if (!number || number > mi->memos->size()) return; - MemoListCallback::DoRead(source, mi, ci, Number - 1); + MemoListCallback::DoRead(source, mi, ci, number - 1); } static void DoRead(CommandSource &source, MemoInfo *mi, const ChannelInfo *ci, unsigned index) { Memo *m = mi->GetMemo(index); if (ci) - source.Reply(_("Memo %d from %s (%s). To delete, type: \002%s%s DEL %s %d\002"), index + 1, m->sender.c_str(), do_strftime(m->time).c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), ci->name.c_str(), index + 1); + source.Reply(_("Memo %d from %s (%s). To delete, type: \002%s%s DEL %s %d\002"), index + 1, m->sender.c_str(), Anope::strftime(m->time).c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), ci->name.c_str(), index + 1); else - source.Reply(_("Memo %d from %s (%s). To delete, type: \002%s%s DEL %d\002"), index + 1, m->sender.c_str(), do_strftime(m->time).c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), index + 1); + source.Reply(_("Memo %d from %s (%s). To delete, type: \002%s%s DEL %d\002"), index + 1, m->sender.c_str(), Anope::strftime(m->time).c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), index + 1); source.Reply("%s", m->text.c_str()); m->UnsetFlag(MF_UNREAD); @@ -103,7 +103,7 @@ class CommandMSRead : public Command chan = numstr; numstr = params.size() > 1 ? params[1] : ""; - ci = cs_findchan(chan); + ci = ChannelInfo::Find(chan); if (!ci) { source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str()); diff --git a/modules/commands/ms_rsend.cpp b/modules/commands/ms_rsend.cpp index 9c47b9f53..b08b9be85 100644 --- a/modules/commands/ms_rsend.cpp +++ b/modules/commands/ms_rsend.cpp @@ -25,7 +25,7 @@ class CommandMSRSend : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!memoserv) + if (!MemoServService) return; @@ -34,7 +34,7 @@ class CommandMSRSend : public Command const NickAlias *na = NULL; /* prevent user from rsend to themselves */ - if ((na = findnick(nick)) && na->nc == source.GetAccount()) + if ((na = NickAlias::Find(nick)) && na->nc == source.GetAccount()) { source.Reply(_("You can not request a receipt when sending a memo to yourself.")); return; @@ -49,7 +49,7 @@ class CommandMSRSend : public Command } else { - MemoServService::MemoResult result = memoserv->Send(source.GetNick(), nick, text); + MemoServService::MemoResult result = MemoServService->Send(source.GetNick(), nick, text); if (result == MemoServService::MEMO_INVALID_TARGET) source.Reply(_("\002%s\002 is not a registered unforbidden nick or channel."), nick.c_str()); else if (result == MemoServService::MEMO_TOO_FAST) @@ -61,7 +61,7 @@ class CommandMSRSend : public Command source.Reply(_("Memo sent to \002%s\002."), name.c_str()); bool ischan; - MemoInfo *mi = memoserv->GetMemoInfo(nick, ischan); + MemoInfo *mi = MemoServService->GetMemoInfo(nick, ischan); if (mi == NULL) throw CoreException("NULL mi in ms_rsend"); Memo *m = (mi->memos->size() ? mi->GetMemo(mi->memos->size() - 1) : NULL); @@ -98,7 +98,7 @@ class MSRSend : public Module { this->SetAuthor("Anope"); - if (!memoserv) + if (!MemoServService) throw ModuleException("No MemoServ!"); else if (!Config->MSMemoReceipt) throw ModuleException("Invalid value for memoreceipt"); diff --git a/modules/commands/ms_send.cpp b/modules/commands/ms_send.cpp index a2ba53a9e..42024227e 100644 --- a/modules/commands/ms_send.cpp +++ b/modules/commands/ms_send.cpp @@ -25,13 +25,13 @@ class CommandMSSend : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!memoserv) + if (!MemoServService) return; const Anope::string &nick = params[0]; const Anope::string &text = params[1]; - MemoServService::MemoResult result = memoserv->Send(source.GetNick(), nick, text); + MemoServService::MemoResult result = MemoServService->Send(source.GetNick(), nick, text); if (result == MemoServService::MEMO_SUCCESS) source.Reply(_("Memo sent to \002%s\002."), nick.c_str()); else if (result == MemoServService::MEMO_INVALID_TARGET) @@ -66,7 +66,7 @@ class MSSend : public Module { this->SetAuthor("Anope"); - if (!memoserv) + if (!MemoServService) throw ModuleException("No MemoServ!"); } }; diff --git a/modules/commands/ms_sendall.cpp b/modules/commands/ms_sendall.cpp index 2fba2ecb3..5ade6722b 100644 --- a/modules/commands/ms_sendall.cpp +++ b/modules/commands/ms_sendall.cpp @@ -25,12 +25,12 @@ class CommandMSSendAll : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!memoserv) + if (!MemoServService) return; const Anope::string &text = params[0]; - if (readonly) + if (Anope::ReadOnly) { source.Reply(MEMO_SEND_DISABLED); return; @@ -41,7 +41,7 @@ class CommandMSSendAll : public Command const NickCore *nc = it->second; if (nc != source.nc) - memoserv->Send(source.GetNick(), nc->display, text); + MemoServService->Send(source.GetNick(), nc->display, text); } source.Reply(_("A massmemo has been sent to all registered users.")); @@ -67,7 +67,7 @@ class MSSendAll : public Module { this->SetAuthor("Anope"); - if (!memoserv) + if (!MemoServService) throw ModuleException("No MemoServ!"); } }; diff --git a/modules/commands/ms_set.cpp b/modules/commands/ms_set.cpp index 02ce8d32c..497dffd4c 100644 --- a/modules/commands/ms_set.cpp +++ b/modules/commands/ms_set.cpp @@ -86,7 +86,7 @@ class CommandMSSet : public Command p2 = p3; p3 = params.size() > 4 ? params[4] : ""; - ci = cs_findchan(chan); + ci = ChannelInfo::Find(chan); if (!ci) { source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str()); @@ -104,7 +104,7 @@ class CommandMSSet : public Command if (!p2.empty() && !p2.equals_ci("HARD") && chan.empty()) { const NickAlias *na; - if (!(na = findnick(p1))) + if (!(na = NickAlias::Find(p1))) { source.Reply(NICK_X_NOT_REGISTERED, p1.c_str()); return; @@ -211,7 +211,7 @@ class CommandMSSet : public Command const Anope::string &cmd = params[0]; MemoInfo *mi = const_cast<MemoInfo *>(&source.nc->memos); - if (readonly) + if (Anope::ReadOnly) source.Reply(_("Sorry, memo option setting is temporarily disabled.")); else if (cmd.equals_ci("NOTIFY")) return this->DoNotify(source, params, mi); diff --git a/modules/commands/ms_staff.cpp b/modules/commands/ms_staff.cpp index 9896d5971..a1fbdf65d 100644 --- a/modules/commands/ms_staff.cpp +++ b/modules/commands/ms_staff.cpp @@ -25,12 +25,12 @@ class CommandMSStaff : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!memoserv) + if (!MemoServService) return; const Anope::string &text = params[0]; - if (readonly) + if (Anope::ReadOnly) { source.Reply(MEMO_SEND_DISABLED); return; @@ -41,7 +41,7 @@ class CommandMSStaff : public Command const NickCore *nc = it->second; if (source.nc != nc && nc->IsServicesOper()) - memoserv->Send(source.GetNick(), nc->display, text, true); + MemoServService->Send(source.GetNick(), nc->display, text, true); } return; @@ -67,7 +67,7 @@ class MSStaff : public Module { this->SetAuthor("Anope"); - if (!memoserv) + if (!MemoServService) throw ModuleException("No MemoServ!"); } }; diff --git a/modules/commands/ns_access.cpp b/modules/commands/ns_access.cpp index 915b70cb3..f77836909 100644 --- a/modules/commands/ns_access.cpp +++ b/modules/commands/ns_access.cpp @@ -108,7 +108,7 @@ class CommandNSAccess : public Command NickCore *nc; if (!nick.empty()) { - const NickAlias *na = findnick(nick); + const NickAlias *na = NickAlias::Find(nick); if (na == NULL) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); diff --git a/modules/commands/ns_ajoin.cpp b/modules/commands/ns_ajoin.cpp index 46f012c46..54e37ad36 100644 --- a/modules/commands/ns_ajoin.cpp +++ b/modules/commands/ns_ajoin.cpp @@ -15,20 +15,20 @@ struct AJoinEntry; -struct AJoinList : serialize_checker<std::vector<AJoinEntry *> >, ExtensibleItem +struct AJoinList : Serialize::Checker<std::vector<AJoinEntry *> >, ExtensibleItem { - AJoinList() : serialize_checker<std::vector<AJoinEntry *> >("AJoinEntry") { } + AJoinList() : Serialize::Checker<std::vector<AJoinEntry *> >("AJoinEntry") { } }; struct AJoinEntry : Serializable { - serialize_obj<NickCore> owner; + Serialize::Reference<NickCore> owner; Anope::string channel; Anope::string key; AJoinEntry() : Serializable("AJoinEntry") { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data sd; @@ -42,9 +42,9 @@ struct AJoinEntry : Serializable return sd; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &sd) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &sd) { - NickCore *nc = findcore(sd["owner"].astr()); + NickCore *nc = NickCore::Find(sd["owner"].astr()); if (nc == NULL) return NULL; @@ -91,7 +91,7 @@ class CommandNSAJoin : public Command else { ListFormatter list; - list.addColumn("Number").addColumn("Channel").addColumn("Key"); + list.AddColumn("Number").AddColumn("Channel").AddColumn("Key"); for (unsigned i = 0; i < (*channels)->size(); ++i) { AJoinEntry *aj = (*channels)->at(i); @@ -99,7 +99,7 @@ class CommandNSAJoin : public Command entry["Number"] = stringify(i + 1); entry["Channel"] = aj->channel; entry["Key"] = aj->key; - list.addEntry(entry); + list.AddEntry(entry); } source.Reply(_("%s's auto join list:"), nc->display.c_str()); @@ -130,7 +130,7 @@ class CommandNSAJoin : public Command source.Reply(_("Your auto join list is full.")); else if (i != (*channels)->size()) source.Reply(_("%s is already on %s's auto join list."), chan.c_str(), nc->display.c_str()); - else if (ircdproto->IsChannelValid(chan) == false) + else if (IRCD->IsChannelValid(chan) == false) source.Reply(CHAN_X_INVALID, chan.c_str()); else { @@ -161,7 +161,7 @@ class CommandNSAJoin : public Command source.Reply(_("%s was not found on %s's auto join list."), chan.c_str(), nc->display.c_str()); else { - (*channels)->at(i)->destroy(); + (*channels)->at(i)->Destroy(); (*channels)->erase((*channels)->begin() + i); source.Reply(_("%s was removed from %s's auto join list."), chan.c_str(), nc->display.c_str()); } @@ -179,9 +179,9 @@ class CommandNSAJoin : public Command NickCore *nc = source.GetAccount(); Anope::string param, param2; - if (params.size() > 1 && source.IsServicesOper() && ircdproto->IsNickValid(params[1])) + if (params.size() > 1 && source.IsServicesOper() && IRCD->IsNickValid(params[1])) { - NickAlias *na = findnick(params[1]); + NickAlias *na = NickAlias::Find(params[1]); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, params[1].c_str()); @@ -224,12 +224,12 @@ class CommandNSAJoin : public Command class NSAJoin : public Module { - SerializeType ajoinentry_type; + Serialize::Type ajoinentry_type; CommandNSAJoin commandnsajoin; public: NSAJoin(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - ajoinentry_type("AJoinEntry", AJoinEntry::unserialize), commandnsajoin(this) + ajoinentry_type("AJoinEntry", AJoinEntry::Unserialize), commandnsajoin(this) { this->SetAuthor("Anope"); @@ -239,6 +239,9 @@ class NSAJoin : public Module void OnNickIdentify(User *u) anope_override { + if (!NickServ) + return; + AJoinList *channels = u->Account()->GetExt<AJoinList *>("ns_ajoin_channels"); if (channels == NULL) { @@ -246,20 +249,16 @@ class NSAJoin : public Module u->Account()->Extend("ns_ajoin_channels", channels); } - const BotInfo *bi = findbot(Config->NickServ); - if (bi == NULL) - return; - for (unsigned i = 0; i < (*channels)->size(); ++i) { AJoinEntry *entry = (*channels)->at(i); - Channel *c = findchan(entry->channel); + Channel *c = Channel::Find(entry->channel); ChannelInfo *ci; if (c) ci = c->ci; else - ci = cs_findchan(entry->channel); + ci = ChannelInfo::Find(entry->channel); bool need_invite = false; Anope::string key = entry->key; @@ -279,9 +278,9 @@ class NSAJoin : public Module continue; else if (c->HasMode(CMODE_SSL) && !u->HasMode(UMODE_SSL)) continue; - else if (matches_list(c, u, CMODE_BAN) == true && matches_list(c, u, CMODE_EXCEPT) == false) + else if (c->MatchesList(u, CMODE_BAN) == true && c->MatchesList(u, CMODE_EXCEPT) == false) need_invite = true; - else if (c->HasMode(CMODE_INVITE) && matches_list(c, u, CMODE_INVITEOVERRIDE) == false) + else if (c->HasMode(CMODE_INVITE) && c->MatchesList(u, CMODE_INVITEOVERRIDE) == false) need_invite = true; if (c->HasMode(CMODE_KEY)) @@ -315,10 +314,10 @@ class NSAJoin : public Module { if (!ci->AccessFor(u).HasPriv("INVITE")) continue; - ircdproto->SendInvite(bi, c, u); + IRCD->SendInvite(NickServ, c, u); } - ircdproto->SendSVSJoin(bi, u->nick, entry->channel, key); + IRCD->SendSVSJoin(NickServ, u->nick, entry->channel, key); } } }; diff --git a/modules/commands/ns_alist.cpp b/modules/commands/ns_alist.cpp index ef018ea8b..8da1b8346 100644 --- a/modules/commands/ns_alist.cpp +++ b/modules/commands/ns_alist.cpp @@ -30,7 +30,7 @@ class CommandNSAList : public Command if (params.size() && source.IsServicesOper()) { nick = params[0]; - const NickAlias *na = findnick(nick); + const NickAlias *na = NickAlias::Find(nick); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -42,7 +42,7 @@ class CommandNSAList : public Command ListFormatter list; int chan_count = 0; - list.addColumn("Number").addColumn("Channel").addColumn("Access"); + list.AddColumn("Number").AddColumn("Channel").AddColumn("Access"); source.Reply(_("Channels that \002%s\002 has access on:"), nc->display.c_str()); @@ -57,7 +57,7 @@ class CommandNSAList : public Command entry["Number"] = stringify(chan_count); entry["Channel"] = (ci->HasFlag(CI_NO_EXPIRE) ? "!" : "") + ci->name; entry["Access"] = "Founder"; - list.addEntry(entry); + list.AddEntry(entry); continue; } @@ -70,9 +70,9 @@ class CommandNSAList : public Command entry["Number"] = stringify(chan_count); entry["Channel"] = (ci->HasFlag(CI_NO_EXPIRE) ? "!" : "") + ci->name; for (unsigned i = 0; i < access.size(); ++i) - entry["Access"] = entry["Access"] + ", " + access[i]->Serialize(); + entry["Access"] = entry["Access"] + ", " + access[i]->AccessSerialize(); entry["Access"] = entry["Access"].substr(2); - list.addEntry(entry); + list.AddEntry(entry); } std::vector<Anope::string> replies; diff --git a/modules/commands/ns_cert.cpp b/modules/commands/ns_cert.cpp index a06dd1a3a..6c2100adf 100644 --- a/modules/commands/ns_cert.cpp +++ b/modules/commands/ns_cert.cpp @@ -31,14 +31,14 @@ class CommandNSCert : public Command } ListFormatter list; - list.addColumn("Certificate"); + list.AddColumn("Certificate"); for (unsigned i = 0, end = nc->cert.size(); i < end; ++i) { Anope::string fingerprint = nc->GetCert(i); ListFormatter::ListEntry entry; entry["Certificate"] = fingerprint; - list.addEntry(entry); + list.AddEntry(entry); } source.Reply(_("Certificate list for \002%s\002:"), nc->display.c_str()); @@ -121,13 +121,13 @@ class CommandNSCert : public Command } ListFormatter list; - list.addColumn("Certificate"); + list.AddColumn("Certificate"); for (unsigned i = 0, end = nc->cert.size(); i < end; ++i) { ListFormatter::ListEntry entry; entry["Certificate"] = nc->GetCert(i); - list.addEntry(entry); + list.AddEntry(entry); } source.Reply(_("Certificate list:")); @@ -152,7 +152,7 @@ class CommandNSCert : public Command const Anope::string &mask = params.size() > 1 ? params[1] : ""; const NickAlias *na; - if (cmd.equals_ci("LIST") && source.IsServicesOper() && !mask.empty() && (na = findnick(mask))) + if (cmd.equals_ci("LIST") && source.IsServicesOper() && !mask.empty() && (na = NickAlias::Find(mask))) return this->DoServAdminList(source, na->nc); NickCore *nc = source.nc; @@ -202,9 +202,8 @@ class NSCert : public Module void DoAutoIdentify(User *u) { - const BotInfo *bi = findbot(Config->NickServ); - NickAlias *na = findnick(u->nick); - if (!bi || !na) + NickAlias *na = NickAlias::Find(u->nick); + if (!NickServ || !na) return; if (u->IsIdentified() && u->Account() == na->nc) return; @@ -214,7 +213,7 @@ class NSCert : public Module return; u->Identify(na); - u->SendMessage(bi, _("SSL Fingerprint accepted. You are now identified.")); + u->SendMessage(NickServ, _("SSL Fingerprint accepted. You are now identified.")); Log(u) << "automatically identified for account " << na->nc->display << " using a valid SSL fingerprint"; return; } @@ -225,7 +224,7 @@ class NSCert : public Module { this->SetAuthor("Anope"); - if (!ircdproto || !ircdproto->CanCertFP) + if (!IRCD || !IRCD->CanCertFP) throw ModuleException("Your IRCd does not support ssl client certificates"); Implementation i[] = { I_OnFingerprint }; diff --git a/modules/commands/ns_drop.cpp b/modules/commands/ns_drop.cpp index d5ac7cef8..efd95cf1c 100644 --- a/modules/commands/ns_drop.cpp +++ b/modules/commands/ns_drop.cpp @@ -25,13 +25,13 @@ class CommandNSDrop : public Command { Anope::string nick = !params.empty() ? params[0] : ""; - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, nickname de-registration is temporarily disabled.")); return; } - NickAlias *na = findnick(!nick.empty() ? nick : source.GetNick()); + NickAlias *na = NickAlias::Find(!nick.empty() ? nick : source.GetNick()); if (!na) { source.Reply(NICK_NOT_REGISTERED); @@ -49,13 +49,13 @@ class CommandNSDrop : public Command source.Reply(_("You may not drop other services operators nicknames.")); else { - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); FOREACH_MOD(I_OnNickDrop, OnNickDrop(source, na)); Log(!is_mine ? LOG_OVERRIDE : LOG_COMMAND, source, this) << "to drop nickname " << na->nick << " (group: " << na->nc->display << ") (email: " << (!na->nc->email.empty() ? na->nc->email : "none") << ")"; - na->destroy(); + na->Destroy(); if (!is_mine) { diff --git a/modules/commands/ns_getpass.cpp b/modules/commands/ns_getpass.cpp index 2e5efdf4d..998316f5b 100644 --- a/modules/commands/ns_getpass.cpp +++ b/modules/commands/ns_getpass.cpp @@ -28,13 +28,13 @@ class CommandNSGetPass : public Command Anope::string tmp_pass; const NickAlias *na; - if (!(na = findnick(nick))) + if (!(na = NickAlias::Find(nick))) source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); else if (Config->NSSecureAdmins && na->nc->IsServicesOper()) source.Reply(_("You may not get the password of other services operators.")); else { - if (enc_decrypt(na->nc->pass, tmp_pass) == 1) + if (Anope::Decrypt(na->nc->pass, tmp_pass) == 1) { Log(LOG_ADMIN, source, this) << "for " << nick; source.Reply(_("Password for %s is \002%s\002."), nick.c_str(), tmp_pass.c_str()); @@ -68,7 +68,7 @@ class NSGetPass : public Module this->SetAuthor("Anope"); Anope::string tmp_pass = "plain:tmp"; - if (enc_decrypt(tmp_pass, tmp_pass) == -1) + if (Anope::Decrypt(tmp_pass, tmp_pass) == -1) throw ModuleException("Incompatible with the encryption module being used"); } diff --git a/modules/commands/ns_ghost.cpp b/modules/commands/ns_ghost.cpp index e7289f728..de85a941f 100644 --- a/modules/commands/ns_ghost.cpp +++ b/modules/commands/ns_ghost.cpp @@ -19,7 +19,7 @@ class NSGhostRequest : public IdentifyRequest { CommandSource source; Command *cmd; - dynamic_reference<User> u; + Reference<User> u; public: NSGhostRequest(Module *o, CommandSource &src, Command *c, User *user, const Anope::string &pass) : IdentifyRequest(o, user->nick, pass), source(src), cmd(c), u(user) { } @@ -38,7 +38,7 @@ class NSGhostRequest : public IdentifyRequest { NSGhostExtensibleInfo *ei = new NSGhostExtensibleInfo; for (UChannelList::iterator it = u->chans.begin(), it_end = u->chans.end(); it != it_end; ++it) - (*ei)[(*it)->chan->name] = *(*it)->Status; + (*ei)[(*it)->chan->name] = *(*it)->status; source.GetUser()->Extend("ns_ghost_info", ei); } @@ -50,14 +50,14 @@ class NSGhostRequest : public IdentifyRequest source.Reply(_("Ghost with your nick has been killed.")); if (Config->NSRestoreOnGhost) - ircdproto->SendForceNickChange(source.GetUser(), GetAccount(), Anope::CurTime); + IRCD->SendForceNickChange(source.GetUser(), GetAccount(), Anope::CurTime); } void OnFail() anope_override { if (!u) ; - else if (!findnick(GetAccount())) + else if (!NickAlias::Find(GetAccount())) source.Reply(NICK_X_NOT_REGISTERED, GetAccount().c_str()); else { @@ -66,7 +66,7 @@ class NSGhostRequest : public IdentifyRequest { Log(LOG_COMMAND, source, cmd) << "with an invalid password for " << GetAccount(); if (source.GetUser()) - bad_password(source.GetUser()); + source.GetUser()->BadPassword(); } } } @@ -87,8 +87,8 @@ class CommandNSGhost : public Command const Anope::string &nick = params[0]; const Anope::string &pass = params.size() > 1 ? params[1] : ""; - User *user = finduser(nick); - const NickAlias *na = findnick(nick); + User *user = User::Find(nick, true); + const NickAlias *na = NickAlias::Find(nick); if (!user) source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); @@ -107,7 +107,7 @@ class CommandNSGhost : public Command bool ok = false; if (source.GetAccount() == na->nc) ok = true; - else if (!na->nc->HasFlag(NI_SECURE) && source.GetUser() && is_on_access(source.GetUser(), na->nc)) + else if (!na->nc->HasFlag(NI_SECURE) && source.GetUser() && na->nc->IsOnAccess(source.GetUser())) ok = true; else if (source.GetUser() && !source.GetUser()->fingerprint.empty() && na->nc->FindCert(source.GetUser()->fingerprint)) ok = true; @@ -183,7 +183,7 @@ class NSGhost : public Module if (ei != NULL) for (std::map<Anope::string, ChannelStatus>::iterator it = ei->begin(), it_end = ei->end(); it != it_end; ++it) - ircdproto->SendSVSJoin(findbot(Config->NickServ), u->GetUID(), it->first, ""); + IRCD->SendSVSJoin(NickServ, u->GetUID(), it->first, ""); } } diff --git a/modules/commands/ns_group.cpp b/modules/commands/ns_group.cpp index 58251d76d..f4a464d28 100644 --- a/modules/commands/ns_group.cpp +++ b/modules/commands/ns_group.cpp @@ -18,7 +18,7 @@ class NSGroupRequest : public IdentifyRequest CommandSource source; Command *cmd; Anope::string nick; - dynamic_reference<NickAlias> target; + Reference<NickAlias> target; public: NSGroupRequest(Module *o, CommandSource &src, Command *c, const Anope::string &n, NickAlias *targ, const Anope::string &pass) : IdentifyRequest(o, targ->nc->display, pass), source(src), cmd(c), nick(n), target(targ) { } @@ -29,12 +29,12 @@ class NSGroupRequest : public IdentifyRequest return; User *u = source.GetUser(); - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); /* If the nick is already registered, drop it. */ if (na) { FOREACH_MOD(I_OnChangeCoreDisplay, OnChangeCoreDisplay(na->nc, u->nick)); - na->destroy(); + na->Destroy(); } na = new NickAlias(nick, target->nc); @@ -45,9 +45,9 @@ class NSGroupRequest : public IdentifyRequest na->time_registered = na->last_seen = Anope::CurTime; u->Login(target->nc); - ircdproto->SendLogin(u); + IRCD->SendLogin(u); if (!Config->NoNicknameOwnership && na->nc == u->Account() && na->nc->HasFlag(NI_UNCONFIRMED) == false) - u->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + u->SetMode(NickServ, UMODE_REGISTERED); FOREACH_MOD(I_OnNickGroup, OnNickGroup(u, target)); Log(LOG_COMMAND, source, cmd) << "makes " << nick << " join group of " << target->nick << " (" << target->nc->display << ") (email: " << (!target->nc->email.empty() ? target->nc->email : "none") << ")"; @@ -64,7 +64,7 @@ class NSGroupRequest : public IdentifyRequest Log(LOG_COMMAND, source, cmd) << "failed group for " << target->nick; source.Reply(PASSWORD_INCORRECT); - bad_password(source.GetUser()); + source.GetUser()->BadPassword(); } }; @@ -88,13 +88,13 @@ class CommandNSGroup : public Command const Anope::string &nick = params[0]; const Anope::string &pass = params.size() > 1 ? params[1] : ""; - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, nickname grouping is temporarily disabled.")); return; } - if (!ircdproto->IsNickValid(u->nick)) + if (!IRCD->IsNickValid(u->nick)) { source.Reply(NICK_CANNOT_BE_REGISTERED, u->nick.c_str()); return; @@ -112,8 +112,8 @@ class CommandNSGroup : public Command } } - NickAlias *target, *na = findnick(u->nick); - if (!(target = findnick(nick))) + NickAlias *target, *na = NickAlias::Find(u->nick); + if (!(target = NickAlias::Find(nick))) source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); else if (Anope::CurTime < u->lastnickreg + Config->NSRegDelay) source.Reply(_("Please wait %d seconds before using the GROUP command again."), (Config->NSRegDelay + u->lastnickreg) - Anope::CurTime); @@ -212,7 +212,7 @@ class CommandNSUngroup : public Command return; Anope::string nick = !params.empty() ? params[0] : ""; - NickAlias *na = findnick(!nick.empty() ? nick : u->nick); + NickAlias *na = NickAlias::Find(!nick.empty() ? nick : u->nick); if (u->Account()->aliases.size() == 1) source.Reply(_("Your nick is not grouped to anything, you can't ungroup it.")); @@ -224,12 +224,12 @@ class CommandNSUngroup : public Command { NickCore *oldcore = na->nc; - std::list<serialize_obj<NickAlias> >::iterator it = std::find(oldcore->aliases.begin(), oldcore->aliases.end(), na); + std::list<Serialize::Reference<NickAlias> >::iterator it = std::find(oldcore->aliases.begin(), oldcore->aliases.end(), na); if (it != oldcore->aliases.end()) oldcore->aliases.erase(it); if (na->nick.equals_ci(oldcore->display)) - change_core_display(oldcore); + oldcore->SetDisplay(oldcore->aliases.front()); NickCore *nc = new NickCore(na->nick); na->nc = nc; @@ -244,10 +244,10 @@ class CommandNSUngroup : public Command source.Reply(_("Nick %s has been ungrouped from %s."), na->nick.c_str(), oldcore->display.c_str()); - User *user = finduser(na->nick); + User *user = User::Find(na->nick); if (user) /* The user on the nick who was ungrouped may be identified to the old group, set -r */ - user->RemoveMode(findbot(Config->NickServ), UMODE_REGISTERED); + user->RemoveMode(NickServ, UMODE_REGISTERED); } return; @@ -281,7 +281,7 @@ class CommandNSGList : public Command if (!nick.empty()) { - const NickAlias *na = findnick(nick); + const NickAlias *na = NickAlias::Find(nick); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -299,8 +299,8 @@ class CommandNSGList : public Command nc = source.GetAccount(); ListFormatter list; - list.addColumn("Nick").addColumn("Expires"); - for (std::list<serialize_obj<NickAlias> >::const_iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end;) + list.AddColumn("Nick").AddColumn("Expires"); + for (std::list<Serialize::Reference<NickAlias> >::const_iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end;) { const NickAlias *na2 = *it++; if (!na2) @@ -308,8 +308,8 @@ class CommandNSGList : public Command ListFormatter::ListEntry entry; entry["Nick"] = na2->nick; - entry["Expires"] = (na2->HasFlag(NS_NO_EXPIRE) || !Config->NSExpire) ? "Does not expire" : ("expires in " + do_strftime(na2->last_seen + Config->NSExpire)); - list.addEntry(entry); + entry["Expires"] = (na2->HasFlag(NS_NO_EXPIRE) || !Config->NSExpire) ? "Does not expire" : ("expires in " + Anope::strftime(na2->last_seen + Config->NSExpire)); + list.AddEntry(entry); } source.Reply(!nick.empty() ? _("List of nicknames in the group of \002%s\002:") : _("List of nicknames in your group:"), nc->display.c_str()); diff --git a/modules/commands/ns_identify.cpp b/modules/commands/ns_identify.cpp index dde24d72d..4796e7bb6 100644 --- a/modules/commands/ns_identify.cpp +++ b/modules/commands/ns_identify.cpp @@ -27,7 +27,7 @@ class NSIdentifyRequest : public IdentifyRequest return; User *u = source.GetUser(); - NickAlias *na = findnick(GetAccount()); + NickAlias *na = NickAlias::Find(GetAccount()); if (!na) source.Reply(NICK_X_NOT_REGISTERED, GetAccount().c_str()); @@ -49,7 +49,7 @@ class NSIdentifyRequest : public IdentifyRequest { Log(LOG_COMMAND, source, cmd) << "and failed to identify"; source.Reply(PASSWORD_INCORRECT); - bad_password(source.GetUser()); + source.GetUser()->BadPassword(); } } }; @@ -74,7 +74,7 @@ class CommandNSIdentify : public Command const Anope::string &nick = params.size() == 2 ? params[0] : u->nick; Anope::string pass = params[params.size() - 1]; - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (na && na->nc->HasFlag(NI_SUSPENDED)) source.Reply(NICK_X_SUSPENDED, na->nick.c_str()); else if (u->Account() && na && u->Account() == na->nc) diff --git a/modules/commands/ns_info.cpp b/modules/commands/ns_info.cpp index 5daf2357e..976589718 100644 --- a/modules/commands/ns_info.cpp +++ b/modules/commands/ns_info.cpp @@ -16,14 +16,14 @@ class CommandNSInfo : public Command { private: - template<typename T, unsigned END> void CheckOptStr(NickCore *core, Anope::string &buf, T opt, const char *str, const Flags<T, END> *nc, bool reverse_logic = false) + template<typename T> void CheckOptStr(NickCore *core, Anope::string &buf, T opt, const char *str, const Flags<T> *nc, bool reverse_logic = false) { if (reverse_logic ? !nc->HasFlag(opt) : nc->HasFlag(opt)) { if (!buf.empty()) buf += ", "; - buf += translate(core, str); + buf += Language::Translate(core, str); } } public: @@ -38,12 +38,12 @@ class CommandNSInfo : public Command { const Anope::string &nick = params.size() ? params[0] : (source.nc ? source.nc->display : source.GetNick()); - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); bool has_auspex = source.HasPriv("nickserv/auspex"); if (!na) { - if (nickIsServices(nick, true)) + if (BotInfo::Find(nick, true)) source.Reply(_("Nick \002%s\002 is part of this Network's Services."), nick.c_str()); else source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -53,7 +53,7 @@ class CommandNSInfo : public Command bool nick_online = false, show_hidden = false; /* Is the real owner of the nick we're looking up online? -TheShadow */ - User *u2 = finduser(na->nick); + User *u2 = User::Find(na->nick); if (u2 && u2->Account() == na->nc) nick_online = true; @@ -87,10 +87,10 @@ class CommandNSInfo : public Command info[_("Last seen address")] = na->last_realhost; } - info[_("Time registered")] = do_strftime(na->time_registered); + info[_("Time registered")] = Anope::strftime(na->time_registered); if (!nick_online) - info[_("Last seen")] = do_strftime(na->last_seen); + info[_("Last seen")] = Anope::strftime(na->last_seen); if (!na->last_quit.empty() && (show_hidden || !na->nc->HasFlag(NI_HIDE_QUIT))) info[_("Last quit message")] = na->last_quit; @@ -102,7 +102,7 @@ class CommandNSInfo : public Command { if (na->HasVhost()) { - if (ircdproto->CanSetVIdent && !na->GetVhostIdent().empty()) + if (IRCD->CanSetVIdent && !na->GetVhostIdent().empty()) info[_("VHost")] = na->GetVhostIdent() + "@" + na->GetVhostHost(); else info[_("VHost")] = na->GetVhostHost(); @@ -113,14 +113,14 @@ class CommandNSInfo : public Command Anope::string optbuf; - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_KILLPROTECT, _("Protection"), na->nc); - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_SECURE, _("Security"), na->nc); - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_PRIVATE, _("Private"), na->nc); - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_MSG, _("Message mode"), na->nc); - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_AUTOOP, _("Auto-op"), na->nc); - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_SUSPENDED, _("Suspended"), na->nc); - CheckOptStr<NickCoreFlag, NI_END>(source.nc, optbuf, NI_STATS, _("Chanstats"), na->nc); - CheckOptStr<NickNameFlag, NS_END>(source.nc, optbuf, NS_NO_EXPIRE, _("No expire"), na); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_KILLPROTECT, _("Protection"), na->nc); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_SECURE, _("Security"), na->nc); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_PRIVATE, _("Private"), na->nc); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_MSG, _("Message mode"), na->nc); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_AUTOOP, _("Auto-op"), na->nc); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_SUSPENDED, _("Suspended"), na->nc); + CheckOptStr<NickCoreFlag>(source.nc, optbuf, NI_STATS, _("Chanstats"), na->nc); + CheckOptStr<NickNameFlag>(source.nc, optbuf, NS_NO_EXPIRE, _("No expire"), na); info[_("Options")] = optbuf.empty() ? _("None") : optbuf; @@ -129,10 +129,10 @@ class CommandNSInfo : public Command if (na->HasFlag(NS_NO_EXPIRE) || !Config->NSExpire) ; else - info[_("Expires")] = do_strftime(na->last_seen + Config->NSExpire); + info[_("Expires")] = Anope::strftime(na->last_seen + Config->NSExpire); } else - info[_("Expires")] = do_strftime(na->time_registered + Config->NSUnconfirmedExpire); + info[_("Expires")] = Anope::strftime(na->time_registered + Config->NSUnconfirmedExpire); } FOREACH_MOD(I_OnNickInfo, OnNickInfo(source, na, info, show_hidden)); diff --git a/modules/commands/ns_list.cpp b/modules/commands/ns_list.cpp index 89adfc6ea..9c3c164dd 100644 --- a/modules/commands/ns_list.cpp +++ b/modules/commands/ns_list.cpp @@ -36,8 +36,9 @@ class CommandNSList : public Command if (pattern[0] == '#') { - Anope::string n1 = myStrGetToken(pattern.substr(1), '-', 0), /* Read FROM out */ - n2 = myStrGetToken(pattern, '-', 1); + Anope::string n1, n2; + sepstream(pattern.substr(1), '-').GetToken(n1, 0); + sepstream(pattern, '-').GetToken(n2, 1); try { from = convertTo<int>(n1); @@ -72,7 +73,7 @@ class CommandNSList : public Command mync = source.nc; ListFormatter list; - list.addColumn("Nick").addColumn("Last usermask"); + list.AddColumn("Nick").AddColumn("Last usermask"); for (nickalias_map::const_iterator it = NickAliasList->begin(), it_end = NickAliasList->end(); it != it_end; ++it) { @@ -110,7 +111,7 @@ class CommandNSList : public Command entry["Last usermask"] = "[Unconfirmed]"; else entry["Last usermask"] = na->last_usermask; - list.addEntry(entry); + list.AddEntry(entry); } ++count; } diff --git a/modules/commands/ns_logout.cpp b/modules/commands/ns_logout.cpp index 4e0dc7131..5519e6ae8 100644 --- a/modules/commands/ns_logout.cpp +++ b/modules/commands/ns_logout.cpp @@ -32,16 +32,16 @@ class CommandNSLogout : public Command User *u2; if (!source.IsServicesOper() && !nick.empty()) this->OnSyntaxError(source, ""); - else if (!(u2 = (!nick.empty() ? finduser(nick) : source.GetUser()))) + else if (!(u2 = (!nick.empty() ? User::Find(nick, true) : source.GetUser()))) source.Reply(NICK_X_NOT_IN_USE, !nick.empty() ? nick.c_str() : source.GetNick().c_str()); else if (!nick.empty() && u2->IsServicesOper()) source.Reply(_("You can't logout %s because they are a Services Operator."), nick.c_str()); else { - if (!nick.empty() && !param.empty() && param.equals_ci("REVALIDATE") && nickserv) - nickserv->Validate(u2); + if (!nick.empty() && !param.empty() && param.equals_ci("REVALIDATE") && NickServService) + NickServService->Validate(u2); - u2->SuperAdmin = 0; /* Dont let people logout and remain a SuperAdmin */ + u2->super_admin = false; /* Dont let people logout and remain a SuperAdmin */ Log(LOG_COMMAND, source, this) << "to logout " << u2->nick; /* Remove founder status from this user in all channels */ @@ -50,8 +50,8 @@ class CommandNSLogout : public Command else source.Reply(_("Your nick has been logged out.")); - ircdproto->SendLogout(u2); - u2->RemoveMode(findbot(Config->NickServ), UMODE_REGISTERED); + IRCD->SendLogout(u2); + u2->RemoveMode(NickServ, UMODE_REGISTERED); u2->Logout(); /* Send out an event */ diff --git a/modules/commands/ns_recover.cpp b/modules/commands/ns_recover.cpp index 63d503553..54a10f3b4 100644 --- a/modules/commands/ns_recover.cpp +++ b/modules/commands/ns_recover.cpp @@ -18,8 +18,8 @@ class NSRecoverRequest : public IdentifyRequest { CommandSource source; Command *cmd; - dynamic_reference<NickAlias> na; - dynamic_reference<User> u; + Reference<NickAlias> na; + Reference<User> u; public: NSRecoverRequest(Module *m, CommandSource &src, Command *c, User *user, NickAlias *n, const Anope::string &pass) : IdentifyRequest(m, n->nc->display, pass), source(src), cmd(c), na(n), u(user) { } @@ -33,14 +33,14 @@ class NSRecoverRequest : public IdentifyRequest if (u->Account() == na->nc) { - ircdproto->SendLogout(u); - u->RemoveMode(findbot(Config->NickServ), UMODE_REGISTERED); + IRCD->SendLogout(u); + u->RemoveMode(NickServ, UMODE_REGISTERED); } u->Collide(na); /* Convert Config->NSReleaseTimeout seconds to string format */ - Anope::string relstr = duration(Config->NSReleaseTimeout); + Anope::string relstr = Anope::Duration(Config->NSReleaseTimeout); source.Reply(NICK_RECOVERED, Config->UseStrictPrivMsgString.c_str(), Config->NickServ.c_str(), na->nick.c_str(), relstr.c_str()); } @@ -53,7 +53,7 @@ class NSRecoverRequest : public IdentifyRequest if (!GetPassword().empty()) { Log(LOG_COMMAND, source, cmd) << "with invalid password for " << na->nick; - bad_password(u); + u->BadPassword(); } } }; @@ -76,11 +76,11 @@ class CommandNSRecover : public Command NickAlias *na; User *u2; - if (!(u2 = finduser(nick))) + if (!(u2 = User::Find(nick, true))) source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); else if (u2->server == Me) source.Reply(_("\2%s\2 has already been recovered."), u2->nick.c_str()); - else if (!(na = findnick(u2->nick))) + else if (!(na = NickAlias::Find(u2->nick))) source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); else if (na->nc->HasFlag(NI_SUSPENDED)) source.Reply(NICK_X_SUSPENDED, na->nick.c_str()); @@ -91,7 +91,7 @@ class CommandNSRecover : public Command bool ok = false; if (source.GetAccount() == na->nc) ok = true; - else if (!na->nc->HasFlag(NI_SECURE) && source.GetUser() && is_on_access(source.GetUser(), na->nc)) + else if (!na->nc->HasFlag(NI_SECURE) && source.GetUser() && na->nc->IsOnAccess(source.GetUser())) ok = true; else if (source.GetUser() && !source.GetUser()->fingerprint.empty() && na->nc->FindCert(source.GetUser()->fingerprint)) ok = true; @@ -117,7 +117,7 @@ class CommandNSRecover : public Command bool OnHelp(CommandSource &source, const Anope::string &subcommand) anope_override { /* Convert Config->NSReleaseTimeout seconds to string format */ - Anope::string relstr = duration(Config->NSReleaseTimeout); + Anope::string relstr = Anope::Duration(Config->NSReleaseTimeout); this->SendSyntax(source); source.Reply(" "); diff --git a/modules/commands/ns_register.cpp b/modules/commands/ns_register.cpp index 0413f8cc8..d16144a18 100644 --- a/modules/commands/ns_register.cpp +++ b/modules/commands/ns_register.cpp @@ -31,7 +31,7 @@ class CommandNSConfirm : public Command if (source.nc && !source.nc->HasFlag(NI_UNCONFIRMED) && source.HasPriv("nickserv/confirm")) { - NickAlias *na = findnick(passcode); + NickAlias *na = NickAlias::Find(passcode); if (na == NULL) source.Reply(NICK_X_NOT_REGISTERED, passcode.c_str()); else if (na->nc->HasFlag(NI_UNCONFIRMED) == false) @@ -56,10 +56,10 @@ class CommandNSConfirm : public Command if (source.GetUser()) { - ircdproto->SendLogin(source.GetUser()); - const NickAlias *na = findnick(source.GetNick()); + IRCD->SendLogin(source.GetUser()); + const NickAlias *na = NickAlias::Find(source.GetNick()); if (!Config->NoNicknameOwnership && na != NULL && na->nc == source.GetAccount() && na->nc->HasFlag(NI_UNCONFIRMED) == false) - source.GetUser()->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + source.GetUser()->SetMode(NickServ, UMODE_REGISTERED); } } else @@ -118,7 +118,7 @@ class CommandNSRegister : public Command Anope::string pass = params[0]; Anope::string email = params.size() > 1 ? params[1] : ""; - if (readonly) + if (Anope::ReadOnly) { source.Reply(_("Sorry, nickname registration is temporarily disabled.")); return; @@ -147,7 +147,7 @@ class CommandNSRegister : public Command return; } - if (!ircdproto->IsNickValid(u_nick)) + if (!IRCD->IsNickValid(u_nick)) { source.Reply(NICK_CANNOT_BE_REGISTERED, u_nick.c_str()); return; @@ -169,19 +169,19 @@ class CommandNSRegister : public Command this->OnSyntaxError(source, ""); else if (u && Anope::CurTime < u->lastnickreg + Config->NSRegDelay) source.Reply(_("Please wait %d seconds before using the REGISTER command again."), (u->lastnickreg + Config->NSRegDelay) - Anope::CurTime); - else if ((na = findnick(u_nick))) + else if ((na = NickAlias::Find(u_nick))) source.Reply(NICK_ALREADY_REGISTERED, u_nick.c_str()); else if (pass.equals_ci(u_nick) || (Config->StrictPasswords && pass.length() < 5)) source.Reply(MORE_OBSCURE_PASSWORD); else if (pass.length() > Config->PassLen) source.Reply(PASSWORD_TOO_LONG); - else if (!email.empty() && !MailValidate(email)) + else if (!email.empty() && !Mail::Validate(email)) source.Reply(MAIL_X_INVALID, email.c_str()); else { NickCore *nc = new NickCore(u_nick); na = new NickAlias(u_nick, nc); - enc_encrypt(pass, nc->pass); + Anope::Encrypt(pass, nc->pass); if (!email.empty()) nc->email = email; @@ -193,7 +193,7 @@ class CommandNSRegister : public Command u->Login(nc); if (Config->NSAddAccessOnReg) - nc->AddAccess(create_mask(u)); + nc->AddAccess(u->Mask()); } Log(LOG_COMMAND, source, this) << "to register " << na->nick << " (email: " << (!na->nc->email.empty() ? na->nc->email : "none") << ")"; @@ -206,7 +206,7 @@ class CommandNSRegister : public Command source.Reply(_("Nickname \002%s\002 registered."), u_nick.c_str()); Anope::string tmp_pass; - if (enc_decrypt(na->nc->pass, tmp_pass) == 1) + if (Anope::Decrypt(na->nc->pass, tmp_pass) == 1) source.Reply(_("Your password is \002%s\002 - remember this for later use."), tmp_pass.c_str()); if (Config->NSRegistration.equals_ci("admin")) @@ -220,16 +220,16 @@ class CommandNSRegister : public Command if (SendRegmail(u, na, source.service)) { source.Reply(_("A passcode has been sent to %s, please type %s%s confirm <passcode> to confirm your email address."), email.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->NickServ.c_str()); - source.Reply(_("If you do not confirm your email address within %s your account will expire."), duration(Config->NSUnconfirmedExpire).c_str()); + source.Reply(_("If you do not confirm your email address within %s your account will expire."), Anope::Duration(Config->NSUnconfirmedExpire).c_str()); } } else if (Config->NSRegistration.equals_ci("none")) { if (u) { - ircdproto->SendLogin(u); + IRCD->SendLogin(u); if (!Config->NoNicknameOwnership && na->nc == u->Account() && na->nc->HasFlag(NI_UNCONFIRMED) == false) - u->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + u->SetMode(NickServ, UMODE_REGISTERED); } } @@ -290,7 +290,7 @@ class CommandNSResend : public Command if (Config->NSRegistration.equals_ci("mail")) return; - const NickAlias *na = findnick(source.GetNick()); + const NickAlias *na = NickAlias::Find(source.GetNick()); if (na == NULL) source.Reply(NICK_NOT_REGISTERED); @@ -372,8 +372,8 @@ static bool SendRegmail(User *u, const NickAlias *na, const BotInfo *bi) else codebuf = *code; - Anope::string subject = translate(na->nc, Config->MailRegistrationSubject.c_str()); - Anope::string message = translate(na->nc, Config->MailRegistrationMessage.c_str()); + Anope::string subject = Language::Translate(na->nc, Config->MailRegistrationSubject.c_str()); + Anope::string message = Language::Translate(na->nc, Config->MailRegistrationMessage.c_str()); subject = subject.replace_all_cs("%n", na->nick); subject = subject.replace_all_cs("%N", Config->NetworkName); @@ -383,7 +383,7 @@ static bool SendRegmail(User *u, const NickAlias *na, const BotInfo *bi) message = message.replace_all_cs("%N", Config->NetworkName); message = message.replace_all_cs("%c", codebuf); - return Mail(u, nc, bi, subject, message); + return Mail::Send(u, nc, bi, subject, message); } MODULE_INIT(NSRegister) diff --git a/modules/commands/ns_release.cpp b/modules/commands/ns_release.cpp index cd669e707..a3004f462 100644 --- a/modules/commands/ns_release.cpp +++ b/modules/commands/ns_release.cpp @@ -17,7 +17,7 @@ class NSReleaseRequest : public IdentifyRequest { CommandSource source; Command *cmd; - dynamic_reference<NickAlias> na; + Reference<NickAlias> na; public: NSReleaseRequest(Module *m, CommandSource &src, Command *c, NickAlias *n, const Anope::string &pass) : IdentifyRequest(m, n->nc->display, pass), source(src), cmd(c), na(n) { } @@ -40,7 +40,7 @@ class NSReleaseRequest : public IdentifyRequest { Log(LOG_COMMAND, source, cmd) << "with invalid password for " << na->nick; if (!source.GetUser()) - bad_password(source.GetUser()); + source.GetUser()->BadPassword(); } } }; @@ -61,7 +61,7 @@ class CommandNSRelease : public Command Anope::string pass = params.size() > 1 ? params[1] : ""; NickAlias *na; - if (!(na = findnick(nick))) + if (!(na = NickAlias::Find(nick))) source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); else if (na->nc->HasFlag(NI_SUSPENDED)) source.Reply(NICK_X_SUSPENDED, na->nick.c_str()); @@ -74,7 +74,7 @@ class CommandNSRelease : public Command bool ok = override; if (source.GetAccount() == na->nc) ok = true; - else if (source.GetUser() && !na->nc->HasFlag(NI_SECURE) && is_on_access(source.GetUser(), na->nc)) + else if (source.GetUser() && !na->nc->HasFlag(NI_SECURE) && na->nc->IsOnAccess(source.GetUser())) ok = true; else if (source.GetUser() && !source.GetUser()->fingerprint.empty() && na->nc->FindCert(source.GetUser()->fingerprint)) ok = true; @@ -101,7 +101,7 @@ class CommandNSRelease : public Command bool OnHelp(CommandSource &source, const Anope::string &subcommand) anope_override { /* Convert Config->NSReleaseTimeout seconds to string format */ - Anope::string relstr = duration(Config->NSReleaseTimeout); + Anope::string relstr = Anope::Duration(Config->NSReleaseTimeout); this->SendSyntax(source); source.Reply(" "); diff --git a/modules/commands/ns_resetpass.cpp b/modules/commands/ns_resetpass.cpp index 8965b6a3e..39eead56e 100644 --- a/modules/commands/ns_resetpass.cpp +++ b/modules/commands/ns_resetpass.cpp @@ -31,7 +31,7 @@ class CommandNSResetPass : public Command if (Config->RestrictMail && source.HasCommand("nickserv/resetpass")) source.Reply(ACCESS_DENIED); - else if (!(na = findnick(params[0]))) + else if (!(na = NickAlias::Find(params[0]))) source.Reply(NICK_X_NOT_REGISTERED, params[0].c_str()); else { @@ -82,7 +82,7 @@ class NSResetPass : public Module { if (command->name == "nickserv/confirm" && params.size() > 1) { - NickAlias *na = findnick(params[0]); + NickAlias *na = NickAlias::Find(params[0]); ResetInfo *ri = na ? na->nc->GetExt<ResetInfo *>("ns_resetpass") : NULL; if (na && ri) @@ -135,8 +135,8 @@ static bool SendResetEmail(User *u, const NickAlias *na, const BotInfo *bi) for (idx = 0; idx < 20; ++idx) passcode += chars[1 + static_cast<int>((static_cast<float>(max - min)) * static_cast<uint16_t>(rand()) / 65536.0) + min]; - Anope::string subject = translate(na->nc, Config->MailResetSubject.c_str()); - Anope::string message = translate(na->nc, Config->MailResetMessage.c_str()); + Anope::string subject = Language::Translate(na->nc, Config->MailResetSubject.c_str()); + Anope::string message = Language::Translate(na->nc, Config->MailResetMessage.c_str()); subject = subject.replace_all_cs("%n", na->nick); subject = subject.replace_all_cs("%N", Config->NetworkName); @@ -152,7 +152,7 @@ static bool SendResetEmail(User *u, const NickAlias *na, const BotInfo *bi) NickCore *nc = na->nc; nc->Extend("ns_resetpass", ri); - return Mail(u, nc, bi, subject, message); + return Mail::Send(u, nc, bi, subject, message); } MODULE_INIT(NSResetPass) diff --git a/modules/commands/ns_saset.cpp b/modules/commands/ns_saset.cpp index 8d2ba08d9..ac3cb1d8f 100644 --- a/modules/commands/ns_saset.cpp +++ b/modules/commands/ns_saset.cpp @@ -40,7 +40,7 @@ class CommandNSSASet : public Command if (c_name.find_ci(this_name + " ") == 0) { - service_reference<Command> command("Command", info.name); + ServiceReference<Command> command("Command", info.name); if (command) { source.command = c_name; @@ -66,7 +66,7 @@ class CommandNSSASetPassword : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - const NickAlias *setter_na = findnick(params[0]); + const NickAlias *setter_na = NickAlias::Find(params[0]); if (setter_na == NULL) { source.Reply(NICK_X_NOT_REGISTERED, params[0].c_str()); @@ -92,9 +92,9 @@ class CommandNSSASetPassword : public Command return; } - enc_encrypt(params[1], nc->pass); + Anope::Encrypt(params[1], nc->pass); Anope::string tmp_pass; - if (enc_decrypt(nc->pass, tmp_pass) == 1) + if (Anope::Decrypt(nc->pass, tmp_pass) == 1) source.Reply(_("Password for \002%s\002 changed to \002%s\002."), nc->display.c_str(), tmp_pass.c_str()); else source.Reply(_("Password for \002%s\002 changed."), nc->display.c_str()); diff --git a/modules/commands/ns_saset_noexpire.cpp b/modules/commands/ns_saset_noexpire.cpp index 5ebfdce89..ea3e946ae 100644 --- a/modules/commands/ns_saset_noexpire.cpp +++ b/modules/commands/ns_saset_noexpire.cpp @@ -24,7 +24,7 @@ class CommandNSSASetNoexpire : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - NickAlias *na = findnick(params[0]); + NickAlias *na = NickAlias::Find(params[0]); if (na == NULL) { source.Reply(NICK_X_NOT_REGISTERED, params[0].c_str()); diff --git a/modules/commands/ns_sendpass.cpp b/modules/commands/ns_sendpass.cpp index 5d88fd5a4..e85690e24 100644 --- a/modules/commands/ns_sendpass.cpp +++ b/modules/commands/ns_sendpass.cpp @@ -32,12 +32,12 @@ class CommandNSSendPass : public Command if (Config->RestrictMail && !source.HasCommand("nickserv/sendpass")) source.Reply(ACCESS_DENIED); - else if (!(na = findnick(nick))) + else if (!(na = NickAlias::Find(nick))) source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); else { Anope::string tmp_pass; - if (enc_decrypt(na->nc->pass, tmp_pass) == 1) + if (Anope::Decrypt(na->nc->pass, tmp_pass) == 1) { if (SendPassMail(source.GetUser(), na, source.service, tmp_pass)) { @@ -79,7 +79,7 @@ class NSSendPass : public Module throw ModuleException("Not using mail."); Anope::string tmp_pass = "plain:tmp"; - if (enc_decrypt(tmp_pass, tmp_pass) == -1) + if (Anope::Decrypt(tmp_pass, tmp_pass) == -1) throw ModuleException("Incompatible with the encryption module being used"); } @@ -87,8 +87,8 @@ class NSSendPass : public Module static bool SendPassMail(User *u, const NickAlias *na, const BotInfo *bi, const Anope::string &pass) { - Anope::string subject = translate(na->nc, Config->MailSendpassSubject.c_str()); - Anope::string message = translate(na->nc, Config->MailSendpassMessage.c_str()); + Anope::string subject = Language::Translate(na->nc, Config->MailSendpassSubject.c_str()); + Anope::string message = Language::Translate(na->nc, Config->MailSendpassMessage.c_str()); subject = subject.replace_all_cs("%n", na->nick); subject = subject.replace_all_cs("%N", Config->NetworkName); @@ -98,7 +98,7 @@ static bool SendPassMail(User *u, const NickAlias *na, const BotInfo *bi, const message = message.replace_all_cs("%N", Config->NetworkName); message = message.replace_all_cs("%p", pass); - return Mail(u, na->nc, bi, subject, message); + return Mail::Send(u, na->nc, bi, subject, message); } MODULE_INIT(NSSendPass) diff --git a/modules/commands/ns_set.cpp b/modules/commands/ns_set.cpp index 0917d45bd..bc6a67b35 100644 --- a/modules/commands/ns_set.cpp +++ b/modules/commands/ns_set.cpp @@ -41,7 +41,7 @@ class CommandNSSet : public Command if (c_name.find_ci(this_name + " ") == 0) { - service_reference<Command> command("Command", info.name); + ServiceReference<Command> command("Command", info.name); if (command) { source.command = c_name; @@ -81,9 +81,9 @@ class CommandNSSetPassword : public Command return; } - enc_encrypt(param, source.nc->pass); + Anope::Encrypt(param, source.nc->pass); Anope::string tmp_pass; - if (enc_decrypt(source.nc->pass, tmp_pass) == 1) + if (Anope::Decrypt(source.nc->pass, tmp_pass) == 1) source.Reply(_("Password for \002%s\002 changed to \002%s\002."), source.nc->display.c_str(), tmp_pass.c_str()); else source.Reply(_("Password for \002%s\002 changed."), source.nc->display.c_str()); diff --git a/modules/commands/ns_set_autoop.cpp b/modules/commands/ns_set_autoop.cpp index 7e3864420..e6533875b 100644 --- a/modules/commands/ns_set_autoop.cpp +++ b/modules/commands/ns_set_autoop.cpp @@ -24,7 +24,7 @@ class CommandNSSetAutoOp : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (na == NULL) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_chanstats.cpp b/modules/commands/ns_set_chanstats.cpp index 5bf23907b..7b8f371ff 100644 --- a/modules/commands/ns_set_chanstats.cpp +++ b/modules/commands/ns_set_chanstats.cpp @@ -23,7 +23,7 @@ class CommandNSSetChanstats : public Command } void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - NickAlias *na = findnick(user); + NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_display.cpp b/modules/commands/ns_set_display.cpp index 1980ba116..c532f4cf1 100644 --- a/modules/commands/ns_set_display.cpp +++ b/modules/commands/ns_set_display.cpp @@ -24,7 +24,7 @@ class CommandNSSetDisplay : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *user_na = findnick(user), *na = findnick(param); + const NickAlias *user_na = NickAlias::Find(user), *na = NickAlias::Find(param); if (user_na == NULL) { @@ -42,7 +42,7 @@ class CommandNSSetDisplay : public Command if (MOD_RESULT == EVENT_STOP) return; - change_core_display(user_na->nc, na->nick); + user_na->nc->SetDisplay(na); source.Reply(NICK_SET_DISPLAY_CHANGED, user_na->nc->display.c_str()); } diff --git a/modules/commands/ns_set_email.cpp b/modules/commands/ns_set_email.cpp index 6966c2a79..82b4a0cc8 100644 --- a/modules/commands/ns_set_email.cpp +++ b/modules/commands/ns_set_email.cpp @@ -40,7 +40,7 @@ static bool SendConfirmMail(User *u, const BotInfo *bi) message = message.replace_all_cs("%N", Config->NetworkName); message = message.replace_all_cs("%c", code); - return Mail(u, u->Account(), bi, subject, message); + return Mail::Send(u, u->Account(), bi, subject, message); } class CommandNSSetEmail : public Command @@ -54,7 +54,7 @@ class CommandNSSetEmail : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); @@ -72,7 +72,7 @@ class CommandNSSetEmail : public Command source.Reply(_("You may not change the email of other services operators.")); return; } - else if (!param.empty() && !MailValidate(param)) + else if (!param.empty() && !Mail::Validate(param)) { source.Reply(MAIL_X_INVALID, param.c_str()); return; diff --git a/modules/commands/ns_set_greet.cpp b/modules/commands/ns_set_greet.cpp index 87ac7d1ee..b28edc2bb 100644 --- a/modules/commands/ns_set_greet.cpp +++ b/modules/commands/ns_set_greet.cpp @@ -24,7 +24,7 @@ class CommandNSSetGreet : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_hide.cpp b/modules/commands/ns_set_hide.cpp index 4770653f2..d7fe886ea 100644 --- a/modules/commands/ns_set_hide.cpp +++ b/modules/commands/ns_set_hide.cpp @@ -24,7 +24,7 @@ class CommandNSSetHide : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m, const Anope::string &arg) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_kill.cpp b/modules/commands/ns_set_kill.cpp index ca0f804d3..0f62a4ba0 100644 --- a/modules/commands/ns_set_kill.cpp +++ b/modules/commands/ns_set_kill.cpp @@ -24,7 +24,7 @@ class CommandNSSetKill : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_language.cpp b/modules/commands/ns_set_language.cpp index 43162d6fd..d2830d4b8 100644 --- a/modules/commands/ns_set_language.cpp +++ b/modules/commands/ns_set_language.cpp @@ -24,7 +24,7 @@ class CommandNSSetLanguage : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); @@ -37,11 +37,11 @@ class CommandNSSetLanguage : public Command if (MOD_RESULT == EVENT_STOP) return; - for (unsigned j = 0; j < languages.size(); ++j) + for (unsigned j = 0; j < Language::Languages.size(); ++j) { - if (param == "en" || languages[j] == param) + if (param == "en" || Language::Languages[j] == param) break; - else if (j + 1 == languages.size()) + else if (j + 1 == Language::Languages.size()) { this->OnSyntaxError(source, ""); return; @@ -69,12 +69,12 @@ class CommandNSSetLanguage : public Command "supported languages:")); source.Reply(" en (English)"); - for (unsigned j = 0; j < languages.size(); ++j) + for (unsigned j = 0; j < Language::Languages.size(); ++j) { - const Anope::string &langname = anope_gettext(languages[j].c_str(), _("English")); + const Anope::string &langname = Language::Translate(Language::Languages[j].c_str(), _("English")); if (langname == "English") continue; - source.Reply(" %s (%s)", languages[j].c_str(), langname.c_str()); + source.Reply(" %s (%s)", Language::Languages[j].c_str(), langname.c_str()); } return true; @@ -104,12 +104,12 @@ class CommandNSSASetLanguage : public CommandNSSetLanguage "\037language\037 should be chosen from the following list of\n" "supported languages:")); source.Reply(" en (English)"); - for (unsigned j = 0; j < languages.size(); ++j) + for (unsigned j = 0; j < Language::Languages.size(); ++j) { - const Anope::string &langname = anope_gettext(languages[j].c_str(), _("English")); + const Anope::string &langname = Language::Translate(Language::Languages[j].c_str(), _("English")); if (langname == "English") continue; - source.Reply(" %s (%s)", languages[j].c_str(), langname.c_str()); + source.Reply(" %s (%s)", Language::Languages[j].c_str(), langname.c_str()); } return true; } diff --git a/modules/commands/ns_set_message.cpp b/modules/commands/ns_set_message.cpp index fa0ad7ec3..f515b22c1 100644 --- a/modules/commands/ns_set_message.cpp +++ b/modules/commands/ns_set_message.cpp @@ -24,7 +24,7 @@ class CommandNSSetMessage : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_misc.cpp b/modules/commands/ns_set_misc.cpp index 9c805b3ea..1e088a425 100644 --- a/modules/commands/ns_set_misc.cpp +++ b/modules/commands/ns_set_misc.cpp @@ -15,7 +15,7 @@ struct NSMiscData : ExtensibleItem, Serializable { - serialize_obj<NickCore> nc; + Serialize::Reference<NickCore> nc; Anope::string name; Anope::string data; @@ -23,7 +23,7 @@ struct NSMiscData : ExtensibleItem, Serializable { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data sdata; @@ -34,9 +34,9 @@ struct NSMiscData : ExtensibleItem, Serializable return sdata; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { - NickCore *nc = findcore(data["nc"].astr()); + NickCore *nc = NickCore::Find(data["nc"].astr()); if (nc == NULL) return NULL; @@ -76,7 +76,7 @@ class CommandNSSetMisc : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); @@ -126,13 +126,13 @@ class CommandNSSASetMisc : public CommandNSSetMisc class NSSetMisc : public Module { - SerializeType nsmiscdata_type; + Serialize::Type nsmiscdata_type; CommandNSSetMisc commandnssetmisc; CommandNSSASetMisc commandnssasetmisc; public: NSSetMisc(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - nsmiscdata_type("NSMiscData", NSMiscData::unserialize), commandnssetmisc(this), commandnssasetmisc(this) + nsmiscdata_type("NSMiscData", NSMiscData::Unserialize), commandnssetmisc(this), commandnssasetmisc(this) { this->SetAuthor("Anope"); diff --git a/modules/commands/ns_set_private.cpp b/modules/commands/ns_set_private.cpp index 358035567..8f953fcc0 100644 --- a/modules/commands/ns_set_private.cpp +++ b/modules/commands/ns_set_private.cpp @@ -24,7 +24,7 @@ class CommandNSSetPrivate : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_set_secure.cpp b/modules/commands/ns_set_secure.cpp index 52eea8e5b..b7dd79969 100644 --- a/modules/commands/ns_set_secure.cpp +++ b/modules/commands/ns_set_secure.cpp @@ -24,7 +24,7 @@ class CommandNSSetSecure : public Command void Run(CommandSource &source, const Anope::string &user, const Anope::string ¶m) { - const NickAlias *na = findnick(user); + const NickAlias *na = NickAlias::Find(user); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, user.c_str()); diff --git a/modules/commands/ns_status.cpp b/modules/commands/ns_status.cpp index 7a5a68a5a..495ae96a1 100644 --- a/modules/commands/ns_status.cpp +++ b/modules/commands/ns_status.cpp @@ -26,13 +26,13 @@ class CommandNSStatus : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { const Anope::string &nick = !params.empty() ? params[0] : source.GetNick(); - const NickAlias *na = findnick(nick); + const NickAlias *na = NickAlias::Find(nick); spacesepstream sep(nick); Anope::string nickbuf; while (sep.GetToken(nickbuf)) { - User *u2 = finduser(nickbuf); + User *u2 = User::Find(nickbuf, true); if (!u2) /* Nick is not online */ source.Reply(_("STATUS %s %d %s"), nickbuf.c_str(), 0, ""); else if (u2->IsIdentified() && na && na->nc == u2->Account()) /* Nick is identified */ diff --git a/modules/commands/ns_suspend.cpp b/modules/commands/ns_suspend.cpp index 6b316379e..6ff355437 100644 --- a/modules/commands/ns_suspend.cpp +++ b/modules/commands/ns_suspend.cpp @@ -22,7 +22,7 @@ struct NickSuspend : ExtensibleItem, Serializable { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data sd; @@ -32,9 +32,9 @@ struct NickSuspend : ExtensibleItem, Serializable return sd; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &sd) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &sd) { - const NickAlias *na = findnick(sd["nick"].astr()); + const NickAlias *na = NickAlias::Find(sd["nick"].astr()); if (na == NULL) return NULL; @@ -71,7 +71,7 @@ class CommandNSSuspend : public Command Anope::string reason = params.size() > 2 ? params[2] : ""; time_t expiry_secs = Config->NSSuspendExpire; - if (readonly) + if (Anope::ReadOnly) { source.Reply(READ_ONLY_MODE); return; @@ -84,9 +84,9 @@ class CommandNSSuspend : public Command expiry.clear(); } else - expiry_secs = dotime(expiry); + expiry_secs = Anope::DoTime(expiry); - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -107,7 +107,7 @@ class CommandNSSuspend : public Command nc->UnsetFlag(NI_KILL_QUICK); nc->UnsetFlag(NI_KILL_IMMED); - for (std::list<serialize_obj<NickAlias> >::iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end;) + for (std::list<Serialize::Reference<NickAlias> >::iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end;) { NickAlias *na2 = *it++; @@ -115,7 +115,7 @@ class CommandNSSuspend : public Command { na2->last_quit = reason; - User *u2 = finduser(na2->nick); + User *u2 = User::Find(na2->nick); if (u2) { u2->Logout(); @@ -133,7 +133,7 @@ class CommandNSSuspend : public Command nc->Extend("ns_suspend_expire", ns); } - Log(LOG_ADMIN, source, this) << "for " << nick << " (" << (!reason.empty() ? reason : "No reason") << "), expires in " << (expiry_secs ? do_strftime(Anope::CurTime + expiry_secs) : "never"); + Log(LOG_ADMIN, source, this) << "for " << nick << " (" << (!reason.empty() ? reason : "No reason") << "), expires in " << (expiry_secs ? Anope::strftime(Anope::CurTime + expiry_secs) : "never"); source.Reply(_("Nick %s is now suspended."), nick.c_str()); FOREACH_MOD(I_OnNickSuspended, OnNickSuspend(na)); @@ -166,13 +166,13 @@ class CommandNSUnSuspend : public Command { const Anope::string &nick = params[0]; - if (readonly) + if (Anope::ReadOnly) { source.Reply(READ_ONLY_MODE); return; } - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (!na) { source.Reply(NICK_X_NOT_REGISTERED, nick.c_str()); @@ -207,13 +207,13 @@ class CommandNSUnSuspend : public Command class NSSuspend : public Module { - SerializeType nicksuspend_type; + Serialize::Type nicksuspend_type; CommandNSSuspend commandnssuspend; CommandNSUnSuspend commandnsunsuspend; public: NSSuspend(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - nicksuspend_type("NickSuspend", NickSuspend::unserialize), commandnssuspend(this), commandnsunsuspend(this) + nicksuspend_type("NickSuspend", NickSuspend::Unserialize), commandnssuspend(this), commandnsunsuspend(this) { this->SetAuthor("Anope"); @@ -241,7 +241,7 @@ class NSSuspend : public Module na->nc->UnsetFlag(NI_SUSPENDED); na->nc->Shrink("ns_suspend_expire"); - Log(LOG_NORMAL, "expire", findbot(Config->NickServ)) << "Expiring suspend for " << na->nick; + Log(LOG_NORMAL, "expire", NickServ) << "Expiring suspend for " << na->nick; } } }; diff --git a/modules/commands/ns_update.cpp b/modules/commands/ns_update.cpp index 5ca8da26d..8f4812b9e 100644 --- a/modules/commands/ns_update.cpp +++ b/modules/commands/ns_update.cpp @@ -28,7 +28,7 @@ class CommandNSUpdate : public Command if (!u) return; - NickAlias *na = findnick(u->nick); + NickAlias *na = NickAlias::Find(u->nick); if (na && na->nc == source.GetAccount()) { diff --git a/modules/commands/os_akill.cpp b/modules/commands/os_akill.cpp index f09d1f87a..89b1d96ae 100644 --- a/modules/commands/os_akill.cpp +++ b/modules/commands/os_akill.cpp @@ -13,38 +13,38 @@ #include "module.h" -static service_reference<XLineManager> akills("XLineManager", "xlinemanager/sgline"); +static ServiceReference<XLineManager> akills("XLineManager", "xlinemanager/sgline"); class AkillDelCallback : public NumberList { CommandSource &source; - unsigned Deleted; + unsigned deleted; public: - AkillDelCallback(CommandSource &_source, const Anope::string &numlist) : NumberList(numlist, true), source(_source), Deleted(0) + AkillDelCallback(CommandSource &_source, const Anope::string &numlist) : NumberList(numlist, true), source(_source), deleted(0) { } ~AkillDelCallback() { - if (!Deleted) + if (!deleted) source.Reply(_("No matching entries on the AKILL list.")); - else if (Deleted == 1) + else if (deleted == 1) source.Reply(_("Deleted 1 entry from the AKILL list.")); else - source.Reply(_("Deleted %d entries from the AKILL list."), Deleted); + source.Reply(_("Deleted %d entries from the AKILL list."), deleted); } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number) + if (!number) return; - XLine *x = akills->GetEntry(Number - 1); + XLine *x = akills->GetEntry(number - 1); if (!x) return; - ++Deleted; + ++deleted; DoDel(source, x); } @@ -76,7 +76,7 @@ class CommandOSAKill : public Command sep.GetToken(mask); } - time_t expires = !expiry.empty() ? dotime(expiry) : Config->AutokillExpiry; + time_t expires = !expiry.empty() ? Anope::DoTime(expiry) : Config->AutokillExpiry; /* If the expiry given does not contain a final letter, it's in days, * said the doc. Ah well. */ @@ -127,7 +127,7 @@ class CommandOSAKill : public Command return; } - service_reference<RegexProvider> provider("Regex", Config->RegexEngine); + ServiceReference<RegexProvider> provider("Regex", Config->RegexEngine); if (!provider) { source.Reply(_("Unable to find regex engine %s"), Config->RegexEngine.c_str()); @@ -146,7 +146,7 @@ class CommandOSAKill : public Command } } - User *targ = finduser(mask); + User *targ = User::Find(mask, true); if (targ) mask = "*@" + targ->host; @@ -160,7 +160,7 @@ class CommandOSAKill : public Command XLine *x = new XLine(mask, source.GetNick(), expires, reason); if (Config->AkillIds) - x->UID = XLineManager::GenerateUID(); + x->id = XLineManager::GenerateUID(); unsigned int affected = 0; for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) @@ -172,7 +172,7 @@ class CommandOSAKill : public Command { source.Reply(USERHOST_MASK_TOO_WIDE, mask.c_str()); Log(LOG_ADMIN, source, this) << "tried to akill " << percent << "% of the network (" << affected << " users)"; - x->destroy(); + x->Destroy(); return; } @@ -180,7 +180,7 @@ class CommandOSAKill : public Command FOREACH_RESULT(I_OnAddXLine, OnAddXLine(source, x, akills)); if (MOD_RESULT == EVENT_STOP) { - x->destroy(); + x->Destroy(); return; } @@ -190,8 +190,8 @@ class CommandOSAKill : public Command source.Reply(_("\002%s\002 added to the AKILL list."), mask.c_str()); - Log(LOG_ADMIN, source, this) << "on " << mask << " (" << x->Reason << ") expires in " << (expires ? duration(expires - Anope::CurTime) : "never") << " [affects " << affected << " user(s) (" << percent << "%)]"; - if (readonly) + Log(LOG_ADMIN, source, this) << "on " << mask << " (" << x->reason << ") expires in " << (expires ? Anope::Duration(expires - Anope::CurTime) : "never") << " [affects " << affected << " user(s) (" << percent << "%)]"; + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); } @@ -230,14 +230,14 @@ class CommandOSAKill : public Command { FOREACH_MOD(I_OnDelXLine, OnDelXLine(source, x, akills)); - source.Reply(_("\002%s\002 deleted from the AKILL list."), x->Mask.c_str()); + source.Reply(_("\002%s\002 deleted from the AKILL list."), x->mask.c_str()); AkillDelCallback::DoDel(source, x); } while ((x = akills->HasEntry(mask))); } - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); return; @@ -269,12 +269,12 @@ class CommandOSAKill : public Command ListFormatter::ListEntry entry; entry["Number"] = stringify(number); - entry["Mask"] = x->Mask; - entry["Creator"] = x->By; - entry["Created"] = do_strftime(x->Created, NULL, true); - entry["Expires"] = expire_left(NULL, x->Expires); - entry["Reason"] = x->Reason; - this->list.addEntry(entry); + entry["Mask"] = x->mask; + entry["Creator"] = x->by; + entry["Created"] = Anope::strftime(x->created, NULL, true); + entry["Expires"] = Anope::Expires(x->expires); + entry["Reason"] = x->reason; + this->list.AddEntry(entry); } } nl_list(list, mask); @@ -286,21 +286,21 @@ class CommandOSAKill : public Command { const XLine *x = akills->GetEntry(i); - if (mask.empty() || mask.equals_ci(x->Mask) || mask == x->UID || Anope::Match(x->Mask, mask, false, true)) + if (mask.empty() || mask.equals_ci(x->mask) || mask == x->id || Anope::Match(x->mask, mask, false, true)) { ListFormatter::ListEntry entry; entry["Number"] = stringify(i + 1); - entry["Mask"] = x->Mask; - entry["Creator"] = x->By; - entry["Created"] = do_strftime(x->Created, NULL, true); - entry["Expires"] = expire_left(source.nc, x->Expires); - entry["Reason"] = x->Reason; - list.addEntry(entry); + entry["Mask"] = x->mask; + entry["Creator"] = x->by; + entry["Created"] = Anope::strftime(x->created, NULL, true); + entry["Expires"] = Anope::Expires(x->expires, source.nc); + entry["Reason"] = x->reason; + list.AddEntry(entry); } } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on the AKILL list.")); else { @@ -325,7 +325,7 @@ class CommandOSAKill : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("Reason"); this->ProcessList(source, params, list); } @@ -339,7 +339,7 @@ class CommandOSAKill : public Command } ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("Creator").addColumn("Created").addColumn("Expires").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("Creator").AddColumn("Created").AddColumn("Expires").AddColumn("Reason"); this->ProcessList(source, params, list); } diff --git a/modules/commands/os_chankill.cpp b/modules/commands/os_chankill.cpp index 456525a46..c1d71831b 100644 --- a/modules/commands/os_chankill.cpp +++ b/modules/commands/os_chankill.cpp @@ -13,7 +13,7 @@ #include "module.h" -static service_reference<XLineManager> akills("XLineManager", "xlinemanager/sgline"); +static ServiceReference<XLineManager> akills("XLineManager", "xlinemanager/sgline"); class CommandOSChanKill : public Command { @@ -42,7 +42,7 @@ class CommandOSChanKill : public Command last_param = 2; } - expires = !expiry.empty() ? dotime(expiry) : Config->ChankillExpiry; + expires = !expiry.empty() ? Anope::DoTime(expiry) : Config->ChankillExpiry; if (!expiry.empty() && isdigit(expiry[expiry.length() - 1])) expires *= 86400; if (expires && expires < 60) @@ -70,7 +70,7 @@ class CommandOSChanKill : public Command else realreason = reason; - if ((c = findchan(channel))) + if ((c = Channel::Find(channel))) { for (CUserList::iterator it = c->users.begin(), it_end = c->users.end(); it != it_end; ) { diff --git a/modules/commands/os_config.cpp b/modules/commands/os_config.cpp index 11437a087..61cda44c0 100644 --- a/modules/commands/os_config.cpp +++ b/modules/commands/os_config.cpp @@ -117,7 +117,7 @@ class CommandOSConfig : public Command } case DT_TIME: { - time_t time = dotime(vi.GetValue()); + time_t time = Anope::DoTime(vi.GetValue()); ValueContainerTime *vci = anope_dynamic_static_cast<ValueContainerTime *>(v->val); vci->Set(&time, sizeof(time_t)); break; @@ -169,7 +169,7 @@ class CommandOSConfig : public Command continue; ListFormatter lflist; - lflist.addColumn("Name").addColumn("Value"); + lflist.AddColumn("Name").AddColumn("Value"); for (unsigned i = 0; i < list.size(); ++i) { const Anope::string &first = list[i].first, second = list[i].second; @@ -177,7 +177,7 @@ class CommandOSConfig : public Command ListFormatter::ListEntry entry; entry["Name"] = first; entry["Value"] = second; - lflist.addEntry(entry); + lflist.AddEntry(entry); } std::vector<Anope::string> replies; diff --git a/modules/commands/os_defcon.cpp b/modules/commands/os_defcon.cpp index ad08ba77c..1457a57dc 100644 --- a/modules/commands/os_defcon.cpp +++ b/modules/commands/os_defcon.cpp @@ -34,8 +34,8 @@ bool DefConModesSet = false; struct DefconConfig { std::vector<std::bitset<32> > DefCon; - Flags<ChannelModeName, CMODE_END * 2> DefConModesOn; - Flags<ChannelModeName, CMODE_END * 2> DefConModesOff; + Flags<ChannelModeName> DefConModesOn; + Flags<ChannelModeName> DefConModesOff; std::map<ChannelModeName, Anope::string> DefConModesOnParams; int defaultlevel, sessionlimit; @@ -117,17 +117,17 @@ class DefConTimeout : public CallBack { DConfig.defaultlevel = level; FOREACH_MOD(I_OnDefconLevel, OnDefconLevel(level)); - Log(findbot(Config->OperServ), "operserv/defcon") << "Defcon level timeout, returning to level " << level; + Log(OperServ, "operserv/defcon") << "Defcon level timeout, returning to level " << level; if (DConfig.globalondefcon) { if (!DConfig.offmessage.empty()) - global->SendGlobal(findbot(Config->Global), "", DConfig.offmessage); + GlobalService->SendGlobal(Global, "", DConfig.offmessage); else - global->SendGlobal(findbot(Config->Global), "", Anope::printf(translate(_("The Defcon Level is now at Level: \002%d\002")), DConfig.defaultlevel)); + GlobalService->SendGlobal(Global, "", Anope::printf(Language::Translate(_("The Defcon Level is now at Level: \002%d\002")), DConfig.defaultlevel)); if (!DConfig.message.empty()) - global->SendGlobal(findbot(Config->Global), "", DConfig.message); + GlobalService->SendGlobal(Global, "", DConfig.message); } runDefCon(); @@ -215,12 +215,12 @@ class CommandOSDefcon : public Command if (DConfig.globalondefcon) { if (DConfig.defaultlevel == 5 && !DConfig.offmessage.empty()) - global->SendGlobal(findbot(Config->Global), "", DConfig.offmessage); + GlobalService->SendGlobal(Global, "", DConfig.offmessage); else if (DConfig.defaultlevel != 5) { - global->SendGlobal(findbot(Config->Global), "", Anope::printf(_("The Defcon level is now at: \002%d\002"), DConfig.defaultlevel)); + GlobalService->SendGlobal(Global, "", Anope::printf(_("The Defcon level is now at: \002%d\002"), DConfig.defaultlevel)); if (!DConfig.message.empty()) - global->SendGlobal(findbot(Config->Global), "", DConfig.message); + GlobalService->SendGlobal(Global, "", DConfig.message); } } @@ -242,8 +242,8 @@ class CommandOSDefcon : public Command class OSDefcon : public Module { - service_reference<SessionService> session_service; - service_reference<XLineManager> akills; + ServiceReference<SessionService> session_service; + ServiceReference<XLineManager> akills; CommandOSDefcon commandosdefcon; void ParseModeString() @@ -280,17 +280,17 @@ class OSDefcon : public Module if ((cm = ModeManager::FindChannelModeByChar(mode))) { - if (cm->Type == MODE_STATUS || cm->Type == MODE_LIST || !cm->CanSet(NULL)) + if (cm->type == MODE_STATUS || cm->type == MODE_LIST || !cm->CanSet(NULL)) { Log(this) << "DefConChanModes mode character '" << mode << "' cannot be locked"; continue; } else if (add) { - DConfig.DefConModesOn.SetFlag(cm->Name); - DConfig.DefConModesOff.UnsetFlag(cm->Name); + DConfig.DefConModesOn.SetFlag(cm->name); + DConfig.DefConModesOff.UnsetFlag(cm->name); - if (cm->Type == MODE_PARAM) + if (cm->type == MODE_PARAM) { cmp = anope_dynamic_static_cast<ChannelModeParam *>(cm); @@ -303,21 +303,21 @@ class OSDefcon : public Module if (!cmp->IsValid(param)) continue; - DConfig.SetDefConParam(cmp->Name, param); + DConfig.SetDefConParam(cmp->name, param); } } - else if (DConfig.DefConModesOn.HasFlag(cm->Name)) + else if (DConfig.DefConModesOn.HasFlag(cm->name)) { - DConfig.DefConModesOn.UnsetFlag(cm->Name); + DConfig.DefConModesOn.UnsetFlag(cm->name); - if (cm->Type == MODE_PARAM) - DConfig.UnsetDefConParam(cm->Name); + if (cm->type == MODE_PARAM) + DConfig.UnsetDefConParam(cm->name); } } } /* We can't mlock +L if +l is not mlocked as well. */ - if ((cm = ModeManager::FindChannelModeByName(CMODE_REDIRECT)) && DConfig.DefConModesOn.HasFlag(cm->Name) && !DConfig.DefConModesOn.HasFlag(CMODE_LIMIT)) + if ((cm = ModeManager::FindChannelModeByName(CMODE_REDIRECT)) && DConfig.DefConModesOn.HasFlag(cm->name) && !DConfig.DefConModesOn.HasFlag(CMODE_LIMIT)) { DConfig.DefConModesOn.UnsetFlag(CMODE_REDIRECT); @@ -356,9 +356,9 @@ class OSDefcon : public Module dconfig.defcons[1] = config.ReadValue("defcon", "level1", 0); dconfig.sessionlimit = config.ReadInteger("defcon", "sessionlimit", 0, 0); dconfig.akillreason = config.ReadValue("defcon", "akillreason", 0); - dconfig.akillexpire = dotime(config.ReadValue("defcon", "akillexpire", 0)); + dconfig.akillexpire = Anope::DoTime(config.ReadValue("defcon", "akillexpire", 0)); dconfig.chanmodes = config.ReadValue("defcon", "chanmodes", 0); - dconfig.timeout = dotime(config.ReadValue("defcon", "timeout", 0)); + dconfig.timeout = Anope::DoTime(config.ReadValue("defcon", "timeout", 0)); dconfig.globalondefcon = config.ReadFlag("defcon", "globalondefcon", 0); dconfig.message = config.ReadValue("defcon", "message", 0); dconfig.offmessage = config.ReadValue("defcon", "offmessage", 0); @@ -414,9 +414,9 @@ class OSDefcon : public Module { if (DConfig.Check(DEFCON_AKILL_NEW_CLIENTS) && akills) { - Log(findbot(Config->OperServ), "operserv/defcon") << "DEFCON: adding akill for *@" << u->host; + Log(OperServ, "operserv/defcon") << "DEFCON: adding akill for *@" << u->host; XLine *x = new XLine("*@" + u->host, Config->OperServ, Anope::CurTime + DConfig.akillexpire, DConfig.akillreason, XLineManager::GenerateUID()); - x->By = Config->OperServ; + x->by = Config->OperServ; akills->AddXLine(x); } @@ -435,7 +435,7 @@ class OSDefcon : public Module if (DConfig.Check(DEFCON_FORCE_CHAN_MODES) && cm && DConfig.DefConModesOff.HasFlag(Name)) { - c->RemoveMode(findbot(Config->OperServ), Name, param); + c->RemoveMode(OperServ, Name, param); return EVENT_STOP; } @@ -452,9 +452,9 @@ class OSDefcon : public Module Anope::string param; if (DConfig.GetDefConParam(Name, param)) - c->SetMode(findbot(Config->OperServ), Name, param); + c->SetMode(OperServ, Name, param); else - c->SetMode(findbot(Config->OperServ), Name); + c->SetMode(OperServ, Name); return EVENT_STOP; @@ -501,16 +501,16 @@ class OSDefcon : public Module return EVENT_CONTINUE; } - void OnUserConnect(dynamic_reference<User> &u, bool &exempt) anope_override + void OnUserConnect(Reference<User> &u, bool &exempt) anope_override { if (exempt || !u || !u->server->IsSynced() || u->server->IsULined()) return; if (DConfig.Check(DEFCON_AKILL_NEW_CLIENTS) && akills) { - Log(findbot(Config->OperServ), "operserv/defcon") << "DEFCON: adding akill for *@" << u->host; + Log(OperServ, "operserv/defcon") << "DEFCON: adding akill for *@" << u->host; XLine x("*@" + u->host, Config->OperServ, Anope::CurTime + DConfig.akillexpire, DConfig.akillreason, XLineManager::GenerateUID()); - x.By = Config->OperServ; + x.by = Config->OperServ; akills->Send(NULL, &x); } if (DConfig.Check(DEFCON_NO_NEW_CLIENTS) || DConfig.Check(DEFCON_AKILL_NEW_CLIENTS)) @@ -525,7 +525,7 @@ class OSDefcon : public Module return; } - if (!DConfig.sessionlimit || !session_service) + if (DConfig.sessionlimit <= 0 || !session_service) return; Session *session; @@ -541,19 +541,19 @@ class OSDefcon : public Module if (DConfig.Check(DEFCON_REDUCE_SESSION) && !exception) { - if (session && session->count > DConfig.sessionlimit) + if (session && session->count > static_cast<unsigned>(DConfig.sessionlimit)) { if (!Config->SessionLimitExceeded.empty()) - ircdproto->SendMessage(findbot(Config->OperServ), u->nick, Config->SessionLimitExceeded.c_str(), u->host.c_str()); + IRCD->SendMessage(OperServ, u->nick, Config->SessionLimitExceeded.c_str(), u->host.c_str()); if (!Config->SessionLimitDetailsLoc.empty()) - ircdproto->SendMessage(findbot(Config->OperServ), u->nick, "%s", Config->SessionLimitDetailsLoc.c_str()); + IRCD->SendMessage(OperServ, u->nick, "%s", Config->SessionLimitDetailsLoc.c_str()); ++session->hits; if (akills && Config->MaxSessionKill && session->hits >= Config->MaxSessionKill) { XLine x("*@" + u->host, Config->OperServ, Anope::CurTime + Config->SessionAutoKillExpiry, "Defcon session limit exceeded", XLineManager::GenerateUID()); akills->Send(NULL, &x); - Log(findbot(Config->OperServ), "akill/defcon") << "[DEFCON] Added a temporary AKILL for \2*@" << u->host << "\2 due to excessive connections"; + Log(OperServ, "akill/defcon") << "[DEFCON] Added a temporary AKILL for \2*@" << u->host << "\2 due to excessive connections"; } else { @@ -566,14 +566,14 @@ class OSDefcon : public Module void OnChannelModeAdd(ChannelMode *cm) anope_override { - if (DConfig.chanmodes.find(cm->ModeChar) != Anope::string::npos) + if (DConfig.chanmodes.find(cm->mchar) != Anope::string::npos) this->ParseModeString(); } void OnChannelCreate(Channel *c) anope_override { if (DConfig.Check(DEFCON_FORCE_CHAN_MODES)) - c->SetModes(findbot(Config->OperServ), false, "%s", DConfig.chanmodes.c_str()); + c->SetModes(OperServ, false, "%s", DConfig.chanmodes.c_str()); } }; @@ -612,10 +612,10 @@ void runDefCon() { if (DConfig.chanmodes[0] == '+' || DConfig.chanmodes[0] == '-') { - Log(findbot(Config->OperServ), "operserv/defcon") << "DEFCON: setting " << DConfig.chanmodes << " on all channels"; + Log(OperServ, "operserv/defcon") << "DEFCON: setting " << DConfig.chanmodes << " on all channels"; DefConModesSet = true; for (channel_map::const_iterator it = ChannelList.begin(), it_end = ChannelList.end(); it != it_end; ++it) - it->second->SetModes(findbot(Config->OperServ), false, "%s", DConfig.chanmodes.c_str()); + it->second->SetModes(OperServ, false, "%s", DConfig.chanmodes.c_str()); } } } @@ -629,9 +629,9 @@ void runDefCon() Anope::string newmodes = defconReverseModes(DConfig.chanmodes); if (!newmodes.empty()) { - Log(findbot(Config->OperServ), "operserv/defcon") << "DEFCON: setting " << newmodes << " on all channels"; + Log(OperServ, "operserv/defcon") << "DEFCON: setting " << newmodes << " on all channels"; for (channel_map::const_iterator it = ChannelList.begin(), it_end = ChannelList.end(); it != it_end; ++it) - it->second->SetModes(findbot(Config->OperServ), false, "%s", newmodes.c_str()); + it->second->SetModes(OperServ, false, "%s", newmodes.c_str()); } } } diff --git a/modules/commands/os_dns.cpp b/modules/commands/os_dns.cpp index e304050b3..769a42f26 100644 --- a/modules/commands/os_dns.cpp +++ b/modules/commands/os_dns.cpp @@ -44,12 +44,12 @@ class DNSServer : public Serializable void Pool(bool p) { pooled = p; - if (DNSEngine) - DNSEngine->UpdateSerial(); + if (DNS::Engine) + DNS::Engine->UpdateSerial(); } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data data; @@ -62,7 +62,7 @@ class DNSServer : public Serializable return data; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { DNSServer *req; @@ -104,7 +104,7 @@ class CommandOSDNS : public Command } ListFormatter lf; - lf.addColumn("Server").addColumn("IP").addColumn("Limit").addColumn("State"); + lf.AddColumn("Server").AddColumn("IP").AddColumn("Limit").AddColumn("State"); for (unsigned i = 0; i < dns_servers.size(); ++i) { DNSServer *s = dns_servers[i]; @@ -129,7 +129,7 @@ class CommandOSDNS : public Command else entry["State"] = "Unpooled"; - lf.addEntry(entry); + lf.AddEntry(entry); } std::vector<Anope::string> replies; @@ -221,7 +221,7 @@ class CommandOSDNS : public Command Log(LOG_ADMIN, source, this) << "to add IP " << params[2] << " to " << s->GetName(); if (s->Pooled()) - DNSEngine->UpdateSerial(); + DNS::Engine->UpdateSerial(); } void DelIP(CommandSource &source, const std::vector<Anope::string> ¶ms) @@ -248,7 +248,7 @@ class CommandOSDNS : public Command } if (s->Pooled()) - DNSEngine->UpdateSerial(); + DNS::Engine->UpdateSerial(); return; } @@ -388,7 +388,7 @@ class CommandOSDNS : public Command class ModuleDNS : public Module { - SerializeType dns_type; + Serialize::Type dns_type; CommandOSDNS commandosdns; time_t ttl; @@ -400,7 +400,7 @@ class ModuleDNS : public Module public: ModuleDNS(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, SUPPORTED), - dns_type("DNSServer", DNSServer::unserialize), commandosdns(this) + dns_type("DNSServer", DNSServer::Unserialize), commandosdns(this) { this->SetAuthor("Anope"); @@ -414,10 +414,10 @@ class ModuleDNS : public Module { ConfigReader config; - this->ttl = dotime(config.ReadValue("os_dns", "ttl", 0)); + this->ttl = Anope::DoTime(config.ReadValue("os_dns", "ttl", 0)); this->user_drop_mark = config.ReadInteger("os_dns", "user_drop_mark", 0, false); - this->user_drop_time = dotime(config.ReadValue("os_dns", "user_drop_time", 0, false)); - this->user_drop_readd_time = dotime(config.ReadValue("os_dns", "user_drop_readd_time", 0, false)); + this->user_drop_time = Anope::DoTime(config.ReadValue("os_dns", "user_drop_time", 0, false)); + this->user_drop_readd_time = Anope::DoTime(config.ReadValue("os_dns", "user_drop_readd_time", 0, false)); this->remove_split_servers = config.ReadFlag("os_dns", "remove_split_servers", 0); this->readd_connected_servers = config.ReadFlag("os_dns", "readd_connected_servers", 0); } @@ -427,7 +427,7 @@ class ModuleDNS : public Module if (this->readd_connected_servers) { DNSServer *dns = DNSServer::Find(s->GetName()); - if (dns && !dns->Pooled() && !dns->GetIPs().empty() && dns->GetLimit() < s->Users) + if (dns && !dns->Pooled() && !dns->GetIPs().empty() && dns->GetLimit() < s->users) { dns->Pool(true); Log(this) << "Pooling server " << s->GetName(); @@ -446,15 +446,15 @@ class ModuleDNS : public Module } } - void OnUserConnect(dynamic_reference<User> &u, bool &exempt) anope_override + void OnUserConnect(Reference<User> &u, bool &exempt) anope_override { if (u && u->server) { DNSServer *s = DNSServer::Find(u->server->GetName()); /* Check for user limit reached */ - if (s && s->GetLimit() && s->Pooled() && u->server->Users >= s->GetLimit()) + if (s && s->GetLimit() && s->Pooled() && u->server->users >= s->GetLimit()) { - Log(this) << "Depooling full server " << s->GetName() << ": " << u->server->Users << " users"; + Log(this) << "Depooling full server " << s->GetName() << ": " << u->server->users << " users"; s->Pool(false); } } @@ -469,7 +469,7 @@ class ModuleDNS : public Module return; /* Check for dropping under userlimit */ - if (s->GetLimit() && !s->Pooled() && s->GetLimit() > u->server->Users) + if (s->GetLimit() && !s->Pooled() && s->GetLimit() > u->server->users) { Log(this) << "Pooling server " << s->GetName(); s->Pool(true); @@ -505,13 +505,13 @@ class ModuleDNS : public Module } } - void OnDnsRequest(DNSPacket &req, DNSPacket *packet) anope_override + void OnDnsRequest(DNS::Packet &req, DNS::Packet *packet) anope_override { if (req.questions.empty()) return; /* Currently we reply to any QR for A/AAAA */ - const Question& q = req.questions[0]; - if (q.type != DNS_QUERY_A && q.type != DNS_QUERY_AAAA && q.type != DNS_QUERY_AXFR) + const DNS::Question& q = req.questions[0]; + if (q.type != DNS::QUERY_A && q.type != DNS::QUERY_AAAA && q.type != DNS::QUERY_AXFR) return; for (unsigned i = 0; i < dns_servers.size(); ++i) @@ -522,11 +522,11 @@ class ModuleDNS : public Module for (unsigned j = 0; j < s->GetIPs().size(); ++j) { - QueryType q_type = s->GetIPs()[j].find(':') != Anope::string::npos ? DNS_QUERY_AAAA : DNS_QUERY_A; + DNS::QueryType q_type = s->GetIPs()[j].find(':') != Anope::string::npos ? DNS::QUERY_AAAA : DNS::QUERY_A; - if (q.type == DNS_QUERY_AXFR || q_type == q.type) + if (q.type == DNS::QUERY_AXFR || q_type == q.type) { - ResourceRecord rr(q.name, q_type); + DNS::ResourceRecord rr(q.name, q_type); rr.ttl = this->ttl; rr.rdata = s->GetIPs()[j]; packet->answers.push_back(rr); @@ -550,11 +550,11 @@ class ModuleDNS : public Module for (unsigned j = 0; j < s->GetIPs().size(); ++j) { - QueryType q_type = s->GetIPs()[j].find(':') != Anope::string::npos ? DNS_QUERY_AAAA : DNS_QUERY_A; + DNS::QueryType q_type = s->GetIPs()[j].find(':') != Anope::string::npos ? DNS::QUERY_AAAA : DNS::QUERY_A; - if (q.type == DNS_QUERY_AXFR || q_type == q.type) + if (q.type == DNS::QUERY_AXFR || q_type == q.type) { - ResourceRecord rr(q.name, q_type); + DNS::ResourceRecord rr(q.name, q_type); rr.ttl = this->ttl; rr.rdata = s->GetIPs()[j]; packet->answers.push_back(rr); diff --git a/modules/commands/os_forbid.cpp b/modules/commands/os_forbid.cpp index 31ca94265..08710b223 100644 --- a/modules/commands/os_forbid.cpp +++ b/modules/commands/os_forbid.cpp @@ -31,7 +31,7 @@ class MyForbidService : public ForbidService std::vector<ForbidData *>::iterator it = std::find(this->forbidData.begin(), this->forbidData.end(), d); if (it != this->forbidData.end()) this->forbidData.erase(it); - d->destroy(); + d->Destroy(); } ForbidData *FindForbid(const Anope::string &mask, ForbidType ftype) anope_override @@ -65,7 +65,7 @@ class MyForbidService : public ForbidService Log(LOG_NORMAL, "expire/forbid") << "Expiring forbid for " << d->mask << " type " << ftype; this->forbidData.erase(this->forbidData.begin() + i - 1); - d->destroy(); + d->Destroy(); } } @@ -75,7 +75,7 @@ class MyForbidService : public ForbidService class CommandOSForbid : public Command { - service_reference<ForbidService> fs; + ServiceReference<ForbidService> fs; public: CommandOSForbid(Module *creator) : Command(creator, "operserv/forbid", 1, 5), fs("ForbidService", "forbid") { @@ -122,12 +122,12 @@ class CommandOSForbid : public Command if (!expiry.empty()) { - expiryt = dotime(expiry); + expiryt = Anope::DoTime(expiry); if (expiryt) expiryt += Anope::CurTime; } - NickAlias *target = findnick(entry); + NickAlias *target = NickAlias::Find(entry); if (target != NULL && Config->NSSecureAdmins && target->nc->IsServicesOper()) { source.Reply(ACCESS_DENIED); @@ -152,7 +152,7 @@ class CommandOSForbid : public Command this->fs->AddForbid(d); Log(LOG_ADMIN, source, this) << "to add a forbid on " << entry << " of type " << subcommand; - source.Reply(_("Added a%s forbid on %s to expire on %s"), ftype == FT_CHAN ? "n" : "", entry.c_str(), d->expires ? do_strftime(d->expires).c_str() : "never"); + source.Reply(_("Added a%s forbid on %s to expire on %s"), ftype == FT_CHAN ? "n" : "", entry.c_str(), d->expires ? Anope::strftime(d->expires).c_str() : "never"); } else if (command.equals_ci("DEL") && params.size() > 2 && ftype != FT_NONE) { @@ -176,7 +176,7 @@ class CommandOSForbid : public Command else { ListFormatter list; - list.addColumn("Mask").addColumn("Type").addColumn("Reason"); + list.AddColumn("Mask").AddColumn("Type").AddColumn("Reason"); for (unsigned i = 0; i < forbids.size(); ++i) { @@ -196,9 +196,9 @@ class CommandOSForbid : public Command entry["Mask"] = d->mask; entry["Type"] = stype; entry["Creator"] = d->creator; - entry["Expires"] = d->expires ? do_strftime(d->expires).c_str() : "never"; + entry["Expires"] = d->expires ? Anope::strftime(d->expires).c_str() : "never"; entry["Reason"] = d->reason; - list.addEntry(entry); + list.AddEntry(entry); } source.Reply(_("Forbid list:")); @@ -234,13 +234,13 @@ class CommandOSForbid : public Command class OSForbid : public Module { - SerializeType forbiddata_type; + Serialize::Type forbiddata_type; MyForbidService forbidService; CommandOSForbid commandosforbid; public: OSForbid(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - forbiddata_type("ForbidData", ForbidData::unserialize), forbidService(this), commandosforbid(this) + forbiddata_type("ForbidData", ForbidData::Unserialize), forbidService(this), commandosforbid(this) { this->SetAuthor("Anope"); @@ -248,7 +248,7 @@ class OSForbid : public Module ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); } - void OnUserConnect(dynamic_reference<User> &u, bool &exempt) anope_override + void OnUserConnect(Reference<User> &u, bool &exempt) anope_override { if (!u || exempt) return; @@ -264,13 +264,12 @@ class OSForbid : public Module ForbidData *d = this->forbidService.FindForbid(u->nick, FT_NICK); if (d != NULL) { - const BotInfo *bi = findbot(Config->OperServ); - if (bi) + if (OperServ) { if (d->reason.empty()) - u->SendMessage(bi, _("This nickname has been forbidden.")); + u->SendMessage(OperServ, _("This nickname has been forbidden.")); else - u->SendMessage(bi, _("This nickname has been forbidden: %s"), d->reason.c_str()); + u->SendMessage(OperServ, _("This nickname has been forbidden: %s"), d->reason.c_str()); } u->Collide(NULL); } @@ -278,17 +277,16 @@ class OSForbid : public Module void OnJoinChannel(User *u, Channel *c) anope_override { - if (u->HasMode(UMODE_OPER)) + if (u->HasMode(UMODE_OPER) || !OperServ) return; - BotInfo *bi = findbot(Config->OperServ); ForbidData *d = this->forbidService.FindForbid(c->name, FT_CHAN); - if (bi != NULL && d != NULL) + if (d != NULL) { - if (ircdproto->CanSQLineChannel) + if (IRCD->CanSQLineChannel) { - XLine x(c->name, bi->nick, Anope::CurTime + Config->CSInhabit, d->reason); - ircdproto->SendSQLine(NULL, &x); + XLine x(c->name, OperServ->nick, Anope::CurTime + Config->CSInhabit, d->reason); + IRCD->SendSQLine(NULL, &x); } else if (!c->HasFlag(CH_INHABIT)) { @@ -303,9 +301,9 @@ class OSForbid : public Module } if (d->reason.empty()) - c->Kick(bi, u, _("This channel has been forbidden.")); + c->Kick(OperServ, u, _("This channel has been forbidden.")); else - c->Kick(bi, u, _("This channel has been forbidden: %s"), d->reason.c_str()); + c->Kick(OperServ, u, _("This channel has been forbidden: %s"), d->reason.c_str()); } } diff --git a/modules/commands/os_forbid.h b/modules/commands/os_forbid.h index f79b63616..1fce928db 100644 --- a/modules/commands/os_forbid.h +++ b/modules/commands/os_forbid.h @@ -19,8 +19,8 @@ struct ForbidData : Serializable ForbidType type; ForbidData() : Serializable("ForbidData") { } - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &data); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data); }; class ForbidService : public Service @@ -37,9 +37,9 @@ class ForbidService : public Service virtual const std::vector<ForbidData *> &GetForbids() = 0; }; -static service_reference<ForbidService> forbid_service("ForbidService", "forbid"); +static ServiceReference<ForbidService> forbid_service("ForbidService", "forbid"); -Serialize::Data ForbidData::serialize() const +Serialize::Data ForbidData::Serialize() const { Serialize::Data data; @@ -53,7 +53,7 @@ Serialize::Data ForbidData::serialize() const return data; } -Serializable* ForbidData::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* ForbidData::Unserialize(Serializable *obj, Serialize::Data &data) { if (!forbid_service) return NULL; diff --git a/modules/commands/os_ignore.cpp b/modules/commands/os_ignore.cpp index 2377c28be..f959e7ebc 100644 --- a/modules/commands/os_ignore.cpp +++ b/modules/commands/os_ignore.cpp @@ -25,7 +25,7 @@ class OSIgnoreService : public IgnoreService Anope::string realmask = mask; size_t user, host; - User *u = finduser(mask); + User *u = User::Find(mask, true); if (u) realmask = "*!*@" + u->host; /* Determine whether we get a nick or a mask. */ @@ -86,7 +86,7 @@ class OSIgnoreService : public IgnoreService IgnoreData *Find(const Anope::string &mask) anope_override { - User *u = finduser(mask); + User *u = User::Find(mask, true); std::list<IgnoreData>::iterator ign = this->ignores.begin(), ign_end = this->ignores.end(); if (u) @@ -162,7 +162,7 @@ class CommandOSIgnore : public Command } else { - time_t t = dotime(time); + time_t t = Anope::DoTime(time); if (t <= -1) { @@ -205,7 +205,7 @@ class CommandOSIgnore : public Command else { ListFormatter list; - list.addColumn("Mask").addColumn("Creator").addColumn("Reason").addColumn("Expires"); + list.AddColumn("Mask").AddColumn("Creator").AddColumn("Reason").AddColumn("Expires"); for (std::list<IgnoreData>::const_iterator ign = ignores.begin(), ign_end = ignores.end(); ign != ign_end; ++ign) { const IgnoreData &ignore = *ign; @@ -214,8 +214,8 @@ class CommandOSIgnore : public Command entry["Mask"] = ignore.mask; entry["Creator"] = ignore.creator; entry["Reason"] = ignore.reason; - entry["Expires"] = do_strftime(ignore.time); - list.addEntry(entry); + entry["Expires"] = Anope::strftime(ignore.time); + list.AddEntry(entry); } source.Reply(_("Services ignore list:")); @@ -309,17 +309,16 @@ class CommandOSIgnore : public Command class OSIgnore : public Module { - SerializeType ignoredata_type; + Serialize::Type ignoredata_type; OSIgnoreService osignoreservice; CommandOSIgnore commandosignore; public: OSIgnore(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - ignoredata_type("IgnoreData", IgnoreData::unserialize), osignoreservice(this), commandosignore(this) + ignoredata_type("IgnoreData", IgnoreData::Unserialize), osignoreservice(this), commandosignore(this) { this->SetAuthor("Anope"); - Implementation i[] = { I_OnBotPrivmsg }; ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); } diff --git a/modules/commands/os_ignore.h b/modules/commands/os_ignore.h index 38042a72d..003d88b5b 100644 --- a/modules/commands/os_ignore.h +++ b/modules/commands/os_ignore.h @@ -18,8 +18,8 @@ struct IgnoreData : Serializable time_t time; /* When do we stop ignoring them? */ IgnoreData() : Serializable("IgnoreData") { } - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &data); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data); }; class IgnoreService : public Service @@ -41,9 +41,9 @@ class IgnoreService : public Service inline std::list<IgnoreData> &GetIgnores() { return this->ignores; } }; -static service_reference<IgnoreService> ignore_service("IgnoreService", "ignore"); +static ServiceReference<IgnoreService> ignore_service("IgnoreService", "ignore"); -Serialize::Data IgnoreData::serialize() const +Serialize::Data IgnoreData::Serialize() const { Serialize::Data data; @@ -55,7 +55,7 @@ Serialize::Data IgnoreData::serialize() const return data; } -Serializable* IgnoreData::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* IgnoreData::Unserialize(Serializable *obj, Serialize::Data &data) { if (!ignore_service) return NULL; diff --git a/modules/commands/os_jupe.cpp b/modules/commands/os_jupe.cpp index cfe917c13..49095129c 100644 --- a/modules/commands/os_jupe.cpp +++ b/modules/commands/os_jupe.cpp @@ -28,7 +28,7 @@ class CommandOSJupe : public Command const Anope::string &reason = params.size() > 1 ? params[1] : ""; Server *server = Server::Find(jserver); - if (!IsValidHost(jserver) || jserver.find('.') == Anope::string::npos) + if (!IRCD->IsHostValid(jserver) || jserver.find('.') == Anope::string::npos) source.Reply(_("Please use a valid server name when juping")); else if (server && (server == Me || server == Me->GetLinks().front())) source.Reply(_("You can not jupe your services server or your uplink server.")); @@ -36,9 +36,9 @@ class CommandOSJupe : public Command { Anope::string rbuf = "Juped by " + source.GetNick() + (!reason.empty() ? ": " + reason : ""); if (server) - ircdproto->SendSquit(server, rbuf); - Server *juped_server = new Server(Me, jserver, 1, rbuf, ts6_sid_retrieve(), SERVER_JUPED); - ircdproto->SendServer(juped_server); + IRCD->SendSquit(server, rbuf); + Server *juped_server = new Server(Me, jserver, 1, rbuf, Servers::TS6_SID_Retrieve(), SERVER_JUPED); + IRCD->SendServer(juped_server); Log(LOG_ADMIN, source, this) << "on " << jserver << " (" << rbuf << ")"; } diff --git a/modules/commands/os_kick.cpp b/modules/commands/os_kick.cpp index 0a5165621..5f33a4bbc 100644 --- a/modules/commands/os_kick.cpp +++ b/modules/commands/os_kick.cpp @@ -30,7 +30,7 @@ class CommandOSKick : public Command Channel *c; User *u2; - if (!(c = findchan(chan))) + if (!(c = Channel::Find(chan))) { source.Reply(CHAN_X_NOT_IN_USE, chan.c_str()); return; @@ -40,7 +40,7 @@ class CommandOSKick : public Command source.Reply(_("Services is unable to change modes. Are your servers' U:lines configured correctly?")); return; } - else if (!(u2 = finduser(nick))) + else if (!(u2 = User::Find(nick, true))) { source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); return; diff --git a/modules/commands/os_kill.cpp b/modules/commands/os_kill.cpp index e7f78b1b5..83cd81f58 100644 --- a/modules/commands/os_kill.cpp +++ b/modules/commands/os_kill.cpp @@ -27,7 +27,7 @@ class CommandOSKill : public Command const Anope::string &nick = params[0]; Anope::string reason = params.size() > 1 ? params[1] : ""; - User *u2 = finduser(nick); + User *u2 = User::Find(nick, true); if (u2 == NULL) source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); else if (u2->IsProtected() || u2->server == Me) diff --git a/modules/commands/os_list.cpp b/modules/commands/os_list.cpp index 0272742c1..dfb0c00c8 100644 --- a/modules/commands/os_list.cpp +++ b/modules/commands/os_list.cpp @@ -36,9 +36,9 @@ class CommandOSChanList : public Command } ListFormatter list; - list.addColumn("Name").addColumn("Users").addColumn("Modes").addColumn("Topic"); + list.AddColumn("Name").AddColumn("Users").AddColumn("Modes").AddColumn("Topic"); - if (!pattern.empty() && (u2 = finduser(pattern))) + if (!pattern.empty() && (u2 = User::Find(pattern, true))) { source.Reply(_("\002%s\002 channel list:"), u2->nick.c_str()); @@ -56,7 +56,7 @@ class CommandOSChanList : public Command entry["Users"] = stringify(cc->chan->users.size()); entry["Modes"] = cc->chan->GetModes(true, true); entry["Topic"] = cc->chan->topic; - list.addEntry(entry); + list.AddEntry(entry); } } else @@ -79,7 +79,7 @@ class CommandOSChanList : public Command entry["Users"] = stringify(c->users.size()); entry["Modes"] = c->GetModes(true, true); entry["Topic"] = c->topic; - list.addEntry(entry); + list.AddEntry(entry); } } @@ -130,9 +130,9 @@ class CommandOSUserList : public Command Modes.push_back(UMODE_INVIS); ListFormatter list; - list.addColumn("Name").addColumn("Mask"); + list.AddColumn("Name").AddColumn("Mask"); - if (!pattern.empty() && (c = findchan(pattern))) + if (!pattern.empty() && (c = Channel::Find(pattern))) { source.Reply(_("\002%s\002 users list:"), pattern.c_str()); @@ -148,7 +148,7 @@ class CommandOSUserList : public Command ListFormatter::ListEntry entry; entry["Name"] = uc->user->nick; entry["Mask"] = uc->user->GetIdent() + "@" + uc->user->GetDisplayedHost(); - list.addEntry(entry); + list.AddEntry(entry); } } else @@ -178,7 +178,7 @@ class CommandOSUserList : public Command ListFormatter::ListEntry entry; entry["Name"] = u2->nick; entry["Mask"] = u2->GetIdent() + "@" + u2->GetDisplayedHost(); - list.addEntry(entry); + list.AddEntry(entry); } } diff --git a/modules/commands/os_login.cpp b/modules/commands/os_login.cpp index 7b223eb1f..735562819 100644 --- a/modules/commands/os_login.cpp +++ b/modules/commands/os_login.cpp @@ -41,7 +41,7 @@ class CommandOSLogin : public Command else if (o->password != password) { source.Reply(PASSWORD_INCORRECT); - bad_password(u); + u->BadPassword(); } else { diff --git a/modules/commands/os_logsearch.cpp b/modules/commands/os_logsearch.cpp index 12431798c..7ad806330 100644 --- a/modules/commands/os_logsearch.cpp +++ b/modules/commands/os_logsearch.cpp @@ -23,7 +23,7 @@ class CommandOSLogSearch : public Command strftime(timestamp, sizeof(timestamp), "%Y%m%d", tm); - return log_dir + "/" + file + "." + timestamp; + return Anope::LogDir + "/" + file + "." + timestamp; } public: diff --git a/modules/commands/os_mode.cpp b/modules/commands/os_mode.cpp index 419fc8442..676ef7ea5 100644 --- a/modules/commands/os_mode.cpp +++ b/modules/commands/os_mode.cpp @@ -27,7 +27,7 @@ class CommandOSMode : public Command const Anope::string &target = params[0]; const Anope::string &modes = params[1]; - Channel *c = findchan(target); + Channel *c = Channel::Find(target); if (!c) source.Reply(CHAN_X_NOT_IN_USE, target.c_str()); else if (c->bouncy_modes) @@ -62,23 +62,23 @@ class CommandOSMode : public Command continue; Anope::string param, param_log; - if (cm->Type != MODE_REGULAR) + if (cm->type != MODE_REGULAR) { if (!sep.GetToken(param)) continue; param_log = param; - if (cm->Type == MODE_STATUS) + if (cm->type == MODE_STATUS) { - User *targ = finduser(param); + User *targ = User::Find(param, true); if (targ == NULL || c->FindUser(targ) == NULL) continue; param = targ->GetUID(); } } - log_modes += cm->ModeChar; + log_modes += cm->mchar; if (!param.empty()) log_params += " " + param_log; @@ -117,7 +117,7 @@ class CommandOSUMode : public Command const Anope::string &target = params[0]; const Anope::string &modes = params[1]; - User *u2 = finduser(target); + User *u2 = User::Find(target, true); if (!u2) source.Reply(NICK_X_NOT_IN_USE, target.c_str()); else diff --git a/modules/commands/os_modinfo.cpp b/modules/commands/os_modinfo.cpp index 88748a106..15e2d73a2 100644 --- a/modules/commands/os_modinfo.cpp +++ b/modules/commands/os_modinfo.cpp @@ -29,12 +29,12 @@ class CommandOSModInfo : public Command Module *m = ModuleManager::FindModule(file); if (m) { - source.Reply(_("Module: \002%s\002 Version: \002%s\002 Author: \002%s\002 loaded: \002%s\002"), m->name.c_str(), !m->version.empty() ? m->version.c_str() : "?", !m->author.empty() ? m->author.c_str() : "?", do_strftime(m->created).c_str()); + source.Reply(_("Module: \002%s\002 Version: \002%s\002 Author: \002%s\002 loaded: \002%s\002"), m->name.c_str(), !m->version.empty() ? m->version.c_str() : "?", !m->author.empty() ? m->author.c_str() : "?", Anope::strftime(m->created).c_str()); std::vector<Anope::string> servicekeys = Service::GetServiceKeys("Command"); for (unsigned i = 0; i < servicekeys.size(); ++i) { - service_reference<Command> c("Command", servicekeys[i]); + ServiceReference<Command> c("Command", servicekeys[i]); if (!c || c->owner != m) continue; @@ -156,9 +156,11 @@ class CommandOSModList : public Command } } + Module *protocol = ModuleManager::FindFirstOf(PROTOCOL); + source.Reply(_("Current Module list:")); - for (std::list<Module *>::iterator it = Modules.begin(), it_end = Modules.end(); it != it_end; ++it) + for (std::list<Module *>::iterator it = ModuleManager::Modules.begin(), it_end = ModuleManager::Modules.end(); it != it_end; ++it) { Module *m = *it; @@ -179,6 +181,8 @@ class CommandOSModList : public Command } break; case PROTOCOL: + if (m != protocol) + break; if (showProto) { source.Reply(_("Module: \002%s\002 [%s] [%s]"), m->name.c_str(), m->version.c_str(), proto); diff --git a/modules/commands/os_module.cpp b/modules/commands/os_module.cpp index e7e0e2c16..75bc82af6 100644 --- a/modules/commands/os_module.cpp +++ b/modules/commands/os_module.cpp @@ -76,6 +76,13 @@ class CommandOSModReLoad : public Command return; } + Module *protocol = ModuleManager::FindFirstOf(PROTOCOL); + if (m->type == PROTOCOL && m != protocol) + { + source.Reply(_("You may not reload this module directly, instead reload %s."), protocol ? protocol->name.c_str() : "(unknown)"); + return; + } + /* Unrecoverable */ bool fatal = m->type == PROTOCOL; ModuleReturn status = ModuleManager::UnloadModule(m, source.GetUser()); @@ -96,8 +103,8 @@ class CommandOSModReLoad : public Command { if (fatal) { - quitmsg = "Unable to reload module " + mname; - quitting = true; + Anope::QuitReason = "Unable to reload module " + mname; + Anope::Quitting = true; } else source.Reply(_("Unable to load module \002%s\002"), mname.c_str()); diff --git a/modules/commands/os_news.cpp b/modules/commands/os_news.cpp index ba23c431d..eea480d13 100644 --- a/modules/commands/os_news.cpp +++ b/modules/commands/os_news.cpp @@ -72,7 +72,7 @@ class MyNewsService : public NewsService { for (unsigned i = 0; i < 3; ++i) for (unsigned j = 0; j < newsItems[i].size(); ++j) - newsItems[i][j]->destroy(); + newsItems[i][j]->Destroy(); } void AddNewsItem(NewsItem *n) @@ -86,7 +86,7 @@ class MyNewsService : public NewsService std::vector<NewsItem *>::iterator it = std::find(list.begin(), list.end(), n); if (it != list.end()) list.erase(it); - n->destroy(); + n->Destroy(); } std::vector<NewsItem *> &GetNewsList(NewsType t) @@ -106,7 +106,7 @@ static const char **findmsgs(NewsType type) class NewsBase : public Command { - service_reference<NewsService> ns; + ServiceReference<NewsService> ns; protected: void DoList(CommandSource &source, NewsType ntype, const char **msgs) @@ -117,16 +117,16 @@ class NewsBase : public Command else { ListFormatter lflist; - lflist.addColumn("Number").addColumn("Creator").addColumn("Created").addColumn("Text"); + lflist.AddColumn("Number").AddColumn("Creator").AddColumn("Created").AddColumn("Text"); for (unsigned i = 0, end = list.size(); i < end; ++i) { ListFormatter::ListEntry entry; entry["Number"] = stringify(i + 1); entry["Creator"] = list[i]->who; - entry["Created"] = do_strftime(list[i]->time); + entry["Created"] = Anope::strftime(list[i]->time); entry["Text"] = list[i]->text; - lflist.addEntry(entry); + lflist.AddEntry(entry); } source.Reply(msgs[MSG_LIST_HEADER]); @@ -151,7 +151,7 @@ class NewsBase : public Command this->OnSyntaxError(source, "ADD"); else { - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); NewsItem *news = new NewsItem(); @@ -181,7 +181,7 @@ class NewsBase : public Command source.Reply(msgs[MSG_LIST_NONE]); else { - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); if (!text.equals_ci("ALL")) { @@ -336,7 +336,7 @@ class CommandOSRandomNews : public NewsBase class OSNews : public Module { - SerializeType newsitem_type; + Serialize::Type newsitem_type; MyNewsService newsservice; CommandOSLogonNews commandoslogonnews; @@ -364,14 +364,14 @@ class OSNews : public Module if (Type == NEWS_RANDOM && i != cur_rand_news) continue; - const BotInfo *gl = findbot(Config->Global); + const BotInfo *gl = Global; if (!gl && !BotListByNick->empty()) gl = BotListByNick->begin()->second; - const BotInfo *os = findbot(Config->OperServ); + const BotInfo *os = OperServ; if (!os) os = gl; if (gl) - u->SendMessage(Type != NEWS_OPER ? gl : os, msg.c_str(), do_strftime(newsList[i]->time).c_str(), newsList[i]->text.c_str()); + u->SendMessage(Type != NEWS_OPER ? gl : os, msg.c_str(), Anope::strftime(newsList[i]->time).c_str(), newsList[i]->text.c_str()); ++displayed; @@ -391,7 +391,7 @@ class OSNews : public Module public: OSNews(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - newsitem_type("NewsItem", NewsItem::unserialize), newsservice(this), commandoslogonnews(this), commandosopernews(this), commandosrandomnews(this) + newsitem_type("NewsItem", NewsItem::Unserialize), newsservice(this), commandoslogonnews(this), commandosopernews(this), commandosrandomnews(this) { this->SetAuthor("Anope"); @@ -405,7 +405,7 @@ class OSNews : public Module DisplayNews(u, NEWS_OPER); } - void OnUserConnect(dynamic_reference<User> &user, bool &) anope_override + void OnUserConnect(Reference<User> &user, bool &) anope_override { if (!user || !user->server->IsSynced()) return; diff --git a/modules/commands/os_news.h b/modules/commands/os_news.h index 426121fb7..44525b963 100644 --- a/modules/commands/os_news.h +++ b/modules/commands/os_news.h @@ -23,8 +23,8 @@ struct NewsItem : Serializable time_t time; NewsItem() : Serializable("NewsItem") { } - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &data); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data); }; class NewsService : public Service @@ -39,9 +39,9 @@ class NewsService : public Service virtual std::vector<NewsItem *> &GetNewsList(NewsType t) = 0; }; -static service_reference<NewsService> news_service("NewsService", "news"); +static ServiceReference<NewsService> news_service("NewsService", "news"); -Serialize::Data NewsItem::serialize() const +Serialize::Data NewsItem::Serialize() const { Serialize::Data data; @@ -53,7 +53,7 @@ Serialize::Data NewsItem::serialize() const return data; } -Serializable* NewsItem::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* NewsItem::Unserialize(Serializable *obj, Serialize::Data &data) { if (!news_service) return NULL; diff --git a/modules/commands/os_noop.cpp b/modules/commands/os_noop.cpp index 826f1313a..fa9361f7b 100644 --- a/modules/commands/os_noop.cpp +++ b/modules/commands/os_noop.cpp @@ -36,7 +36,7 @@ class CommandOSNOOP : public Command else if (cmd.equals_ci("SET")) { /* Remove the O:lines */ - ircdproto->SendSVSNOOP(s, true); + IRCD->SendSVSNOOP(s, true); s->Extend("noop", new ExtensibleItemClass<Anope::string>(source.GetNick())); Log(LOG_ADMIN, source, this) << "SET on " << s->GetName(); @@ -56,7 +56,7 @@ class CommandOSNOOP : public Command else if (cmd.equals_ci("REVOKE")) { s->Shrink("noop"); - ircdproto->SendSVSNOOP(s, false); + IRCD->SendSVSNOOP(s, false); Log(LOG_ADMIN, source, this) << "REVOKE on " << s->GetName(); source.Reply(_("All O:lines of \002%s\002 have been reset."), s->GetName().c_str()); } diff --git a/modules/commands/os_oline.cpp b/modules/commands/os_oline.cpp index 3fe622c1c..7b8be5768 100644 --- a/modules/commands/os_oline.cpp +++ b/modules/commands/os_oline.cpp @@ -29,11 +29,11 @@ class CommandOSOLine : public Command User *u2 = NULL; /* let's check whether the user is online */ - if (!(u2 = finduser(nick))) + if (!(u2 = User::Find(nick, true))) source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); else if (u2 && flag[0] == '+') { - ircdproto->SendSVSO(source.service, nick, flag); + IRCD->SendSVSO(source.service, nick, flag); u2->SetMode(source.service, UMODE_OPER); u2->SendMessage(source.service, _("You are now an IRC Operator.")); source.Reply(_("Operflags \002%s\002 have been added for \002%s\002."), flag.c_str(), nick.c_str()); @@ -41,7 +41,7 @@ class CommandOSOLine : public Command } else if (u2 && flag[0] == '-') { - ircdproto->SendSVSO(source.service, nick, flag); + IRCD->SendSVSO(source.service, nick, flag); source.Reply(_("Operflags \002%s\002 have been added for \002%s\002."), flag.c_str(), nick.c_str()); Log(LOG_ADMIN, source, this) << "for " << nick; } @@ -72,7 +72,7 @@ class OSOLine : public Module { this->SetAuthor("Anope"); - if (!ircdproto || !ircdproto->CanSVSO) + if (!IRCD || !IRCD->CanSVSO) throw ModuleException("Your IRCd does not support OMODE."); } diff --git a/modules/commands/os_oper.cpp b/modules/commands/os_oper.cpp index e2e7b4ab3..882455898 100644 --- a/modules/commands/os_oper.cpp +++ b/modules/commands/os_oper.cpp @@ -17,7 +17,7 @@ struct MyOper : Oper, Serializable { MyOper(const Anope::string &n, OperType *o) : Oper(n, o), Serializable("Oper") { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data data; @@ -27,12 +27,12 @@ struct MyOper : Oper, Serializable return data; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { OperType *ot = OperType::Find(data["type"].astr()); if (ot == NULL) return NULL; - NickCore *nc = findcore(data["name"].astr()); + NickCore *nc = NickCore::Find(data["name"].astr()); if (nc == NULL) return NULL; @@ -68,7 +68,7 @@ class CommandOSOper : public Command const Anope::string &oper = params[1]; const Anope::string &otype = params[2]; - const NickAlias *na = findnick(oper); + const NickAlias *na = NickAlias::Find(oper); if (na == NULL) source.Reply(NICK_X_NOT_REGISTERED, oper.c_str()); else if (na->nc->o) @@ -91,7 +91,7 @@ class CommandOSOper : public Command { const Anope::string &oper = params[1]; - const NickAlias *na = findnick(oper); + const NickAlias *na = NickAlias::Find(oper); if (na == NULL) source.Reply(NICK_X_NOT_REGISTERED, oper.c_str()); else if (!na->nc || !na->nc->o) @@ -118,7 +118,7 @@ class CommandOSOper : public Command source.Reply(_("%-8s %s"), nc->o->name.c_str(), nc->o->ot->GetName().c_str()); if (nc->o->config) source.Reply(_(" This oper is configured in the configuration file.")); - for (std::list<User *>::const_iterator uit = nc->Users.begin(); uit != nc->Users.end(); ++uit) + for (std::list<User *>::const_iterator uit = nc->users.begin(); uit != nc->users.end(); ++uit) { User *u = *uit; source.Reply(_(" %s is online using this oper block."), u->nick.c_str()); @@ -202,12 +202,12 @@ class CommandOSOper : public Command class OSOper : public Module { - SerializeType myoper_type; + Serialize::Type myoper_type; CommandOSOper commandosoper; public: OSOper(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - myoper_type("Oper", MyOper::unserialize), commandosoper(this) + myoper_type("Oper", MyOper::Unserialize), commandosoper(this) { this->SetAuthor("Anope"); } diff --git a/modules/commands/os_session.cpp b/modules/commands/os_session.cpp index 2311b2ed2..27157d511 100644 --- a/modules/commands/os_session.cpp +++ b/modules/commands/os_session.cpp @@ -101,9 +101,9 @@ class ExpireTimer : public Timer if (!e->expires || e->expires > Anope::CurTime) continue; - Log(findbot(Config->OperServ), "expire/exception") << "Session exception for " << e->mask << "has expired."; + Log(OperServ, "expire/exception") << "Session exception for " << e->mask << "has expired."; session_service->DelException(e); - e->destroy(); + e->Destroy(); } } }; @@ -112,30 +112,30 @@ class ExceptionDelCallback : public NumberList { protected: CommandSource &source; - unsigned Deleted; + unsigned deleted; public: - ExceptionDelCallback(CommandSource &_source, const Anope::string &numlist) : NumberList(numlist, true), source(_source), Deleted(0) + ExceptionDelCallback(CommandSource &_source, const Anope::string &numlist) : NumberList(numlist, true), source(_source), deleted(0) { } ~ExceptionDelCallback() { - if (!Deleted) + if (!deleted) source.Reply(_("No matching entries on session-limit exception list.")); - else if (Deleted == 1) + else if (deleted == 1) source.Reply(_("Deleted 1 entry from session-limit exception list.")); else - source.Reply(_("Deleted %d entries from session-limit exception list."), Deleted); + source.Reply(_("Deleted %d entries from session-limit exception list."), deleted); } - virtual void HandleNumber(unsigned Number) anope_override + virtual void HandleNumber(unsigned number) anope_override { - if (!Number || Number > session_service->GetExceptions().size()) + if (!number || number > session_service->GetExceptions().size()) return; - ++Deleted; + ++deleted; - DoDel(source, Number - 1); + DoDel(source, number - 1); } static void DoDel(CommandSource &source, unsigned index) @@ -144,7 +144,7 @@ class ExceptionDelCallback : public NumberList FOREACH_MOD(I_OnExceptionDel, OnExceptionDel(source, e)); session_service->DelException(e); - e->destroy(); + e->Destroy(); } }; @@ -167,7 +167,7 @@ class CommandOSSession : public Command else { ListFormatter list; - list.addColumn("Session").addColumn("Host"); + list.AddColumn("Session").AddColumn("Host"); for (SessionService::SessionMap::iterator it = session_service->GetSessions().begin(), it_end = session_service->GetSessions().end(); it != it_end; ++it) { @@ -178,7 +178,7 @@ class CommandOSSession : public Command ListFormatter::ListEntry entry; entry["Session"] = stringify(session->count); entry["Host"] = session->addr.mask(); - list.addEntry(entry); + list.AddEntry(entry); } } @@ -296,7 +296,7 @@ class CommandOSException : public Command return; } - time_t expires = !expiry.empty() ? dotime(expiry) : Config->ExceptionExpiry; + time_t expires = !expiry.empty() ? Anope::DoTime(expiry) : Config->ExceptionExpiry; if (expires < 0) { source.Reply(BAD_EXPIRY_TIME); @@ -352,12 +352,12 @@ class CommandOSException : public Command EventReturn MOD_RESULT; FOREACH_RESULT(I_OnExceptionAdd, OnExceptionAdd(exception)); if (MOD_RESULT == EVENT_STOP) - exception->destroy(); + exception->Destroy(); else { session_service->AddException(exception); source.Reply(_("Session limit for \002%s\002 set to \002%d\002."), mask.c_str(), limit); - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); } } @@ -394,7 +394,7 @@ class CommandOSException : public Command source.Reply(_("\002%s\002 not found on session-limit exception list."), mask.c_str()); } - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); return; @@ -428,7 +428,7 @@ class CommandOSException : public Command source.Reply(_("Exception for \002%s\002 (#%d) moved to position \002%d\002."), session_service->GetExceptions()[n1]->mask.c_str(), n1 + 1, n2 + 1); - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); } else @@ -468,10 +468,10 @@ class CommandOSException : public Command entry["Number"] = stringify(Number); entry["Mask"] = e->mask; entry["By"] = e->who; - entry["Created"] = do_strftime(e->time); + entry["Created"] = Anope::strftime(e->time); entry["Limit"] = stringify(e->limit); entry["Reason"] = e->reason; - this->list.addEntry(entry); + this->list.AddEntry(entry); } } nl_list(list, mask); @@ -488,15 +488,15 @@ class CommandOSException : public Command entry["Number"] = stringify(i + 1); entry["Mask"] = e->mask; entry["By"] = e->who; - entry["Created"] = do_strftime(e->time); + entry["Created"] = Anope::strftime(e->time); entry["Limit"] = stringify(e->limit); entry["Reason"] = e->reason; - list.addEntry(entry); + list.AddEntry(entry); } } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on session-limit exception list.")); else { @@ -513,7 +513,7 @@ class CommandOSException : public Command void DoList(CommandSource &source, const std::vector<Anope::string> ¶ms) { ListFormatter list; - list.addColumn("Number").addColumn("Limit").addColumn("Mask"); + list.AddColumn("Number").AddColumn("Limit").AddColumn("Mask"); this->ProcessList(source, params, list); } @@ -521,7 +521,7 @@ class CommandOSException : public Command void DoView(CommandSource &source, const std::vector<Anope::string> ¶ms) { ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("By").addColumn("Created").addColumn("Limit").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("By").AddColumn("Created").AddColumn("Limit").AddColumn("Reason"); this->ProcessList(source, params, list); } @@ -604,12 +604,12 @@ class CommandOSException : public Command class OSSession : public Module { - SerializeType exception_type; + Serialize::Type exception_type; MySessionService ss; ExpireTimer expiretimer; CommandOSSession commandossession; CommandOSException commandosexception; - service_reference<XLineManager> akills; + ServiceReference<XLineManager> akills; void AddSession(User *u, bool exempt) { @@ -649,13 +649,12 @@ class OSSession : public Module if (kill && !exempt) { - const BotInfo *bi = findbot(Config->OperServ); - if (bi) + if (OperServ) { if (!Config->SessionLimitExceeded.empty()) - u->SendMessage(bi, Config->SessionLimitExceeded.c_str(), u->host.c_str()); + u->SendMessage(OperServ, Config->SessionLimitExceeded.c_str(), u->host.c_str()); if (!Config->SessionLimitDetailsLoc.empty()) - u->SendMessage(bi, "%s", Config->SessionLimitDetailsLoc.c_str()); + u->SendMessage(OperServ, "%s", Config->SessionLimitDetailsLoc.c_str()); } ++session->hits; @@ -665,7 +664,7 @@ class OSSession : public Module XLine *x = new XLine(akillmask, Config->OperServ, Anope::CurTime + Config->SessionAutoKillExpiry, "Session limit exceeded", XLineManager::GenerateUID()); akills->AddXLine(x); akills->Send(NULL, x); - Log(bi, "akill/session") << "Added a temporary AKILL for \2" << akillmask << "\2 due to excessive connections"; + Log(OperServ, "akill/session") << "Added a temporary AKILL for \2" << akillmask << "\2 due to excessive connections"; } else { @@ -694,8 +693,7 @@ class OSSession : public Module } if (!session) { - if (debug) - Log(this) << "Tried to delete non-existant session: " << u->host; + Log(LOG_DEBUG) << "Tried to delete non-existant session: " << u->host; return; } @@ -711,7 +709,7 @@ class OSSession : public Module public: OSSession(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - exception_type("Exception", Exception::unserialize), ss(this), commandossession(this), commandosexception(this), akills("XLineManager", "xlinemanager/sgline") + exception_type("Exception", Exception::Unserialize), ss(this), commandossession(this), commandosexception(this), akills("XLineManager", "xlinemanager/sgline") { this->SetAuthor("Anope"); @@ -720,7 +718,7 @@ class OSSession : public Module ModuleManager::SetPriority(this, PRIORITY_FIRST); } - void OnUserConnect(dynamic_reference<User> &user, bool &exempt) anope_override + void OnUserConnect(Reference<User> &user, bool &exempt) anope_override { if (user && Config->LimitSessions) this->AddSession(user, exempt); diff --git a/modules/commands/os_session.h b/modules/commands/os_session.h index 070975fd2..7304b21ae 100644 --- a/modules/commands/os_session.h +++ b/modules/commands/os_session.h @@ -20,8 +20,8 @@ struct Exception : Serializable time_t expires; /* Time when it expires. 0 == no expiry */ Exception() : Serializable("Exception") { } - Serialize::Data serialize() const anope_override; - static Serializable* unserialize(Serializable *obj, Serialize::Data &data); + Serialize::Data Serialize() const anope_override; + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data); }; class SessionService : public Service @@ -51,9 +51,9 @@ class SessionService : public Service virtual SessionMap &GetSessions() = 0; }; -static service_reference<SessionService> session_service("SessionService", "session"); +static ServiceReference<SessionService> session_service("SessionService", "session"); -Serialize::Data Exception::serialize() const +Serialize::Data Exception::Serialize() const { Serialize::Data data; @@ -67,7 +67,7 @@ Serialize::Data Exception::serialize() const return data; } -Serializable* Exception::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* Exception::Unserialize(Serializable *obj, Serialize::Data &data) { if (!session_service) return NULL; diff --git a/modules/commands/os_set.cpp b/modules/commands/os_set.cpp index a8a7e2e62..1592e7936 100644 --- a/modules/commands/os_set.cpp +++ b/modules/commands/os_set.cpp @@ -22,11 +22,11 @@ class CommandOSSet : public Command Anope::string index; - index = readonly ? _("%s is enabled") : _("%s is disabled"); + index = Anope::ReadOnly ? _("%s is enabled") : _("%s is disabled"); source.Reply(index.c_str(), "READONLY"); - index = debug ? _("%s is enabled") : _("%s is disabled"); + index = Anope::Debug ? _("%s is enabled") : _("%s is disabled"); source.Reply(index.c_str(), "DEBUG"); - index = noexpire ? _("%s is enabled") : _("%s is disabled"); + index = Anope::NoExpire ? _("%s is enabled") : _("%s is disabled"); source.Reply(index.c_str(), "NOEXPIRE"); return; @@ -44,13 +44,13 @@ class CommandOSSet : public Command if (setting.equals_ci("ON")) { - readonly = true; + Anope::ReadOnly = true; Log(LOG_ADMIN, source, this) << "READONLY ON"; source.Reply(_("Services are now in \002read-only\002 mode.")); } else if (setting.equals_ci("OFF")) { - readonly = false; + Anope::ReadOnly = false; Log(LOG_ADMIN, source, this) << "READONLY OFF"; source.Reply(_("Services are now in \002read-write\002 mode.")); } @@ -79,21 +79,21 @@ class CommandOSSet : public Command * Rob **/ if (!Config->SuperAdmin) - source.Reply(_("SuperAdmin setting not enabled in services.conf")); + source.Reply(_("Superadmin can not be set because it is not enabled in the configuration")); else if (setting.equals_ci("ON")) { - source.GetUser()->SuperAdmin = true; + source.GetUser()->super_admin = true; source.Reply(_("You are now a SuperAdmin")); Log(LOG_ADMIN, source, this) << "SUPERADMIN ON"; } else if (setting.equals_ci("OFF")) { - source.GetUser()->SuperAdmin = false; + source.GetUser()->super_admin = false; source.Reply(_("You are no longer a SuperAdmin")); Log(LOG_ADMIN, source, this) << "SUPERADMIN OFF"; } else - source.Reply(_("Setting for SuperAdmin must be \002on\002 or \002off\002 (must be enabled in services.conf)")); + source.Reply(_("Setting for SuperAdmin must be \002on\002 or \002off\002.")); return; } @@ -110,23 +110,23 @@ class CommandOSSet : public Command if (setting.equals_ci("ON")) { - debug = 1; + Anope::Debug = 1; Log(LOG_ADMIN, source, this) << "DEBUG ON"; source.Reply(_("Services are now in debug mode.")); } else if (setting.equals_ci("OFF") || setting == "0") { Log(LOG_ADMIN, source, this) << "DEBUG OFF"; - debug = 0; + Anope::Debug = 0; source.Reply(_("Services are now in non-debug mode.")); } else { try { - debug = convertTo<int>(setting); - Log(LOG_ADMIN, source, this) << "DEBUG " << debug; - source.Reply(_("Services are now in debug mode (level %d)."), debug); + Anope::Debug = convertTo<int>(setting); + Log(LOG_ADMIN, source, this) << "DEBUG " << Anope::Debug; + source.Reply(_("Services are now in debug mode (level %d)."), Anope::Debug); return; } catch (const ConvertException &) { } @@ -149,13 +149,13 @@ class CommandOSSet : public Command if (setting.equals_ci("ON")) { - noexpire = true; + Anope::NoExpire = true; Log(LOG_ADMIN, source, this) << "NOEXPIRE ON"; source.Reply(_("Services are now in \002no expire\002 mode.")); } else if (setting.equals_ci("OFF")) { - noexpire = false; + Anope::NoExpire = false; Log(LOG_ADMIN, source, this) << "NOEXPIRE OFF"; source.Reply(_("Services are now in \002expire\002 mode.")); } diff --git a/modules/commands/os_shutdown.cpp b/modules/commands/os_shutdown.cpp index 6edb3a64d..2f7827be3 100644 --- a/modules/commands/os_shutdown.cpp +++ b/modules/commands/os_shutdown.cpp @@ -24,8 +24,8 @@ class CommandOSQuit : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - quitmsg = source.command + " command received from " + source.GetNick(); - quitting = true; + Anope::QuitReason = source.command + " command received from " + source.GetNick(); + Anope::Quitting = true; return; } @@ -52,9 +52,9 @@ class CommandOSRestart : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - quitmsg = source.command + " command received from " + source.GetNick(); - quitting = restarting = true; - save_databases(); + Anope::QuitReason = source.command + " command received from " + source.GetNick(); + Anope::Quitting = Anope::Restarting = true; + Anope::SaveDatabases(); return; } @@ -78,9 +78,9 @@ class CommandOSShutdown : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - quitmsg = source.command + " command received from " + source.GetNick(); - quitting = true; - save_databases(); + Anope::QuitReason = source.command + " command received from " + source.GetNick(); + Anope::Quitting = true; + Anope::SaveDatabases(); return; } diff --git a/modules/commands/os_stats.cpp b/modules/commands/os_stats.cpp index 83f13a90a..bb029eed9 100644 --- a/modules/commands/os_stats.cpp +++ b/modules/commands/os_stats.cpp @@ -18,20 +18,20 @@ struct Stats : Serializable { Stats() : Serializable("Stats") { } - Serialize::Data serialize() const anope_override + Serialize::Data Serialize() const anope_override { Serialize::Data data; - data["maxusercnt"] << maxusercnt; - data["maxusertime"] << maxusertime; + data["maxusercnt"] << MaxUserCount; + data["maxusertime"] << MaxUserTime; return data; } - static Serializable* unserialize(Serializable *obj, Serialize::Data &data) + static Serializable* Unserialize(Serializable *obj, Serialize::Data &data) { - data["maxusercnt"] >> maxusercnt; - data["maxusertime"] >> maxusertime; + data["maxusercnt"] >> MaxUserCount; + data["maxusertime"] >> MaxUserTime; return NULL; } }; @@ -57,7 +57,7 @@ static int stats_count_servers(Server *s) class CommandOSStats : public Command { - service_reference<XLineManager> akills, snlines, sqlines; + ServiceReference<XLineManager> akills, snlines, sqlines; private: void DoStatsAkill(CommandSource &source) { @@ -82,7 +82,7 @@ class CommandOSStats : public Command else source.Reply(_("Default AKILL expiry time: \002No expiration\002")); } - if (ircdproto->CanSNLine && snlines) + if (IRCD->CanSNLine && snlines) { /* SNLINEs */ source.Reply(_("Current number of SNLINEs: \002%d\002"), snlines->GetCount()); @@ -102,7 +102,7 @@ class CommandOSStats : public Command else source.Reply(_("Default SNLINE expiry time: \002No expiration\002")); } - if (ircdproto->CanSQLine && sqlines) + if (IRCD->CanSQLine && sqlines) { /* SQLINEs */ source.Reply(_("Current number of SQLINEs: \002%d\002"), sqlines->GetCount()); @@ -127,17 +127,17 @@ class CommandOSStats : public Command void DoStatsReset(CommandSource &source) { - maxusercnt = usercnt; + MaxUserCount = UserListByNick.size(); source.Reply(_("Statistics reset.")); return; } void DoStatsUptime(CommandSource &source) { - time_t uptime = Anope::CurTime - start_time; - source.Reply(_("Current users: \002%d\002 (\002%d\002 ops)"), usercnt, opcnt); - source.Reply(_("Maximum users: \002%d\002 (%s)"), maxusercnt, do_strftime(maxusertime).c_str()); - source.Reply(_("Services up %s"), duration(uptime).c_str()); + time_t uptime = Anope::CurTime - Anope::StartTime; + source.Reply(_("Current users: \002%d\002 (\002%d\002 ops)"), UserListByNick.size(), OperCount); + source.Reply(_("Maximum users: \002%d\002 (%s)"), MaxUserCount, Anope::strftime(MaxUserTime).c_str()); + source.Reply(_("Services up %s"), Anope::Duration(uptime).c_str()); return; } @@ -145,7 +145,7 @@ class CommandOSStats : public Command void DoStatsUplink(CommandSource &source) { Anope::string buf; - for (std::set<Anope::string>::iterator it = Capab.begin(); it != Capab.end(); ++it) + for (std::set<Anope::string>::iterator it = Servers::Capab.begin(); it != Servers::Capab.end(); ++it) buf += " " + *it; if (!buf.empty()) buf.erase(buf.begin()); @@ -255,12 +255,12 @@ class CommandOSStats : public Command class OSStats : public Module { CommandOSStats commandosstats; - SerializeType stats_type; + Serialize::Type stats_type; Stats stats_saver; public: OSStats(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, CORE), - commandosstats(this), stats_type("Stats", Stats::unserialize) + commandosstats(this), stats_type("Stats", Stats::Unserialize) { this->SetAuthor("Anope"); diff --git a/modules/commands/os_svsnick.cpp b/modules/commands/os_svsnick.cpp index 4c6329acb..e08d5d3aa 100644 --- a/modules/commands/os_svsnick.cpp +++ b/modules/commands/os_svsnick.cpp @@ -36,28 +36,22 @@ class CommandOSSVSNick : public Command } /* Check for valid characters */ - if (newnick[0] == '-' || isdigit(newnick[0])) + if (!IRCD->IsNickValid(newnick)) { source.Reply(_("Nick \002%s\002 is an illegal nickname and cannot be used."), newnick.c_str()); return; } - for (unsigned i = 0, end = newnick.length(); i < end; ++i) - if (!isvalidnick(newnick[i])) - { - source.Reply(_("Nick \002%s\002 is an illegal nickname and cannot be used."), newnick.c_str()); - return; - } /* Check for a nick in use or a forbidden/suspended nick */ - if (!(u2 = finduser(nick))) + if (!(u2 = User::Find(nick, true))) source.Reply(NICK_X_NOT_IN_USE, nick.c_str()); - else if (!nick.equals_ci(newnick) && finduser(newnick)) + else if (!nick.equals_ci(newnick) && User::Find(newnick)) source.Reply(_("Nick \002%s\002 is currently in use."), newnick.c_str()); else { source.Reply(_("The nick \002%s\002 is now being changed to \002%s\002."), nick.c_str(), newnick.c_str()); Log(LOG_ADMIN, source, this) << "to change " << nick << " to " << newnick; - ircdproto->SendForceNickChange(u2, newnick, Anope::CurTime); + IRCD->SendForceNickChange(u2, newnick, Anope::CurTime); } return; } @@ -81,7 +75,7 @@ class OSSVSNick : public Module { this->SetAuthor("Anope"); - if (!ircdproto || !ircdproto->CanSVSNick) + if (!IRCD || !IRCD->CanSVSNick) throw ModuleException("Your IRCd does not support SVSNICK"); } diff --git a/modules/commands/os_sxline.cpp b/modules/commands/os_sxline.cpp index 9261bcddd..7f48a2645 100644 --- a/modules/commands/os_sxline.cpp +++ b/modules/commands/os_sxline.cpp @@ -18,33 +18,33 @@ class SXLineDelCallback : public NumberList XLineManager *xlm; Command *command; CommandSource &source; - unsigned Deleted; + unsigned deleted; public: - SXLineDelCallback(XLineManager *x, Command *c, CommandSource &_source, const Anope::string &numlist) : NumberList(numlist, true), xlm(x), command(c), source(_source), Deleted(0) + SXLineDelCallback(XLineManager *x, Command *c, CommandSource &_source, const Anope::string &numlist) : NumberList(numlist, true), xlm(x), command(c), source(_source), deleted(0) { } ~SXLineDelCallback() { - if (!Deleted) + if (!deleted) source.Reply(_("No matching entries on the %s list."), this->command->name.c_str()); - else if (Deleted == 1) + else if (deleted == 1) source.Reply(_("Deleted 1 entry from the %s list."), this->command->name.c_str()); else - source.Reply(_("Deleted %d entries from the %s list."), Deleted, this->command->name.c_str()); + source.Reply(_("Deleted %d entries from the %s list."), deleted, this->command->name.c_str()); } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number) + if (!number) return; - XLine *x = this->xlm->GetEntry(Number - 1); + XLine *x = this->xlm->GetEntry(number - 1); if (!x) return; - ++Deleted; + ++deleted; DoDel(this->xlm, source, x); } @@ -99,7 +99,7 @@ class CommandOSSXLineBase : public Command source.Reply(_("\002%s\002 deleted from the %s list."), mask.c_str(), source.command.c_str()); } - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); return; @@ -126,24 +126,24 @@ class CommandOSSXLineBase : public Command { } - void HandleNumber(unsigned Number) anope_override + void HandleNumber(unsigned number) anope_override { - if (!Number) + if (!number) return; - const XLine *x = this->xlm->GetEntry(Number - 1); + const XLine *x = this->xlm->GetEntry(number - 1); if (!x) return; ListFormatter::ListEntry entry; - entry["Number"] = stringify(Number); - entry["Mask"] = x->Mask; - entry["By"] = x->By; - entry["Created"] = do_strftime(x->Created, NULL, true); - entry["Expires"] = expire_left(NULL, x->Expires); - entry["Reason"] = x->Reason; - list.addEntry(entry); + entry["Number"] = stringify(number); + entry["Mask"] = x->mask; + entry["By"] = x->by; + entry["Created"] = Anope::strftime(x->created, NULL, true); + entry["Expires"] = Anope::Expires(x->expires); + entry["Reason"] = x->reason; + list.AddEntry(entry); } } sl_list(this->xlm(), list, mask); @@ -155,21 +155,21 @@ class CommandOSSXLineBase : public Command { const XLine *x = this->xlm()->GetEntry(i); - if (mask.empty() || mask.equals_ci(x->Mask) || mask == x->UID || Anope::Match(x->Mask, mask, false, true)) + if (mask.empty() || mask.equals_ci(x->mask) || mask == x->id || Anope::Match(x->mask, mask, false, true)) { ListFormatter::ListEntry entry; entry["Number"] = stringify(i + 1); - entry["Mask"] = x->Mask; - entry["By"] = x->By; - entry["Created"] = do_strftime(x->Created, NULL, true); - entry["Expires"] = expire_left(source.nc, x->Expires); - entry["Reason"] = x->Reason; - list.addEntry(entry); + entry["Mask"] = x->mask; + entry["By"] = x->by; + entry["Created"] = Anope::strftime(x->created, NULL, true); + entry["Expires"] = Anope::Expires(x->expires, source.nc); + entry["Reason"] = x->reason; + list.AddEntry(entry); } } } - if (list.isEmpty()) + if (list.IsEmpty()) source.Reply(_("No matching entries on the %s list."), source.command.c_str()); else { @@ -186,7 +186,7 @@ class CommandOSSXLineBase : public Command void OnList(CommandSource &source, const std::vector<Anope::string> ¶ms) { ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("Reason"); this->ProcessList(source, params, list); } @@ -194,7 +194,7 @@ class CommandOSSXLineBase : public Command void OnView(CommandSource &source, const std::vector<Anope::string> ¶ms) { ListFormatter list; - list.addColumn("Number").addColumn("Mask").addColumn("By").addColumn("Created").addColumn("Expires").addColumn("Reason"); + list.AddColumn("Number").AddColumn("Mask").AddColumn("By").AddColumn("Created").AddColumn("Expires").AddColumn("Reason"); this->ProcessList(source, params, list); } @@ -250,7 +250,7 @@ class CommandOSSNLine : public CommandOSSXLineBase void OnAdd(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!this->xlm() || !ircdproto->CanSNLine) + if (!this->xlm() || !IRCD->CanSNLine) { source.Reply(_("Your IRCd does not support SNLINE")); return; @@ -268,7 +268,7 @@ class CommandOSSNLine : public CommandOSSXLineBase last_param = 3; } - expires = !expiry.empty() ? dotime(expiry) : Config->SNLineExpiry; + expires = !expiry.empty() ? Anope::DoTime(expiry) : Config->SNLineExpiry; /* If the expiry given does not contain a final letter, it's in days, * said the doc. Ah well. */ @@ -318,7 +318,7 @@ class CommandOSSNLine : public CommandOSSXLineBase return; } - service_reference<RegexProvider> provider("Regex", Config->RegexEngine); + ServiceReference<RegexProvider> provider("Regex", Config->RegexEngine); if (!provider) { source.Reply(_("Unable to find regex engine %s"), Config->RegexEngine.c_str()); @@ -354,7 +354,7 @@ class CommandOSSNLine : public CommandOSSXLineBase XLine *x = new XLine(mask, source.GetNick(), expires, reason); if (Config->AkillIds) - x->UID = XLineManager::GenerateUID(); + x->id = XLineManager::GenerateUID(); unsigned int affected = 0; for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) @@ -366,7 +366,7 @@ class CommandOSSNLine : public CommandOSSXLineBase { source.Reply(USERHOST_MASK_TOO_WIDE, mask.c_str()); Log(LOG_ADMIN, source, this) << "tried to " << source.command << " " << percent << "% of the network (" << affected << " users)"; - x->destroy(); + x->Destroy(); return; } @@ -374,7 +374,7 @@ class CommandOSSNLine : public CommandOSSXLineBase FOREACH_RESULT(I_OnAddXLine, OnAddXLine(source, x, this->xlm())); if (MOD_RESULT == EVENT_STOP) { - x->destroy(); + x->Destroy(); return; } @@ -391,18 +391,18 @@ class CommandOSSNLine : public CommandOSSXLineBase User *user = it->second; ++it; - if (!user->HasMode(UMODE_OPER) && user->server != Me && Anope::Match(user->realname, x->Mask, false, true)) + if (!user->HasMode(UMODE_OPER) && user->server != Me && Anope::Match(user->realname, x->mask, false, true)) user->Kill(Config->ServerName, rreason); } } source.Reply(_("\002%s\002 added to the %s list."), mask.c_str(), source.command.c_str()); - Log(LOG_ADMIN, source, this) << "on " << mask << " (" << reason << ") expires in " << (expires ? duration(expires - Anope::CurTime) : "never") << " [affects " << affected << " user(s) (" << percent << "%)]"; - if (readonly) + Log(LOG_ADMIN, source, this) << "on " << mask << " (" << reason << ") expires in " << (expires ? Anope::Duration(expires - Anope::CurTime) : "never") << " [affects " << affected << " user(s) (" << percent << "%)]"; + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); } - service_reference<XLineManager> snlines; + ServiceReference<XLineManager> snlines; public: CommandOSSNLine(Module *creator) : CommandOSSXLineBase(creator, "operserv/snline"), snlines("XLineManager", "xlinemanager/snline") { @@ -471,7 +471,7 @@ class CommandOSSQLine : public CommandOSSXLineBase void OnAdd(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (!this->xlm() || !ircdproto->CanSQLine) + if (!this->xlm() || !IRCD->CanSQLine) { source.Reply(_("Your IRCd does not support SQLINE")); return; @@ -489,7 +489,7 @@ class CommandOSSQLine : public CommandOSSXLineBase last_param = 3; } - expires = !expiry.empty() ? dotime(expiry) : Config->SQLineExpiry; + expires = !expiry.empty() ? Anope::DoTime(expiry) : Config->SQLineExpiry; /* If the expiry given does not contain a final letter, it's in days, * said the doc. Ah well. */ @@ -528,7 +528,7 @@ class CommandOSSQLine : public CommandOSSXLineBase return; } - service_reference<RegexProvider> provider("Regex", Config->RegexEngine); + ServiceReference<RegexProvider> provider("Regex", Config->RegexEngine); if (!provider) { source.Reply(_("Unable to find regex engine %s"), Config->RegexEngine.c_str()); @@ -557,7 +557,7 @@ class CommandOSSQLine : public CommandOSSXLineBase XLine *x = new XLine(mask, source.GetNick(), expires, reason); if (Config->AkillIds) - x->UID = XLineManager::GenerateUID(); + x->id = XLineManager::GenerateUID(); unsigned int affected = 0; for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) @@ -569,7 +569,7 @@ class CommandOSSQLine : public CommandOSSXLineBase { source.Reply(USERHOST_MASK_TOO_WIDE, mask.c_str()); Log(LOG_ADMIN, source, this) << "tried to SQLine " << percent << "% of the network (" << affected << " users)"; - x->destroy(); + x->Destroy(); return; } @@ -577,7 +577,7 @@ class CommandOSSQLine : public CommandOSSXLineBase FOREACH_RESULT(I_OnAddXLine, OnAddXLine(source, x, this->xlm())); if (MOD_RESULT == EVENT_STOP) { - x->destroy(); + x->Destroy(); return; } @@ -616,7 +616,7 @@ class CommandOSSQLine : public CommandOSSXLineBase User *user = it->second; ++it; - if (!user->HasMode(UMODE_OPER) && user->server != Me && Anope::Match(user->nick, x->Mask, false, true)) + if (!user->HasMode(UMODE_OPER) && user->server != Me && Anope::Match(user->nick, x->mask, false, true)) user->Kill(Config->ServerName, rreason); } } @@ -625,13 +625,13 @@ class CommandOSSQLine : public CommandOSSXLineBase } source.Reply(_("\002%s\002 added to the SQLINE list."), mask.c_str()); - Log(LOG_ADMIN, source, this) << "on " << mask << " (" << reason << ") expires in " << (expires ? duration(expires - Anope::CurTime) : "never") << " [affects " << affected << " user(s) (" << percent << "%)]"; + Log(LOG_ADMIN, source, this) << "on " << mask << " (" << reason << ") expires in " << (expires ? Anope::Duration(expires - Anope::CurTime) : "never") << " [affects " << affected << " user(s) (" << percent << "%)]"; - if (readonly) + if (Anope::ReadOnly) source.Reply(READ_ONLY_MODE); } - service_reference<XLineManager> sqlines; + ServiceReference<XLineManager> sqlines; public: CommandOSSQLine(Module *creator) : CommandOSSXLineBase(creator, "operserv/sqline"), sqlines("XLineManager", "xlinemanager/sqline") { diff --git a/modules/commands/os_update.cpp b/modules/commands/os_update.cpp index b9b43230f..7bea34aaf 100644 --- a/modules/commands/os_update.cpp +++ b/modules/commands/os_update.cpp @@ -25,7 +25,7 @@ class CommandOSUpdate : public Command void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override { source.Reply(_("Updating databases.")); - save_databases(); + Anope::SaveDatabases(); return; } diff --git a/modules/database/db_flatfile.cpp b/modules/database/db_flatfile.cpp index 2b31c8a81..acb287cee 100644 --- a/modules/database/db_flatfile.cpp +++ b/modules/database/db_flatfile.cpp @@ -37,7 +37,7 @@ class DBFlatFile : public Module void BackupDatabase() { /* Do not backup a database that doesn't exist */ - if (!IsFile(DatabaseFile)) + if (!Anope::IsFile(DatabaseFile)) return; time_t now = Anope::CurTime; @@ -58,7 +58,7 @@ class DBFlatFile : public Module Log(this) << "Unable to back up database!"; if (!Config->NoBackupOkay) - quitting = true; + Anope::Quitting = true; return; } @@ -76,8 +76,8 @@ class DBFlatFile : public Module void OnReload() anope_override { ConfigReader config; - DatabaseFile = db_dir + "/" + config.ReadValue("db_flatfile", "database", "anope.db", 0); - BackupFile = db_dir + "/backups/" + config.ReadValue("db_flatfile", "database", "anope.db", 0); + DatabaseFile = Anope::DataDir + "/" + config.ReadValue("db_flatfile", "database", "anope.db", 0); + BackupFile = Anope::DataDir + "/backups/" + config.ReadValue("db_flatfile", "database", "anope.db", 0); } EventReturn OnLoadDatabase() anope_override @@ -92,23 +92,23 @@ class DBFlatFile : public Module return EVENT_CONTINUE; } - const std::vector<Anope::string> type_order = SerializeType::GetTypeOrder(); + const std::vector<Anope::string> type_order = Serialize::Type::GetTypeOrder(); for (unsigned i = 0; i < type_order.size(); ++i) { - SerializeType *stype = SerializeType::Find(type_order[i]); + Serialize::Type *stype = Serialize::Type::Find(type_order[i]); if (stype && !databases.count(stype->GetOwner())) { - Anope::string db_name = db_dir + "/module_" + stype->GetOwner()->name + ".db"; + Anope::string db_name = Anope::DataDir + "/module_" + stype->GetOwner()->name + ".db"; databases[stype->GetOwner()] = new std::fstream(db_name.c_str(), std::ios_base::in); } } - std::multimap<SerializeType *, Serialize::Data> objects; + std::multimap<Serialize::Type *, Serialize::Data> objects; for (std::map<Module *, std::fstream *>::iterator it = databases.begin(), it_end = databases.end(); it != it_end; ++it) { std::fstream *db = it->second; - SerializeType *st = NULL; + Serialize::Type *st = NULL; Serialize::Data data; for (Anope::string buf, token; std::getline(*db, buf.str());) { @@ -119,7 +119,7 @@ class DBFlatFile : public Module if (token == "OBJECT" && sep.GetToken(token)) { - st = SerializeType::Find(token); + st = Serialize::Type::Find(token); data.clear(); } else if (token == "DATA" && st != NULL && sep.GetToken(token)) @@ -136,9 +136,9 @@ class DBFlatFile : public Module for (unsigned i = 0; i < type_order.size(); ++i) { - SerializeType *stype = SerializeType::Find(type_order[i]); + Serialize::Type *stype = Serialize::Type::Find(type_order[i]); - std::multimap<SerializeType *, Serialize::Data>::iterator it = objects.find(stype), it_end = objects.upper_bound(stype); + std::multimap<Serialize::Type *, Serialize::Data>::iterator it = objects.find(stype), it_end = objects.upper_bound(stype); if (it == objects.end()) continue; for (; it != it_end; ++it) @@ -178,16 +178,16 @@ class DBFlatFile : public Module for (std::list<Serializable *>::const_iterator it = items.begin(), it_end = items.end(); it != it_end; ++it) { Serializable *base = *it; - SerializeType *s_type = base->GetSerializableType(); + Serialize::Type *s_type = base->GetSerializableType(); if (!s_type) continue; - Serialize::Data data = base->serialize(); + Serialize::Data data = base->Serialize(); if (!databases.count(s_type->GetOwner())) { - Anope::string db_name = db_dir + "/module_" + s_type->GetOwner()->name + ".db"; + Anope::string db_name = Anope::DataDir + "/module_" + s_type->GetOwner()->name + ".db"; databases[s_type->GetOwner()] = new std::fstream(db_name.c_str(), std::ios_base::out | std::ios_base::trunc); } std::fstream *fd = databases[s_type->GetOwner()]; @@ -203,7 +203,7 @@ class DBFlatFile : public Module Log(this) << "Unable to write database"; databases[NULL]->close(); if (!Config->NoBackupOkay) - quitting = true; + Anope::Quitting = true; if (IsFile(tmp_db)) rename(tmp_db.c_str(), DatabaseFile.c_str()); } diff --git a/modules/database/db_old.cpp b/modules/database/db_old.cpp index f09fb2aab..ea899edd6 100644 --- a/modules/database/db_old.cpp +++ b/modules/database/db_old.cpp @@ -309,7 +309,7 @@ static dbFILE *open_db_read(const char *service, const char *filename, int versi int myversion; f = new dbFILE; - strscpy(f->filename, (db_dir + "/" + filename).c_str(), sizeof(f->filename)); + strscpy(f->filename, (Anope::DataDir + "/" + filename).c_str(), sizeof(f->filename)); f->mode = 'r'; fp = fopen(f->filename, "rb"); if (!fp) @@ -595,7 +595,7 @@ static void LoadNicks() Anope::string core; READ(read_string(core, f)); - NickCore *nc = findcore(core); + NickCore *nc = NickCore::Find(core); if (nc == NULL) { Log() << "Skipping coreless nick " << nick << " with core " << core; @@ -634,7 +634,7 @@ static void LoadVHosts() READ(read_string(creator, f)); READ(read_int32(&vtime, f)); - NickAlias *na = findnick(nick); + NickAlias *na = NickAlias::Find(nick); if (na == NULL) { Log() << "Removing vhost for nonexistant nick " << nick; @@ -669,7 +669,7 @@ static void LoadBots() READ(read_int32(&created, f)); READ(read_int16(&chancount, f)); - BotInfo *bi = findbot(nick); + BotInfo *bi = BotInfo::Find(nick); if (!bi) bi = new BotInfo(nick, user, host, real); bi->created = created; @@ -698,10 +698,10 @@ static void LoadChannels() ChannelInfo *ci = new ChannelInfo(namebuf); READ(read_string(buffer, f)); - ci->SetFounder(findcore(buffer)); + ci->SetFounder(NickCore::Find(buffer)); READ(read_string(buffer, f)); - ci->successor = findcore(buffer); + ci->successor = NickCore::Find(buffer); char pwbuf[32]; READ(read_buffer(pwbuf, f)); @@ -777,7 +777,7 @@ static void LoadChannels() ci->SetLevel(GetLevelName(j), level); } - service_reference<AccessProvider> provider("AccessProvider", "access/access"); + ServiceReference<AccessProvider> provider("AccessProvider", "access/access"); uint16_t tmpu16; READ(read_uint16(&tmpu16, f)); for (uint16_t j = 0; j < tmpu16; ++j) @@ -793,7 +793,7 @@ static void LoadChannels() int16_t level; READ(read_int16(&level, f)); if (access) - access->Unserialize(stringify(level)); + access->AccessUnserialize(stringify(level)); Anope::string mask; READ(read_string(mask, f)); @@ -858,7 +858,7 @@ static void LoadChannels() READ(read_string(buffer, f)); READ(read_string(buffer, f)); - ci->bi = findbot(buffer); + ci->bi = BotInfo::Find(buffer); READ(read_int32(&tmp32, f)); if (tmp32 & OLD_BS_DONTKICKOPS) @@ -981,7 +981,7 @@ static void LoadOper() continue; XLine *x = new XLine(user + "@" + host, by, expires, reason, XLineManager::GenerateUID()); - x->Created = seton; + x->created = seton; akill->AddXLine(x); } @@ -1001,7 +1001,7 @@ static void LoadOper() continue; XLine *x = new XLine(mask, by, expires, reason, XLineManager::GenerateUID()); - x->Created = seton; + x->created = seton; snline->AddXLine(x); } @@ -1021,7 +1021,7 @@ static void LoadOper() continue; XLine *x = new XLine(mask, by, expires, reason, XLineManager::GenerateUID()); - x->Created = seton; + x->created = seton; sqline->AddXLine(x); } @@ -1041,7 +1041,7 @@ static void LoadOper() continue; XLine *x = new XLine(mask, by, expires, reason, XLineManager::GenerateUID()); - x->Created = seton; + x->created = seton; szline->AddXLine(x); } diff --git a/modules/database/db_plain.cpp b/modules/database/db_plain.cpp index e6d430556..f23cf4e4a 100644 --- a/modules/database/db_plain.cpp +++ b/modules/database/db_plain.cpp @@ -139,9 +139,9 @@ EventReturn OnDatabaseReadMetadata(ChannelInfo *ci, const Anope::string &key, co else if (key.equals_ci("MEMOMAX")) ci->memos.memomax = params[0].is_pos_number_only() ? convertTo<int16_t>(params[0]) : -1; else if (key.equals_ci("FOUNDER")) - ci->SetFounder(findcore(params[0])); + ci->SetFounder(NickCore::Find(params[0])); else if (key.equals_ci("SUCCESSOR")) - ci->successor = findcore(params[0]); + ci->successor = NickCore::Find(params[0]); else if (key.equals_ci("LEVELS")) { for (unsigned j = 0, end = params.size(); j < end; j += 2) @@ -169,14 +169,14 @@ EventReturn OnDatabaseReadMetadata(ChannelInfo *ci, const Anope::string &key, co } else if (key.equals_ci("ACCESS")) // Older access system, from Anope 1.9.4. { - service_reference<AccessProvider> provider("AccessProvider", "access/access"); + ServiceReference<AccessProvider> provider("AccessProvider", "access/access"); if (!provider) throw DatabaseException("Old access entry for nonexistant provider"); ChanAccess *access = const_cast<ChanAccess *>(provider->Create()); access->ci = ci; access->mask = params[0]; - access->Unserialize(params[1]); + access->AccessUnserialize(params[1]); access->last_seen = params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0; access->creator = params[3]; access->created = Anope::CurTime; @@ -185,14 +185,14 @@ EventReturn OnDatabaseReadMetadata(ChannelInfo *ci, const Anope::string &key, co } else if (key.equals_ci("ACCESS2")) { - service_reference<AccessProvider> provider("AccessProvider", params[0]); + ServiceReference<AccessProvider> provider("AccessProvider", params[0]); if (!provider) throw DatabaseException("Access entry for nonexistant provider " + params[0]); ChanAccess *access = const_cast<ChanAccess *>(provider->Create()); access->ci = ci; access->mask = params[1]; - access->Unserialize(params[2]); + access->AccessUnserialize(params[2]); access->last_seen = params[3].is_pos_number_only() ? convertTo<time_t>(params[3]) : 0; access->creator = params[4]; access->created = params.size() > 5 && params[5].is_pos_number_only() ? convertTo<time_t>(params[5]) : Anope::CurTime; @@ -206,7 +206,7 @@ EventReturn OnDatabaseReadMetadata(ChannelInfo *ci, const Anope::string &key, co NickCore *nc = NULL; if (Nick) { - nc = findcore(params[2]); + nc = NickCore::Find(params[2]); if (!nc) throw DatabaseException("Akick for nonexistant core " + params[2] + " on " + ci->name); } @@ -242,6 +242,7 @@ EventReturn OnDatabaseReadMetadata(ChannelInfo *ci, const Anope::string &key, co Anope::string setter = params[2]; time_t mcreated = params[3].is_pos_number_only() ? convertTo<time_t>(params[3]) : Anope::CurTime; Anope::string param = params.size() > 4 ? params[4] : ""; + const Anope::string* ChannelModeNameStrings = Flags<ChannelModeName>::GetFlagStrings(); for (size_t i = CMODE_BEGIN + 1; i < CMODE_END; ++i) if (ChannelModeNameStrings[i] == mode_name) { @@ -270,7 +271,7 @@ EventReturn OnDatabaseReadMetadata(ChannelInfo *ci, const Anope::string &key, co else if (key.equals_ci("BI")) { if (params[0].equals_ci("NAME")) - ci->bi = findbot(params[1]); + ci->bi = BotInfo::Find(params[1]); else if (params[0].equals_ci("FLAGS")) ci->botflags.FromVector(params); else if (params[0].equals_ci("TTB")) @@ -396,22 +397,22 @@ static void ReadDatabase(Module *m = NULL) { if (params[0].equals_ci("NC")) { - nc = findcore(params[1]); + nc = NickCore::Find(params[1]); Type = MD_NC; } else if (params[0].equals_ci("NA")) { - na = findnick(params[2]); + na = NickAlias::Find(params[2]); Type = MD_NA; } else if (params[0].equals_ci("BI")) { - bi = findbot(params[1]); + bi = BotInfo::Find(params[1]); Type = MD_BI; } else if (params[0].equals_ci("CH")) { - ci = cs_findchan(params[1]); + ci = ChannelInfo::Find(params[1]); Type = MD_CH; } else if (params[0].equals_ci("MD")) @@ -484,7 +485,7 @@ static void LoadNickCore(const std::vector<Anope::string> ¶ms) static void LoadNickAlias(const std::vector<Anope::string> ¶ms) { - NickCore *nc = findcore(params[0]); + NickCore *nc = NickCore::Find(params[0]); if (!nc) { Log() << "[db_plain]: Unable to find core " << params[0]; @@ -502,7 +503,7 @@ static void LoadNickAlias(const std::vector<Anope::string> ¶ms) static void LoadBotInfo(const std::vector<Anope::string> ¶ms) { - BotInfo *bi = findbot(params[0]); + BotInfo *bi = BotInfo::Find(params[0]); if (!bi) bi = new BotInfo(params[0], params[1], params[2]); @@ -533,8 +534,8 @@ static void LoadOperInfo(const std::vector<Anope::string> ¶ms) { if (params[0].equals_ci("STATS")) { - maxusercnt = params[1].is_pos_number_only() ? convertTo<uint32_t>(params[1]) : 0; - maxusertime = params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0; + MaxUserCount = params[1].is_pos_number_only() ? convertTo<uint32_t>(params[1]) : 0; + MaxUserTime = params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0; } else if (params[0].equals_ci("SXLINE")) { @@ -551,7 +552,7 @@ static void LoadOperInfo(const std::vector<Anope::string> ¶ms) Anope::string reason = params[7]; XLine *x = new XLine(mask, by, expires, reason, XLineManager::GenerateUID()); - x->Created = seton; + x->created = seton; xl->AddXLine(x); break; } @@ -627,7 +628,7 @@ class DBPlain : public Module Log() << "Unable to back up database!"; if (!Config->NoBackupOkay) - quitting = true; + Anope::Quitting = true; return; } @@ -646,8 +647,8 @@ class DBPlain : public Module void OnReload() anope_override { ConfigReader config; - DatabaseFile = db_dir + "/" + config.ReadValue("db_plain", "database", "anope.db", 0); - BackupFile = db_dir + "/backups/" + config.ReadValue("db_plain", "database", "anope.db", 0); + DatabaseFile = Anope::DataDir + "/" + config.ReadValue("db_plain", "database", "anope.db", 0); + BackupFile = Anope::DataDir + "/backups/" + config.ReadValue("db_plain", "database", "anope.db", 0); } EventReturn OnLoadDatabase() anope_override @@ -777,7 +778,7 @@ class DBPlain : public Module for (unsigned k = 0, end = ci->GetAccessCount(); k < end; ++k) { const ChanAccess *access = ci->GetAccess(k); - db_buffer << "MD ACCESS2 " << access->provider->name << " " << access->mask << " " << access->Serialize() << " " << access->last_seen << " " << access->creator << " " << access->created << endl; + db_buffer << "MD ACCESS2 " << access->provider->name << " " << access->mask << " " << access->AccessSerialize() << " " << access->last_seen << " " << access->creator << " " << access->created << endl; } for (unsigned k = 0, end = ci->GetAkickCount(); k < end; ++k) { @@ -835,7 +836,7 @@ class DBPlain : public Module //FOREACH_MOD(I_OnDatabaseWriteMetadata, OnDatabaseWriteMetadata(WriteMetadata, ci)); } - db_buffer << "OS STATS " << maxusercnt << " " << maxusertime << endl; + db_buffer << "OS STATS " << MaxUserCount << " " << MaxUserTime << endl; for (std::list<XLineManager *>::iterator it = XLineManager::XLineManagers.begin(), it_end = XLineManager::XLineManagers.end(); it != it_end; ++it) { @@ -843,7 +844,7 @@ class DBPlain : public Module for (unsigned i = 0, end = xl->GetCount(); i < end; ++i) { const XLine *x = xl->GetEntry(i); - db_buffer << "OS SXLINE " << xl->Type() << " " << x->GetUser() << " " << x->GetHost() << " " << x->By << " " << x->Created << " " << x->Expires << " :" << x->Reason << endl; + db_buffer << "OS SXLINE " << xl->Type() << " " << x->GetUser() << " " << x->GetHost() << " " << x->by << " " << x->created << " " << x->expires << " :" << x->reason << endl; } } @@ -861,7 +862,7 @@ class DBPlain : public Module if (!db.is_open()) { - ircdproto->SendGlobops(NULL, "Unable to open %s for writing!", DatabaseFile.c_str()); + IRCD->SendGlobops(NULL, "Unable to open %s for writing!", DatabaseFile.c_str()); return EVENT_CONTINUE; } diff --git a/modules/database/db_sql.cpp b/modules/database/db_sql.cpp index 48c813a3c..60db11c0d 100644 --- a/modules/database/db_sql.cpp +++ b/modules/database/db_sql.cpp @@ -33,7 +33,7 @@ class SQLSQLInterface : public SQLInterface class ResultSQLSQLInterface : public SQLSQLInterface { - dynamic_reference<Serializable> obj; + Reference<Serializable> obj; public: ResultSQLSQLInterface(Module *o, Serializable *ob) : SQLSQLInterface(o), obj(ob) { } @@ -55,10 +55,10 @@ public: class DBSQL : public Module, public Pipe { - service_reference<SQLProvider> sql; + ServiceReference<SQLProvider> sql; SQLSQLInterface sqlinterface; Anope::string prefix; - std::set<dynamic_reference<Serializable> > updated_items; + std::set<Reference<Serializable> > updated_items; bool shutting_down; void RunBackground(const SQLQuery &q, SQLInterface *iface = NULL) @@ -72,7 +72,7 @@ class DBSQL : public Module, public Pipe Log(this) << "db_sql: Unable to execute query, is SQL configured correctly?"; } } - else if (!quitting) + else if (!Anope::Quitting) { if (iface == NULL) iface = &this->sqlinterface; @@ -95,9 +95,9 @@ class DBSQL : public Module, public Pipe void OnNotify() anope_override { - for (std::set<dynamic_reference<Serializable> >::iterator it = this->updated_items.begin(), it_end = this->updated_items.end(); it != it_end; ++it) + for (std::set<Reference<Serializable> >::iterator it = this->updated_items.begin(), it_end = this->updated_items.end(); it != it_end; ++it) { - dynamic_reference<Serializable> obj = *it; + Reference<Serializable> obj = *it; if (obj && this->sql) { @@ -105,11 +105,11 @@ class DBSQL : public Module, public Pipe continue; obj->UpdateCache(); - SerializeType *s_type = obj->GetSerializableType(); + Serialize::Type *s_type = obj->GetSerializableType(); if (!s_type) continue; - Serialize::Data data = obj->serialize(); + Serialize::Data data = obj->Serialize(); std::vector<SQLQuery> create = this->sql->CreateTable(this->prefix + s_type->GetName(), data); for (unsigned i = 0; i < create.size(); ++i) @@ -127,7 +127,7 @@ class DBSQL : public Module, public Pipe { ConfigReader config; Anope::string engine = config.ReadValue("db_sql", "engine", "", 0); - this->sql = service_reference<SQLProvider>("SQLProvider", engine); + this->sql = ServiceReference<SQLProvider>("SQLProvider", engine); this->prefix = config.ReadValue("db_sql", "prefix", "anope_db_", 0); } @@ -150,10 +150,10 @@ class DBSQL : public Module, public Pipe return EVENT_CONTINUE; } - const std::vector<Anope::string> type_order = SerializeType::GetTypeOrder(); + const std::vector<Anope::string> type_order = Serialize::Type::GetTypeOrder(); for (unsigned i = 0; i < type_order.size(); ++i) { - SerializeType *sb = SerializeType::Find(type_order[i]); + Serialize::Type *sb = Serialize::Type::Find(type_order[i]); SQLQuery query("SELECT * FROM `" + this->prefix + sb->GetName() + "`"); SQLResult res = this->sql->RunQuery(query); @@ -192,7 +192,7 @@ class DBSQL : public Module, public Pipe void OnSerializableDestruct(Serializable *obj) anope_override { - SerializeType *s_type = obj->GetSerializableType(); + Serialize::Type *s_type = obj->GetSerializableType(); if (s_type) this->RunBackground("DELETE FROM `" + this->prefix + s_type->GetName() + "` WHERE `id` = " + stringify(obj->id)); } diff --git a/modules/database/db_sql_live.cpp b/modules/database/db_sql_live.cpp index 3473fc1a9..00561592f 100644 --- a/modules/database/db_sql_live.cpp +++ b/modules/database/db_sql_live.cpp @@ -7,22 +7,20 @@ class DBMySQL : public Module, public Pipe private: Anope::string engine; Anope::string prefix; - service_reference<SQLProvider> SQL; + ServiceReference<SQLProvider> SQL; time_t lastwarn; bool ro; bool init; - std::set<dynamic_reference<Serializable> > updated_items; + std::set<Reference<Serializable> > updated_items; bool CheckSQL() { if (SQL) { - if (readonly && this->ro) + if (Anope::ReadOnly && this->ro) { - readonly = this->ro = false; - const BotInfo *bi = findbot(Config->OperServ); - if (bi) - ircdproto->SendGlobops(bi, "Found SQL again, going out of readonly mode..."); + Anope::ReadOnly = this->ro = false; + Log() << "Found SQL again, going out of readonly mode..."; } return true; @@ -31,10 +29,8 @@ class DBMySQL : public Module, public Pipe { if (Anope::CurTime - Config->UpdateTimeout > lastwarn) { - const BotInfo *bi = findbot(Config->OperServ); - if (bi) - ircdproto->SendGlobops(bi, "Unable to locate SQL reference, going to readonly..."); - readonly = this->ro = true; + Log() << "Unable to locate SQL reference, going to readonly..."; + Anope::ReadOnly = this->ro = true; this->lastwarn = Anope::CurTime; } @@ -85,9 +81,9 @@ class DBMySQL : public Module, public Pipe if (!this->CheckInit()) return; - for (std::set<dynamic_reference<Serializable> >::iterator it = this->updated_items.begin(), it_end = this->updated_items.end(); it != it_end; ++it) + for (std::set<Reference<Serializable> >::iterator it = this->updated_items.begin(), it_end = this->updated_items.end(); it != it_end; ++it) { - dynamic_reference<Serializable> obj = *it; + Reference<Serializable> obj = *it; if (obj && this->SQL) { @@ -95,11 +91,11 @@ class DBMySQL : public Module, public Pipe continue; obj->UpdateCache(); - SerializeType *s_type = obj->GetSerializableType(); + Serialize::Type *s_type = obj->GetSerializableType(); if (!s_type) continue; - Serialize::Data data = obj->serialize(); + Serialize::Data data = obj->Serialize(); std::vector<SQLQuery> create = this->SQL->CreateTable(this->prefix + s_type->GetName(), data); for (unsigned i = 0; i < create.size(); ++i) @@ -133,7 +129,7 @@ class DBMySQL : public Module, public Pipe { ConfigReader config; this->engine = config.ReadValue("db_sql", "engine", "", 0); - this->SQL = service_reference<SQLProvider>("SQLProvider", this->engine); + this->SQL = ServiceReference<SQLProvider>("SQLProvider", this->engine); this->prefix = config.ReadValue("db_sql", "prefix", "anope_db_", 0); } @@ -149,14 +145,14 @@ class DBMySQL : public Module, public Pipe { if (!this->CheckInit()) return; - SerializeType *s_type = obj->GetSerializableType(); + Serialize::Type *s_type = obj->GetSerializableType(); if (!s_type) return; this->RunQuery("DELETE FROM `" + this->prefix + s_type->GetName() + "` WHERE `id` = " + stringify(obj->id)); s_type->objects.erase(obj->id); } - void OnSerializeCheck(SerializeType *obj) anope_override + void OnSerializeCheck(Serialize::Type *obj) anope_override { if (!this->CheckInit() || obj->GetTimestamp() == Anope::CurTime) return; @@ -189,7 +185,7 @@ class DBMySQL : public Module, public Pipe std::map<unsigned int, Serializable *>::iterator it = obj->objects.find(id); if (it != obj->objects.end()) { - it->second->destroy(); + it->second->Destroy(); obj->objects.erase(it); } } @@ -217,7 +213,7 @@ class DBMySQL : public Module, public Pipe } } else - s->destroy(); + s->Destroy(); } } diff --git a/modules/encryption/enc_md5.cpp b/modules/encryption/enc_md5.cpp index bcbe4aeed..45c7f3df5 100644 --- a/modules/encryption/enc_md5.cpp +++ b/modules/encryption/enc_md5.cpp @@ -341,7 +341,7 @@ class EMD5 : public Module void OnCheckAuthentication(User *, IdentifyRequest *req) anope_override { - const NickAlias *na = findnick(req->GetAccount()); + const NickAlias *na = NickAlias::Find(req->GetAccount()); if (na == NULL) return; NickCore *nc = na->nc; @@ -361,7 +361,7 @@ class EMD5 : public Module * we want to re-encrypt the pass with the new encryption */ if (ModuleManager::FindFirstOf(ENCRYPTION) != this) - enc_encrypt(req->GetPassword(), nc->pass); + Anope::Encrypt(req->GetPassword(), nc->pass); req->Success(this); } } diff --git a/modules/encryption/enc_none.cpp b/modules/encryption/enc_none.cpp index 9496939fd..4854e5eb0 100644 --- a/modules/encryption/enc_none.cpp +++ b/modules/encryption/enc_none.cpp @@ -43,7 +43,7 @@ class ENone : public Module void OnCheckAuthentication(User *, IdentifyRequest *req) anope_override { - const NickAlias *na = findnick(req->GetAccount()); + const NickAlias *na = NickAlias::Find(req->GetAccount()); if (na == NULL) return; NickCore *nc = na->nc; @@ -63,7 +63,7 @@ class ENone : public Module * we want to re-encrypt the pass with the new encryption */ if (ModuleManager::FindFirstOf(ENCRYPTION) != this) - enc_encrypt(req->GetPassword(), nc->pass); + Anope::Encrypt(req->GetPassword(), nc->pass); req->Success(this); } } diff --git a/modules/encryption/enc_old.cpp b/modules/encryption/enc_old.cpp index b5ce86540..f7c83515d 100644 --- a/modules/encryption/enc_old.cpp +++ b/modules/encryption/enc_old.cpp @@ -351,7 +351,7 @@ class EOld : public Module void OnCheckAuthentication(User *, IdentifyRequest *req) anope_override { - const NickAlias *na = findnick(req->GetAccount()); + const NickAlias *na = NickAlias::Find(req->GetAccount()); if (na == NULL) return; NickCore *nc = na->nc; @@ -371,7 +371,7 @@ class EOld : public Module * we want to re-encrypt the pass with the new encryption */ if (ModuleManager::FindFirstOf(ENCRYPTION) != this) - enc_encrypt(req->GetPassword(), nc->pass); + Anope::Encrypt(req->GetPassword(), nc->pass); req->Success(this); } } diff --git a/modules/encryption/enc_sha1.cpp b/modules/encryption/enc_sha1.cpp index 28d216972..88571d776 100644 --- a/modules/encryption/enc_sha1.cpp +++ b/modules/encryption/enc_sha1.cpp @@ -194,7 +194,7 @@ class ESHA1 : public Module void OnCheckAuthentication(User *, IdentifyRequest *req) anope_override { - const NickAlias *na = findnick(req->GetAccount()); + const NickAlias *na = NickAlias::Find(req->GetAccount()); if (na == NULL) return; NickCore *nc = na->nc; @@ -211,7 +211,7 @@ class ESHA1 : public Module if (nc->pass.equals_cs(buf)) { if (ModuleManager::FindFirstOf(ENCRYPTION) != this) - enc_encrypt(req->GetPassword(), nc->pass); + Anope::Encrypt(req->GetPassword(), nc->pass); req->Success(this); } } diff --git a/modules/encryption/enc_sha256.cpp b/modules/encryption/enc_sha256.cpp index 36eaa98fc..396f975ed 100644 --- a/modules/encryption/enc_sha256.cpp +++ b/modules/encryption/enc_sha256.cpp @@ -280,7 +280,7 @@ class ESHA256 : public Module void OnCheckAuthentication(User *, IdentifyRequest *req) anope_override { - const NickAlias *na = findnick(req->GetAccount()); + const NickAlias *na = NickAlias::Find(req->GetAccount()); if (na == NULL) return; NickCore *nc = na->nc; @@ -303,7 +303,7 @@ class ESHA256 : public Module * we want to re-encrypt the pass with the new encryption */ if (ModuleManager::FindFirstOf(ENCRYPTION) != this) - enc_encrypt(req->GetPassword(), nc->pass); + Anope::Encrypt(req->GetPassword(), nc->pass); req->Success(this); } } diff --git a/modules/extra/bs_autoassign.cpp b/modules/extra/bs_autoassign.cpp index f290a3856..c84e18964 100644 --- a/modules/extra/bs_autoassign.cpp +++ b/modules/extra/bs_autoassign.cpp @@ -31,7 +31,7 @@ class BSAutoAssign : public Module if (this->bot.empty()) return; - BotInfo *bi = findbot(this->bot); + BotInfo *bi = BotInfo::Find(this->bot); if (bi == NULL) { Log(this) << "bs_autoassign is configured to assign bot " << this->bot << ", but it does not exist?"; diff --git a/modules/extra/httpd.h b/modules/extra/httpd.h index 490bf72bb..bf6a9838d 100644 --- a/modules/extra/httpd.h +++ b/modules/extra/httpd.h @@ -130,7 +130,7 @@ class HTTPClient : public ClientSocket, public BufferedSocket, public BinarySock bool ProcessWrite() anope_override { - return !BinarySocket::ProcessWrite() || BinarySocket::WriteBuffer.empty() ? false : true; + return !BinarySocket::ProcessWrite() || BinarySocket::write_buffer.empty() ? false : true; } void Write(const char *buffer, size_t l) anope_override diff --git a/modules/extra/m_chanstats.cpp b/modules/extra/m_chanstats.cpp index 1c37aa8ec..b50592b0f 100644 --- a/modules/extra/m_chanstats.cpp +++ b/modules/extra/m_chanstats.cpp @@ -21,7 +21,7 @@ class MySQLInterface : public SQLInterface class MChanstats : public Module { - service_reference<SQLProvider> sql; + ServiceReference<SQLProvider> sql; MySQLInterface sqlinterface; SQLQuery query; Anope::string SmileysHappy, SmileysSad, SmileysOther, prefix; @@ -359,7 +359,7 @@ class MChanstats : public Module SmileysOther = config.ReadValue("chanstats", "SmileysOther", ":/", 0); Anope::string engine = config.ReadValue("chanstats", "engine", "", 0); - this->sql = service_reference<SQLProvider>("SQLProvider", engine); + this->sql = ServiceReference<SQLProvider>("SQLProvider", engine); if (sql) this->CheckTables(); else @@ -367,7 +367,7 @@ class MChanstats : public Module } void OnTopicUpdated(Channel *c, const Anope::string &user, const Anope::string &topic) anope_override { - User *u = finduser(user); + User *u = User::Find(user); if (!u || !u->Account() || !c->ci || !c->ci->HasFlag(CI_STATS)) return; query = "CALL " + prefix + "chanstats_proc_update(@channel@, @nick@, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);"; diff --git a/modules/extra/m_dnsbl.cpp b/modules/extra/m_dnsbl.cpp index b860bd64c..54c802cd4 100644 --- a/modules/extra/m_dnsbl.cpp +++ b/modules/extra/m_dnsbl.cpp @@ -7,7 +7,7 @@ #include "module.h" -static service_reference<XLineManager> akills("XLineManager", "xlinemanager/sgline"); +static ServiceReference<XLineManager> akills("XLineManager", "xlinemanager/sgline"); struct Blacklist { @@ -19,21 +19,21 @@ struct Blacklist Blacklist(const Anope::string &n, time_t b, const Anope::string &r, const std::map<int, Anope::string> &re) : name(n), bantime(b), reason(r), replies(re) { } }; -class DNSBLResolver : public DNSRequest +class DNSBLResolver : public DNS::Request { - dynamic_reference<User> user; + Reference<User> user; Blacklist blacklist; bool add_to_akill; public: - DNSBLResolver(Module *c, User *u, const Blacklist &b, const Anope::string &host, bool add_akill) : DNSRequest(host, DNS_QUERY_A, true, c), user(u), blacklist(b), add_to_akill(add_akill) { } + DNSBLResolver(Module *c, User *u, const Blacklist &b, const Anope::string &host, bool add_akill) : DNS::Request(host, DNS::QUERY_A, true, c), user(u), blacklist(b), add_to_akill(add_akill) { } - void OnLookupComplete(const DNSQuery *record) anope_override + void OnLookupComplete(const DNS::Query *record) anope_override { if (!user || user->HasExt("m_dnsbl_akilled")) return; - const ResourceRecord &ans_record = record->answers[0]; + const DNS::ResourceRecord &ans_record = record->answers[0]; // Replies should be in 127.0.0.0/24 if (ans_record.rdata.find("127.0.0.") != 0) return; @@ -61,8 +61,7 @@ class DNSBLResolver : public DNSRequest reason = reason.replace_all_cs("%r", record_reason); reason = reason.replace_all_cs("%N", Config->NetworkName); - const BotInfo *operserv = findbot(Config->OperServ); - Log(operserv) << "DNSBL: " << user->GetMask() << " (" << user->ip << ") appears in " << this->blacklist.name; + Log(OperServ) << "DNSBL: " << user->GetMask() << " (" << user->ip << ") appears in " << this->blacklist.name; XLine *x = new XLine("*@" + user->ip, Config->OperServ, Anope::CurTime + this->blacklist.bantime, reason, XLineManager::GenerateUID()); if (this->add_to_akill && akills) { @@ -71,8 +70,8 @@ class DNSBLResolver : public DNSRequest } else { - ircdproto->SendAkill(NULL, x); - x->destroy(); + IRCD->SendAkill(NULL, x); + x->Destroy(); } } }; @@ -110,7 +109,7 @@ class ModuleDNSBL : public Module if (bname.empty()) continue; Anope::string sbantime = config.ReadValue("blacklist", "time", "4h", i); - time_t bantime = dotime(sbantime); + time_t bantime = Anope::DoTime(sbantime); if (bantime < 0) bantime = 9000; Anope::string reason = config.ReadValue("blacklist", "reason", "", i); @@ -126,7 +125,7 @@ class ModuleDNSBL : public Module } } - void OnUserConnect(dynamic_reference<User> &user, bool &exempt) anope_override + void OnUserConnect(Reference<User> &user, bool &exempt) anope_override { if (exempt || !user || (!this->check_on_connect && !Me->IsSynced())) return; diff --git a/modules/extra/m_helpchan.cpp b/modules/extra/m_helpchan.cpp index 08f90b644..6b450e581 100644 --- a/modules/extra/m_helpchan.cpp +++ b/modules/extra/m_helpchan.cpp @@ -26,10 +26,10 @@ class HelpChannel : public Module { if (Name == CMODE_OP && c && c->ci && c->name.equals_ci(this->HelpChan)) { - User *u = finduser(param); + User *u = User::Find(param); if (u && c->ci->AccessFor(u).HasPriv("OPDEOPME")) - u->SetMode(findbot(Config->OperServ), UMODE_HELPOP); + u->SetMode(OperServ, UMODE_HELPOP); } return EVENT_CONTINUE; diff --git a/modules/extra/m_httpd.cpp b/modules/extra/m_httpd.cpp index f2704d77c..0176b955a 100644 --- a/modules/extra/m_httpd.cpp +++ b/modules/extra/m_httpd.cpp @@ -42,7 +42,7 @@ class MyHTTPClient : public HTTPClient HTTPMessage header; bool header_done, served; Anope::string page_name; - dynamic_reference<HTTPPage> page; + Reference<HTTPPage> page; Anope::string ip; enum @@ -114,7 +114,8 @@ class MyHTTPClient : public HTTPClient { if (this->action == ACTION_NONE) { - std::vector<Anope::string> params = BuildStringVector(buf); + std::vector<Anope::string> params; + spacesepstream(buf).GetTokens(params); if (params.empty() || (params[0] != "GET" && params[0] != "POST")) { @@ -189,11 +190,11 @@ class MyHTTPClient : public HTTPClient } catch (const ConvertException &) { } - if (this->extrabuf.length() == content_length) + if (this->extra_buf.length() == content_length) { - Log(LOG_DEBUG_2) << "HTTP POST from " << this->clientaddr.addr() << ": " << this->extrabuf; + Log(LOG_DEBUG_2) << "HTTP POST from " << this->clientaddr.addr() << ": " << this->extra_buf; - sepstream sep(this->extrabuf, '&'); + sepstream sep(this->extra_buf, '&'); Anope::string token; while (sep.GetToken(token)) @@ -204,7 +205,7 @@ class MyHTTPClient : public HTTPClient this->header.post_data[token.substr(0, sz)] = HTTPUtils::URLDecode(token.substr(sz + 1)); } - this->header.content = this->extrabuf; + this->header.content = this->extra_buf; this->Serve(); } } @@ -281,7 +282,7 @@ class MyHTTPProvider : public HTTPProvider, public CallBack { int timeout; std::map<Anope::string, HTTPPage *> pages; - std::list<dynamic_reference<MyHTTPClient> > clients; + std::list<Reference<MyHTTPClient> > clients; public: MyHTTPProvider(Module *c, const Anope::string &n, const Anope::string &i, const unsigned short p, const int t) : Socket(-1, i.find(':') != Anope::string::npos), HTTPProvider(c, n, i, p), CallBack(c, 10, Anope::CurTime, true), timeout(t) { } @@ -290,7 +291,7 @@ class MyHTTPProvider : public HTTPProvider, public CallBack { while (!this->clients.empty()) { - dynamic_reference<MyHTTPClient>& c = this->clients.front(); + Reference<MyHTTPClient>& c = this->clients.front(); if (c && c->created + this->timeout >= Anope::CurTime) break; @@ -326,7 +327,7 @@ class MyHTTPProvider : public HTTPProvider, public CallBack class HTTPD : public Module { - service_reference<SSLService> sslref; + ServiceReference<SSLService> sslref; std::map<Anope::string, HTTPProvider *> providers; public: HTTPD(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, SUPPORTED), sslref("SSLService", "ssl") @@ -432,7 +433,7 @@ class HTTPD : public Module p->ext_ip = ext_ip; - p->ext_headers = BuildStringVector(ext_header); + spacesepstream(ext_header).GetTokens(p->ext_headers); } for (std::map<Anope::string, HTTPProvider *>::iterator it = this->providers.begin(), it_end = this->providers.end(); it != it_end;) diff --git a/modules/extra/m_ldap_authentication.cpp b/modules/extra/m_ldap_authentication.cpp index f2140eb71..233a43dde 100644 --- a/modules/extra/m_ldap_authentication.cpp +++ b/modules/extra/m_ldap_authentication.cpp @@ -12,13 +12,13 @@ static Anope::string username_attribute; struct IdentifyInfo { - dynamic_reference<User> user; + Reference<User> user; IdentifyRequest *req; - service_reference<LDAPProvider> lprov; + ServiceReference<LDAPProvider> lprov; bool admin_bind; Anope::string dn; - IdentifyInfo(User *u, IdentifyRequest *r, service_reference<LDAPProvider> &lp) : user(u), req(r), lprov(lp), admin_bind(true) + IdentifyInfo(User *u, IdentifyRequest *r, ServiceReference<LDAPProvider> &lp) : user(u), req(r), lprov(lp), admin_bind(true) { req->Hold(me); } @@ -100,18 +100,17 @@ class IdentifyInterface : public LDAPInterface } else { - NickAlias *na = findnick(ii->req->GetAccount()); + NickAlias *na = NickAlias::Find(ii->req->GetAccount()); if (na == NULL) { na = new NickAlias(ii->req->GetAccount(), new NickCore(ii->req->GetAccount())); if (ii->user) { if (Config->NSAddAccessOnReg) - na->nc->AddAccess(create_mask(ii->user)); + na->nc->AddAccess(ii->user->Mask()); - const BotInfo *bi = findbot(Config->NickServ); - if (bi) - ii->user->SendMessage(bi, _("Your account \002%s\002 has been successfully created."), na->nick.c_str()); + if (NickServ) + ii->user->SendMessage(NickServ, _("Your account \002%s\002 has been successfully created."), na->nick.c_str()); } } na->nc->Extend("m_ldap_authentication_dn", new ExtensibleItemClass<Anope::string>(ii->dn)); @@ -155,7 +154,7 @@ class OnIdentifyInterface : public LDAPInterface std::map<LDAPQuery, Anope::string>::iterator it = this->requests.find(r.id); if (it == this->requests.end()) return; - User *u = finduser(it->second); + User *u = User::Find(it->second); this->requests.erase(it); if (!u || !u->Account() || r.empty()) @@ -169,9 +168,8 @@ class OnIdentifyInterface : public LDAPInterface if (!email.equals_ci(u->Account()->email)) { u->Account()->email = email; - BotInfo *bi = findbot(Config->NickServ); - if (bi) - u->SendMessage(bi, _("Your email has been updated to \002%s\002"), email.c_str()); + if (NickServ) + u->SendMessage(NickServ, _("Your email has been updated to \002%s\002"), email.c_str()); Log(this->owner) << "m_ldap_authentication: Updated email address for " << u->nick << " (" << u->Account()->display << ") to " << email; } } @@ -206,7 +204,7 @@ class OnRegisterInterface : public LDAPInterface class NSIdentifyLDAP : public Module { - service_reference<LDAPProvider> ldap; + ServiceReference<LDAPProvider> ldap; IdentifyInterface iinterface; OnIdentifyInterface oninterface; OnRegisterInterface orinterface; diff --git a/modules/extra/m_ldap_oper.cpp b/modules/extra/m_ldap_oper.cpp index 53b3d4d43..ed2f5900a 100644 --- a/modules/extra/m_ldap_oper.cpp +++ b/modules/extra/m_ldap_oper.cpp @@ -23,7 +23,7 @@ class IdentifyInterface : public LDAPInterface std::map<LDAPQuery, Anope::string>::iterator it = this->requests.find(r.id); if (it == this->requests.end()) return; - User *u = finduser(it->second); + User *u = User::Find(it->second); this->requests.erase(it); @@ -77,7 +77,7 @@ class IdentifyInterface : public LDAPInterface class LDAPOper : public Module { - service_reference<LDAPProvider> ldap; + ServiceReference<LDAPProvider> ldap; IdentifyInterface iinterface; Anope::string binddn; diff --git a/modules/extra/m_mysql.cpp b/modules/extra/m_mysql.cpp index 7f1f965cd..47f6f41de 100644 --- a/modules/extra/m_mysql.cpp +++ b/modules/extra/m_mysql.cpp @@ -376,10 +376,10 @@ std::vector<SQLQuery> MySQLService::CreateTable(const Anope::string &table, cons known_cols.insert(it->first); query_text += ", `" + it->first + "` "; - if (it->second.getType() == Serialize::DT_INT) + if (it->second.GetType() == Serialize::DT_INT) query_text += "int(11)"; - else if (it->second.getMax() > 0) - query_text += "varchar(" + stringify(it->second.getMax()) + ")"; + else if (it->second.GetMax() > 0) + query_text += "varchar(" + stringify(it->second.GetMax()) + ")"; else query_text += "text"; } @@ -395,10 +395,10 @@ std::vector<SQLQuery> MySQLService::CreateTable(const Anope::string &table, cons known_cols.insert(it->first); Anope::string query_text = "ALTER TABLE `" + table + "` ADD `" + it->first + "` "; - if (it->second.getType() == Serialize::DT_INT) + if (it->second.GetType() == Serialize::DT_INT) query_text += "int(11)"; - else if (it->second.getMax() > 0) - query_text += "varchar(" + stringify(it->second.getMax()) + ")"; + else if (it->second.GetMax() > 0) + query_text += "varchar(" + stringify(it->second.GetMax()) + ")"; else query_text += "text"; diff --git a/modules/extra/m_proxyscan.cpp b/modules/extra/m_proxyscan.cpp index 00519c57f..6d2a6b7b0 100644 --- a/modules/extra/m_proxyscan.cpp +++ b/modules/extra/m_proxyscan.cpp @@ -36,7 +36,7 @@ class ProxyCallbackListener : public ListenSocket bool ProcessWrite() anope_override { - return !BufferedSocket::ProcessWrite() || this->WriteBuffer.empty() ? false : true; + return !BufferedSocket::ProcessWrite() || this->write_buffer.empty() ? false : true; } }; @@ -53,7 +53,7 @@ class ProxyCallbackListener : public ListenSocket class ProxyConnect : public ConnectionSocket { - static service_reference<XLineManager> akills; + static ServiceReference<XLineManager> akills; public: static std::set<ProxyConnect *> proxies; @@ -85,7 +85,7 @@ class ProxyConnect : public ConnectionSocket reason = reason.replace_all_cs("%i", this->conaddr.addr()); reason = reason.replace_all_cs("%p", stringify(this->conaddr.port())); - Log(findbot(Config->OperServ)) << "PROXYSCAN: Open " << this->GetType() << " proxy found on " << this->conaddr.addr() << ":" << this->conaddr.port() << " (" << reason << ")"; + Log(OperServ) << "PROXYSCAN: Open " << this->GetType() << " proxy found on " << this->conaddr.addr() << ":" << this->conaddr.port() << " (" << reason << ")"; XLine *x = new XLine("*@" + this->conaddr.addr(), Config->OperServ, Anope::CurTime + this->proxy.duration, reason, XLineManager::GenerateUID()); if (add_to_akill && akills) { @@ -94,15 +94,15 @@ class ProxyConnect : public ConnectionSocket } else { - if (ircdproto->CanSZLine) - ircdproto->SendSZLine(NULL, x); + if (IRCD->CanSZLine) + IRCD->SendSZLine(NULL, x); else - ircdproto->SendAkill(NULL, x); - x->destroy(); + IRCD->SendAkill(NULL, x); + x->Destroy(); } } }; -service_reference<XLineManager> ProxyConnect::akills("XLineManager", "xlinemanager/sgline"); +ServiceReference<XLineManager> ProxyConnect::akills("XLineManager", "xlinemanager/sgline"); std::set<ProxyConnect *> ProxyConnect::proxies; class HTTPProxyConnect : public ProxyConnect, public BufferedSocket @@ -255,7 +255,7 @@ class ModuleProxyScan : public Module ++it; ClientSocket *cs = dynamic_cast<ClientSocket *>(s); - if (cs != NULL && cs->LS == this->listener) + if (cs != NULL && cs->ls == this->listener) delete s; } @@ -332,7 +332,7 @@ class ModuleProxyScan : public Module if (p.ports.empty()) continue; - p.duration = dotime(config.ReadValue("proxyscan", "time", "4h", i)); + p.duration = Anope::DoTime(config.ReadValue("proxyscan", "time", "4h", i)); p.reason = config.ReadValue("proxyscan", "reason", "", i); if (p.reason.empty()) continue; @@ -341,7 +341,7 @@ class ModuleProxyScan : public Module } } - void OnUserConnect(dynamic_reference<User> &user, bool &exempt) anope_override + void OnUserConnect(Reference<User> &user, bool &exempt) anope_override { if (exempt || !user || !Me->IsSynced() || !user->server->IsSynced()) return; @@ -360,7 +360,7 @@ class ModuleProxyScan : public Module if (!this->con_notice.empty() && !this->con_source.empty()) { - const BotInfo *bi = findbot(this->con_source); + const BotInfo *bi = BotInfo::Find(this->con_source); if (bi) user->SendMessage(bi, this->con_notice); } diff --git a/modules/extra/m_rewrite.cpp b/modules/extra/m_rewrite.cpp index 6d8690960..70710bd8a 100644 --- a/modules/extra/m_rewrite.cpp +++ b/modules/extra/m_rewrite.cpp @@ -13,7 +13,8 @@ struct Rewrite bool Matches(const std::vector<Anope::string> &message) { - std::vector<Anope::string> sm = BuildStringVector(this->source_message); + std::vector<Anope::string> sm; + spacesepstream(this->source_message).GetTokens(sm); for (unsigned i = 0; i < sm.size(); ++i) if (sm[i] != "$" && !sm[i].equals_ci(message[i])) @@ -106,7 +107,8 @@ class ModuleRewrite : public Module EventReturn OnBotPrivmsg(User *u, BotInfo *bi, Anope::string &message) anope_override { - std::vector<Anope::string> tokens = BuildStringVector(message); + std::vector<Anope::string> tokens; + spacesepstream(message).GetTokens(tokens); for (unsigned i = 0; i < this->rewrites.size(); ++i) { Rewrite &rw = this->rewrites[i]; diff --git a/modules/extra/m_sql_authentication.cpp b/modules/extra/m_sql_authentication.cpp index 9412edc50..ce7a275b3 100644 --- a/modules/extra/m_sql_authentication.cpp +++ b/modules/extra/m_sql_authentication.cpp @@ -5,7 +5,7 @@ static Module *me; class SQLAuthenticationResult : public SQLInterface { - dynamic_reference<User> user; + Reference<User> user; IdentifyRequest *req; public: @@ -37,26 +37,25 @@ class SQLAuthenticationResult : public SQLInterface } catch (const SQLException &) { } - const BotInfo *bi = findbot(Config->NickServ); - NickAlias *na = findnick(req->GetAccount()); + NickAlias *na = NickAlias::Find(req->GetAccount()); if (na == NULL) { na = new NickAlias(req->GetAccount(), new NickCore(req->GetAccount())); if (user) { if (Config->NSAddAccessOnReg) - na->nc->AddAccess(create_mask(user)); + na->nc->AddAccess(user->Mask()); - if (bi) - user->SendMessage(bi, _("Your account \002%s\002 has been successfully created."), na->nick.c_str()); + if (NickServ) + user->SendMessage(NickServ, _("Your account \002%s\002 has been successfully created."), na->nick.c_str()); } } if (!email.empty() && email != na->nc->email) { na->nc->email = email; - if (user && bi) - user->SendMessage(bi, _("Your email has been updated to \002%s\002."), email.c_str()); + if (user && NickServ) + user->SendMessage(NickServ, _("Your email has been updated to \002%s\002."), email.c_str()); } req->Success(me); @@ -77,7 +76,7 @@ class ModuleSQLAuthentication : public Module bool disable_register; Anope::string disable_reason; - service_reference<SQLProvider> SQL; + ServiceReference<SQLProvider> SQL; public: ModuleSQLAuthentication(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, SUPPORTED) @@ -101,7 +100,7 @@ class ModuleSQLAuthentication : public Module this->disable_register = config.ReadFlag("m_sql_authentication", "disable_ns_register", "false", 0); this->disable_reason = config.ReadValue("m_sql_authentication", "disable_reason", "", 0); - this->SQL = service_reference<SQLProvider>("SQLProvider", this->engine); + this->SQL = ServiceReference<SQLProvider>("SQLProvider", this->engine); } EventReturn OnPreCommand(CommandSource &source, Command *command, std::vector<Anope::string> ¶ms) anope_override diff --git a/modules/extra/m_sql_oper.cpp b/modules/extra/m_sql_oper.cpp index 22218a646..523272a49 100644 --- a/modules/extra/m_sql_oper.cpp +++ b/modules/extra/m_sql_oper.cpp @@ -3,7 +3,7 @@ class SQLOperResult : public SQLInterface { - dynamic_reference<User> user; + Reference<User> user; struct SQLOperResultDeleter { @@ -51,7 +51,7 @@ class SQLOperResult : public SQLInterface delete user->Account()->o; user->Account()->o = NULL; Log(this->owner) << "m_sql_oper: Removed services operator from " << user->nick << " (" << user->Account()->display << ")"; - user->RemoveMode(findbot(Config->OperServ), UMODE_OPER); // Probably not set, just incase + user->RemoveMode(OperServ, UMODE_OPER); // Probably not set, just incase } return; } @@ -72,10 +72,10 @@ class SQLOperResult : public SQLInterface if (!user->HasMode(UMODE_OPER)) { - ircdproto->SendOper(user); + IRCD->SendOper(user); if (!modes.empty()) - user->SetModes(findbot(Config->OperServ), "%s", modes.c_str()); + user->SetModes(OperServ, "%s", modes.c_str()); } } @@ -91,7 +91,7 @@ class ModuleSQLOper : public Module Anope::string engine; Anope::string query; - service_reference<SQLProvider> SQL; + ServiceReference<SQLProvider> SQL; public: ModuleSQLOper(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, SUPPORTED) @@ -111,7 +111,7 @@ class ModuleSQLOper : public Module this->engine = config.ReadValue("m_sql_oper", "engine", "", 0); this->query = config.ReadValue("m_sql_oper", "query", "", 0); - this->SQL = service_reference<SQLProvider>("SQLProvider", this->engine); + this->SQL = ServiceReference<SQLProvider>("SQLProvider", this->engine); } void OnNickIdentify(User *u) anope_override diff --git a/modules/extra/m_sqlite.cpp b/modules/extra/m_sqlite.cpp index f0db04c66..971345475 100644 --- a/modules/extra/m_sqlite.cpp +++ b/modules/extra/m_sqlite.cpp @@ -107,7 +107,7 @@ class ModuleSQLite : public Module if (this->SQLiteServices.find(connname) == this->SQLiteServices.end()) { - Anope::string database = db_dir + "/" + config.ReadValue("sqlite", "database", "anope", i); + Anope::string database = Anope::DataDir + "/" + config.ReadValue("sqlite", "database", "anope", i); try { @@ -214,7 +214,7 @@ std::vector<SQLQuery> SQLiteService::CreateTable(const Anope::string &table, con known_cols.insert(it->first); query_text += ", `" + it->first + "` "; - if (it->second.getType() == Serialize::DT_INT) + if (it->second.GetType() == Serialize::DT_INT) query_text += "int(11)"; else query_text += "text"; @@ -242,7 +242,7 @@ std::vector<SQLQuery> SQLiteService::CreateTable(const Anope::string &table, con known_cols.insert(it->first); Anope::string query_text = "ALTER TABLE `" + table + "` ADD `" + it->first + "` "; - if (it->second.getType() == Serialize::DT_INT) + if (it->second.GetType() == Serialize::DT_INT) query_text += "int(11)"; else query_text += "text"; diff --git a/modules/extra/m_ssl.cpp b/modules/extra/m_ssl.cpp index 2f72744c7..fdde28919 100644 --- a/modules/extra/m_ssl.cpp +++ b/modules/extra/m_ssl.cpp @@ -110,7 +110,7 @@ class SSLModule : public Module this->OnReload(); - if (IsFile(this->certfile.c_str())) + if (Anope::IsFile(this->certfile.c_str())) { if (!SSL_CTX_use_certificate_file(client_ctx, this->certfile.c_str(), SSL_FILETYPE_PEM) || !SSL_CTX_use_certificate_file(server_ctx, this->certfile.c_str(), SSL_FILETYPE_PEM)) { @@ -124,7 +124,7 @@ class SSLModule : public Module else Log() << "Unable to open certificate " << this->certfile; - if (IsFile(this->keyfile.c_str())) + if (Anope::IsFile(this->keyfile.c_str())) { if (!SSL_CTX_use_PrivateKey_file(client_ctx, this->keyfile.c_str(), SSL_FILETYPE_PEM) || !SSL_CTX_use_PrivateKey_file(server_ctx, this->keyfile.c_str(), SSL_FILETYPE_PEM)) { @@ -137,7 +137,7 @@ class SSLModule : public Module } else { - if (IsFile(this->certfile.c_str())) + if (Anope::IsFile(this->certfile.c_str())) { SSL_CTX_free(client_ctx); SSL_CTX_free(server_ctx); @@ -168,7 +168,7 @@ class SSLModule : public Module Socket *s = it->second; ++it; - if (dynamic_cast<SSLSocketIO *>(s->IO)) + if (dynamic_cast<SSLSocketIO *>(s->io)) delete s; } @@ -188,7 +188,7 @@ class SSLModule : public Module { ConfigReader config; - if (config.ReadFlag("uplink", "ssl", "no", CurrentUplink)) + if (config.ReadFlag("uplink", "ssl", "no", Anope::CurrentUplink)) { this->service.Init(UplinkSock); } @@ -201,10 +201,10 @@ MySSLService::MySSLService(Module *o, const Anope::string &n) : SSLService(o, n) void MySSLService::Init(Socket *s) { - if (s->IO != &normalSocketIO) + if (s->io != &NormalSocketIO) throw CoreException("Socket initializing SSL twice"); - s->IO = new SSLSocketIO(); + s->io = new SSLSocketIO(); } SSLSocketIO::SSLSocketIO() @@ -228,7 +228,7 @@ int SSLSocketIO::Send(Socket *s, const char *buf, size_t sz) ClientSocket *SSLSocketIO::Accept(ListenSocket *s) { - if (s->IO == &normalSocketIO) + if (s->io == &NormalSocketIO) throw SocketException("Attempting to accept on uninitialized socket with SSL"); sockaddrs conaddr; @@ -245,15 +245,15 @@ ClientSocket *SSLSocketIO::Accept(ListenSocket *s) ClientSocket *newsocket = s->OnAccept(newsock, conaddr); me->service.Init(newsocket); - SSLSocketIO *IO = anope_dynamic_static_cast<SSLSocketIO *>(newsocket->IO); + SSLSocketIO *io = anope_dynamic_static_cast<SSLSocketIO *>(newsocket->io); - IO->sslsock = SSL_new(server_ctx); - if (!IO->sslsock) + io->sslsock = SSL_new(server_ctx); + if (!io->sslsock) throw SocketException("Unable to initialize SSL socket"); - SSL_set_accept_state(IO->sslsock); + SSL_set_accept_state(io->sslsock); - if (!SSL_set_fd(IO->sslsock, newsocket->GetFD())) + if (!SSL_set_fd(io->sslsock, newsocket->GetFD())) throw SocketException("Unable to set SSL fd"); newsocket->SetFlag(SF_ACCEPTING); @@ -264,19 +264,19 @@ ClientSocket *SSLSocketIO::Accept(ListenSocket *s) SocketFlag SSLSocketIO::FinishAccept(ClientSocket *cs) { - if (cs->IO == &normalSocketIO) + if (cs->io == &NormalSocketIO) throw SocketException("Attempting to finish connect uninitialized socket with SSL"); else if (cs->HasFlag(SF_ACCEPTED)) return SF_ACCEPTED; else if (!cs->HasFlag(SF_ACCEPTING)) throw SocketException("SSLSocketIO::FinishAccept called for a socket not accepted nor accepting?"); - SSLSocketIO *IO = anope_dynamic_static_cast<SSLSocketIO *>(cs->IO); + SSLSocketIO *io = anope_dynamic_static_cast<SSLSocketIO *>(cs->io); - int ret = SSL_accept(IO->sslsock); + int ret = SSL_accept(io->sslsock); if (ret <= 0) { - int error = SSL_get_error(IO->sslsock, ret); + int error = SSL_get_error(io->sslsock, ret); if (ret == -1 && (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)) { SocketEngine::Change(cs, error == SSL_ERROR_WANT_WRITE, SF_WRITABLE); @@ -304,7 +304,7 @@ SocketFlag SSLSocketIO::FinishAccept(ClientSocket *cs) void SSLSocketIO::Connect(ConnectionSocket *s, const Anope::string &target, int port) { - if (s->IO == &normalSocketIO) + if (s->io == &NormalSocketIO) throw SocketException("Attempting to connect uninitialized socket with SSL"); s->UnsetFlag(SF_CONNECTING); @@ -336,29 +336,29 @@ void SSLSocketIO::Connect(ConnectionSocket *s, const Anope::string &target, int SocketFlag SSLSocketIO::FinishConnect(ConnectionSocket *s) { - if (s->IO == &normalSocketIO) + if (s->io == &NormalSocketIO) throw SocketException("Attempting to finish connect uninitialized socket with SSL"); else if (s->HasFlag(SF_CONNECTED)) return SF_CONNECTED; else if (!s->HasFlag(SF_CONNECTING)) throw SocketException("SSLSocketIO::FinishConnect called for a socket not connected nor connecting?"); - SSLSocketIO *IO = anope_dynamic_static_cast<SSLSocketIO *>(s->IO); + SSLSocketIO *io = anope_dynamic_static_cast<SSLSocketIO *>(s->io); - if (IO->sslsock == NULL) + if (io->sslsock == NULL) { - IO->sslsock = SSL_new(client_ctx); - if (!IO->sslsock) + io->sslsock = SSL_new(client_ctx); + if (!io->sslsock) throw SocketException("Unable to initialize SSL socket"); - if (!SSL_set_fd(IO->sslsock, s->GetFD())) + if (!SSL_set_fd(io->sslsock, s->GetFD())) throw SocketException("Unable to set SSL fd"); } - int ret = SSL_connect(IO->sslsock); + int ret = SSL_connect(io->sslsock); if (ret <= 0) { - int error = SSL_get_error(IO->sslsock, ret); + int error = SSL_get_error(io->sslsock, ret); if (ret == -1 && (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)) { SocketEngine::Change(s, error == SSL_ERROR_WANT_WRITE, SF_WRITABLE); diff --git a/modules/extra/m_statusupdate.cpp b/modules/extra/m_statusupdate.cpp index 7cbd9c7be..41ea8833e 100644 --- a/modules/extra/m_statusupdate.cpp +++ b/modules/extra/m_statusupdate.cpp @@ -43,7 +43,7 @@ class StatusUpdate : public Module for (int i = 0; !modeInfo[i].priv.empty(); ++i) if (!access->HasPriv(modeInfo[i].priv)) ci->c->RemoveMode(NULL, modeInfo[i].name, user->nick); - chan_set_correct_modes(user, ci->c, 1, false); + ci->c->SetCorrectModes(user, true, false); } } } diff --git a/modules/extra/m_xmlrpc.cpp b/modules/extra/m_xmlrpc.cpp index 2ff648812..a3b999a5e 100644 --- a/modules/extra/m_xmlrpc.cpp +++ b/modules/extra/m_xmlrpc.cpp @@ -157,7 +157,7 @@ class MyXMLRPCServiceInterface : public XMLRPCServiceInterface, public HTTPPage class ModuleXMLRPC : public Module { - service_reference<HTTPProvider> httpref; + ServiceReference<HTTPProvider> httpref; public: MyXMLRPCServiceInterface xmlrpcinterface; @@ -183,7 +183,7 @@ class ModuleXMLRPC : public Module void OnReload() anope_override { ConfigReader config; - httpref = service_reference<HTTPProvider>("HTTPProvider", "httpd/main"); + httpref = ServiceReference<HTTPProvider>("HTTPProvider", "httpd/main"); } }; diff --git a/modules/extra/m_xmlrpc_main.cpp b/modules/extra/m_xmlrpc_main.cpp index 4bd9c0ec6..672ef5524 100644 --- a/modules/extra/m_xmlrpc_main.cpp +++ b/modules/extra/m_xmlrpc_main.cpp @@ -8,8 +8,8 @@ class XMLRPCIdentifyRequest : public IdentifyRequest XMLRPCRequest request; HTTPReply repl; /* Request holds a reference to the HTTPReply, because we might exist long enough to invalidate it we'll copy it here then reset the reference before we use it */ - dynamic_reference<HTTPClient> client; - dynamic_reference<XMLRPCServiceInterface> xinterface; + Reference<HTTPClient> client; + Reference<XMLRPCServiceInterface> xinterface; public: XMLRPCIdentifyRequest(Module *m, XMLRPCRequest& req, HTTPClient *c, XMLRPCServiceInterface* iface, const Anope::string &acc, const Anope::string &pass) : IdentifyRequest(m, acc, pass), request(req), repl(request.r), client(c), xinterface(iface) { } @@ -74,14 +74,14 @@ class MyXMLRPCEvent : public XMLRPCEvent request.reply("error", "Invalid parameters"); else { - BotInfo *bi = findbot(service); + BotInfo *bi = BotInfo::Find(service); if (!bi) request.reply("error", "Invalid service"); else { request.reply("result", "Success"); - NickAlias *na = findnick(user); + NickAlias *na = NickAlias::Find(user); Anope::string out; @@ -127,18 +127,18 @@ class MyXMLRPCEvent : public XMLRPCEvent void DoStats(XMLRPCServiceInterface *iface, HTTPClient *client, XMLRPCRequest &request) { - request.reply("uptime", stringify(Anope::CurTime - start_time)); + request.reply("uptime", stringify(Anope::CurTime - Anope::StartTime)); request.reply("uplinkname", Me->GetLinks().front()->GetName()); { Anope::string buf; - for (std::set<Anope::string>::iterator it = Capab.begin(); it != Capab.end(); ++it) + for (std::set<Anope::string>::iterator it = Servers::Capab.begin(); it != Servers::Capab.end(); ++it) buf += " " + *it; if (!buf.empty()) buf.erase(buf.begin()); request.reply("uplinkcapab", buf); } - request.reply("usercount", stringify(usercnt)); - request.reply("maxusercount", stringify(maxusercnt)); + request.reply("usercount", stringify(UserListByNick.size())); + request.reply("maxusercount", stringify(MaxUserCount)); request.reply("channelcount", stringify(ChannelList.size())); } @@ -147,7 +147,7 @@ class MyXMLRPCEvent : public XMLRPCEvent if (request.data.empty()) return; - Channel *c = findchan(request.data[0]); + Channel *c = Channel::Find(request.data[0]); request.reply("name", iface->Sanitize(c ? c->name : request.data[0])); @@ -175,7 +175,7 @@ class MyXMLRPCEvent : public XMLRPCEvent for (CUserList::const_iterator it = c->users.begin(); it != c->users.end(); ++it) { UserContainer *uc = *it; - users += uc->Status->BuildModePrefixList() + uc->user->nick + " "; + users += uc->status->BuildModePrefixList() + uc->user->nick + " "; } if (!users.empty()) { @@ -199,7 +199,7 @@ class MyXMLRPCEvent : public XMLRPCEvent if (request.data.empty()) return; - User *u = finduser(request.data[0]); + User *u = User::Find(request.data[0]); request.reply("nick", iface->Sanitize(u ? u->nick : request.data[0])); @@ -227,7 +227,7 @@ class MyXMLRPCEvent : public XMLRPCEvent for (UChannelList::const_iterator it = u->chans.begin(); it != u->chans.end(); ++it) { ChannelContainer *cc = *it; - channels += cc->Status->BuildModePrefixList() + cc->chan->name + " "; + channels += cc->status->BuildModePrefixList() + cc->chan->name + " "; } if (!channels.empty()) { @@ -253,7 +253,7 @@ class MyXMLRPCEvent : public XMLRPCEvent class ModuleXMLRPCMain : public Module { - service_reference<XMLRPCServiceInterface> xmlrpc; + ServiceReference<XMLRPCServiceInterface> xmlrpc; MyXMLRPCEvent stats; diff --git a/modules/extra/webcpanel/pages/chanserv/access.cpp b/modules/extra/webcpanel/pages/chanserv/access.cpp index a1b8be97f..d21546c3a 100644 --- a/modules/extra/webcpanel/pages/chanserv/access.cpp +++ b/modules/extra/webcpanel/pages/chanserv/access.cpp @@ -22,7 +22,7 @@ bool WebCPanel::ChanServ::Access::OnRequest(HTTPProvider *server, const Anope::s return true; } - ChannelInfo *ci = cs_findchan(chname); + ChannelInfo *ci = ChannelInfo::Find(chname); if (!ci) return true; @@ -64,7 +64,7 @@ bool WebCPanel::ChanServ::Access::OnRequest(HTTPProvider *server, const Anope::s if (acc->mask == message.post_data["mask"]) { - if ((!highest || *acc >= *highest) && !u_access.Founder && !has_priv) + if ((!highest || *acc >= *highest) && !u_access.founder && !has_priv) { replacements["MESSAGES"] = "Access denied"; denied = true; @@ -85,7 +85,7 @@ bool WebCPanel::ChanServ::Access::OnRequest(HTTPProvider *server, const Anope::s new_acc->creator = na->nc->display; try { - new_acc->Unserialize(message.post_data["access"]); + new_acc->AccessUnserialize(message.post_data["access"]); } catch (...) { @@ -98,7 +98,7 @@ bool WebCPanel::ChanServ::Access::OnRequest(HTTPProvider *server, const Anope::s new_acc->last_seen = 0; new_acc->created = Anope::CurTime; - if ((!highest || *highest <= *new_acc) && !u_access.Founder && !has_priv) + if ((!highest || *highest <= *new_acc) && !u_access.founder && !has_priv) delete new_acc; else if (new_acc->Serialize().empty()) { @@ -108,7 +108,7 @@ bool WebCPanel::ChanServ::Access::OnRequest(HTTPProvider *server, const Anope::s else { ci->AddAccess(new_acc); - replacements["MESSAGES"] = "Access for " + new_acc->mask + " set to " + new_acc->Serialize(); + replacements["MESSAGES"] = "Access for " + new_acc->mask + " set to " + new_acc->AccessSerialize(); } } } @@ -123,7 +123,7 @@ bool WebCPanel::ChanServ::Access::OnRequest(HTTPProvider *server, const Anope::s ChanAccess *access = ci->GetAccess(i); replacements["MASKS"] = HTTPUtils::Escape(access->mask); - replacements["ACCESSES"] = HTTPUtils::Escape(access->Serialize()); + replacements["ACCESSES"] = HTTPUtils::Escape(access->AccessSerialize()); replacements["CREATORS"] = HTTPUtils::Escape(access->creator); replacements["ACCESS_CHANGES"] = ci->AccessFor(na->nc).HasPriv("ACCESS_CHANGE") ? "YES" : "NO"; } diff --git a/modules/extra/webcpanel/pages/chanserv/akick.cpp b/modules/extra/webcpanel/pages/chanserv/akick.cpp index d5351bfd9..bb678b715 100644 --- a/modules/extra/webcpanel/pages/chanserv/akick.cpp +++ b/modules/extra/webcpanel/pages/chanserv/akick.cpp @@ -22,7 +22,7 @@ bool WebCPanel::ChanServ::Akick::OnRequest(HTTPProvider *server, const Anope::st return true; } - ChannelInfo *ci = cs_findchan(chname); + ChannelInfo *ci = ChannelInfo::Find(chname); if (!ci) return true; diff --git a/modules/extra/webcpanel/pages/chanserv/set.cpp b/modules/extra/webcpanel/pages/chanserv/set.cpp index 4ad551e6a..4a61b37db 100644 --- a/modules/extra/webcpanel/pages/chanserv/set.cpp +++ b/modules/extra/webcpanel/pages/chanserv/set.cpp @@ -22,7 +22,7 @@ bool WebCPanel::ChanServ::Set::OnRequest(HTTPProvider *server, const Anope::stri return true; } - ChannelInfo *ci = cs_findchan(chname); + ChannelInfo *ci = ChannelInfo::Find(chname); if (!ci || !ci->AccessFor(na->nc).HasPriv("SET")) return true; @@ -93,8 +93,8 @@ bool WebCPanel::ChanServ::Set::OnRequest(HTTPProvider *server, const Anope::stri replacements["FOUNDER"] = ci->GetFounder()->display; if (ci->successor) replacements["SUCCESSOR"] = ci->successor->display; - replacements["TIME_REGISTERED"] = do_strftime(ci->time_registered, na->nc); - replacements["LAST_USED"] = do_strftime(ci->last_used, na->nc); + replacements["TIME_REGISTERED"] = Anope::strftime(ci->time_registered, na->nc); + replacements["LAST_USED"] = Anope::strftime(ci->last_used, na->nc); if (!ci->last_topic.empty()) { diff --git a/modules/extra/webcpanel/pages/index.cpp b/modules/extra/webcpanel/pages/index.cpp index c97737c21..6178dab29 100644 --- a/modules/extra/webcpanel/pages/index.cpp +++ b/modules/extra/webcpanel/pages/index.cpp @@ -11,9 +11,9 @@ class WebpanelRequest : public IdentifyRequest { HTTPReply reply; HTTPMessage message; - dynamic_reference<HTTPProvider> server; + Reference<HTTPProvider> server; Anope::string page_name; - dynamic_reference<HTTPClient> client; + Reference<HTTPClient> client; TemplateFileServer::Replacements replacements; public: @@ -23,7 +23,7 @@ class WebpanelRequest : public IdentifyRequest { if (!client) return; - NickAlias *na = findnick(this->GetAccount()); + NickAlias *na = NickAlias::Find(this->GetAccount()); if (!na) { this->OnFail(); diff --git a/modules/extra/webcpanel/pages/memoserv/memos.cpp b/modules/extra/webcpanel/pages/memoserv/memos.cpp index 00b913ef0..54c7a1227 100644 --- a/modules/extra/webcpanel/pages/memoserv/memos.cpp +++ b/modules/extra/webcpanel/pages/memoserv/memos.cpp @@ -36,7 +36,7 @@ bool WebCPanel::MemoServ::Memos::OnRequest(HTTPProvider *server, const Anope::st } else { - ci = cs_findchan(chname); + ci = ChannelInfo::Find(chname); if (ci) { replacements["MESSAGES"] = "Displaying the memos for " + chname + "."; @@ -107,7 +107,7 @@ bool WebCPanel::MemoServ::Memos::OnRequest(HTTPProvider *server, const Anope::st m = mi->GetMemo(i); replacements["NUMBER"] = stringify(i+1); replacements["SENDER"] = m->sender; - replacements["TIME"] = do_strftime(m->time); + replacements["TIME"] = Anope::strftime(m->time); replacements["TEXT"] = m->text; if (m->HasFlag(MF_UNREAD)) replacements["UNREAD"] = "YES"; diff --git a/modules/extra/webcpanel/pages/nickserv/alist.cpp b/modules/extra/webcpanel/pages/nickserv/alist.cpp index 2fd184dbb..3b5b8dab0 100644 --- a/modules/extra/webcpanel/pages/nickserv/alist.cpp +++ b/modules/extra/webcpanel/pages/nickserv/alist.cpp @@ -39,7 +39,7 @@ bool WebCPanel::NickServ::Alist::OnRequest(HTTPProvider *server, const Anope::st replacements["CHANNELS"] = (ci->HasFlag(CI_NO_EXPIRE) ? "!" : "") + ci->name; Anope::string access_str; for (unsigned i = 0; i < access.size(); ++i) - access_str += ", " + access[i]->Serialize(); + access_str += ", " + access[i]->AccessSerialize(); replacements["ACCESSES"] = access_str.substr(2); } diff --git a/modules/extra/webcpanel/pages/nickserv/info.cpp b/modules/extra/webcpanel/pages/nickserv/info.cpp index 3ec61b03f..cdd80b7cd 100644 --- a/modules/extra/webcpanel/pages/nickserv/info.cpp +++ b/modules/extra/webcpanel/pages/nickserv/info.cpp @@ -19,7 +19,7 @@ bool WebCPanel::NickServ::Info::OnRequest(HTTPProvider *server, const Anope::str { if (message.post_data["email"] != na->nc->email) { - if (!message.post_data["email"].empty() && !MailValidate(message.post_data["email"])) + if (!message.post_data["email"].empty() && !Mail::Validate(message.post_data["email"])) replacements["ERRORS"] = "Invalid email"; else { @@ -83,7 +83,7 @@ bool WebCPanel::NickServ::Info::OnRequest(HTTPProvider *server, const Anope::str replacements["DISPLAY"] = HTTPUtils::Escape(na->nc->display); if (na->nc->email.empty() == false) replacements["EMAIL"] = HTTPUtils::Escape(na->nc->email); - replacements["TIME_REGISTERED"] = do_strftime(na->time_registered, na->nc); + replacements["TIME_REGISTERED"] = Anope::strftime(na->time_registered, na->nc); if (na->HasVhost()) { if (na->GetVhostIdent().empty() == false) diff --git a/modules/extra/webcpanel/pages/operserv/akill.cpp b/modules/extra/webcpanel/pages/operserv/akill.cpp index 3d66b5c6a..112949d9e 100644 --- a/modules/extra/webcpanel/pages/operserv/akill.cpp +++ b/modules/extra/webcpanel/pages/operserv/akill.cpp @@ -14,7 +14,7 @@ WebCPanel::OperServ::Akill::Akill(const Anope::string &cat, const Anope::string bool WebCPanel::OperServ::Akill::OnRequest(HTTPProvider *server, const Anope::string &page_name, HTTPClient *client, HTTPMessage &message, HTTPReply &reply, NickAlias *na, TemplateFileServer::Replacements &replacements) { - static service_reference<XLineManager> akills("XLineManager","xlinemanager/sgline"); + static ServiceReference<XLineManager> akills("XLineManager","xlinemanager/sgline"); if (!na->nc->IsServicesOper() && !(na->nc->o && na->nc->o->ot && na->nc->o->ot->HasPriv("operserv/akill"))) { @@ -28,7 +28,7 @@ bool WebCPanel::OperServ::Akill::OnRequest(HTTPProvider *server, const Anope::st if (message.post_data.count("mask") > 0 && message.post_data.count("expiry") > 0 && message.post_data.count("reason") > 0) { std::vector<Anope::string> params; - stringstream cmdstr; + std::stringstream cmdstr; params.push_back("ADD"); cmdstr << "+" << HTTPUtils::URLDecode(message.post_data["expiry"]); cmdstr << " " << HTTPUtils::URLDecode(message.post_data["mask"]); @@ -49,11 +49,11 @@ bool WebCPanel::OperServ::Akill::OnRequest(HTTPProvider *server, const Anope::st { const XLine *x = akills->GetEntry(i); replacements["NUMBER"] = stringify(i + 1); - replacements["HOST"] = x->Mask; - replacements["SETTER"] = x->By; - replacements["TIME"] = do_strftime(x->Created, NULL, true); - replacements["EXPIRE"] = expire_left(na->nc, x->Expires); - replacements["REASON"] = x->Reason; + replacements["HOST"] = x->mask; + replacements["SETTER"] = x->by; + replacements["TIME"] = Anope::strftime(x->created, NULL, true); + replacements["EXPIRE"] = Anope::Expires(x->expires, na->nc); + replacements["REASON"] = x->reason; } } diff --git a/modules/extra/webcpanel/template_fileserver.cpp b/modules/extra/webcpanel/template_fileserver.cpp index b1881b811..cf7094e39 100644 --- a/modules/extra/webcpanel/template_fileserver.cpp +++ b/modules/extra/webcpanel/template_fileserver.cpp @@ -126,7 +126,8 @@ void TemplateFileServer::Serve(HTTPProvider *server, const Anope::string &page_n if (content.find("IF ") == 0) { - std::vector<Anope::string> tokens = BuildStringVector(content); + std::vector<Anope::string> tokens; + spacesepstream(content).GetTokens(tokens); if (tokens.size() == 4 && tokens[1] == "EQ") { @@ -163,13 +164,17 @@ void TemplateFileServer::Serve(HTTPProvider *server, const Anope::string &page_n } else if (content.find("FOR ") == 0) { - std::vector<Anope::string> tokens = BuildStringVector(content); + std::vector<Anope::string> tokens; + spacesepstream(content).GetTokens(tokens); + if (tokens.size() != 4 || tokens[2] != "IN") Log() << "Invalid FOR in web template " << this->file_name; else { - std::vector<Anope::string> temp_variables = BuildStringVector(tokens[1], ','), - real_variables = BuildStringVector(tokens[3], ','); + std::vector<Anope::string> temp_variables, real_variables; + commasepstream(tokens[1]).GetTokens(temp_variables); + commasepstream(tokens[3]).GetTokens(real_variables); + if (temp_variables.size() != real_variables.size()) Log() << "Invalid FOR in web template " << this->file_name << " variable mismatch"; else @@ -200,7 +205,9 @@ void TemplateFileServer::Serve(HTTPProvider *server, const Anope::string &page_n } else if (content.find("INCLUDE ") == 0) { - std::vector<Anope::string> tokens = BuildStringVector(content); + std::vector<Anope::string> tokens; + spacesepstream(content).GetTokens(tokens); + if (tokens.size() != 2) Log() << "Invalid INCLUDE in web template " << this->file_name; else diff --git a/modules/extra/webcpanel/webcpanel.cpp b/modules/extra/webcpanel/webcpanel.cpp index 77cf606aa..164c4b903 100644 --- a/modules/extra/webcpanel/webcpanel.cpp +++ b/modules/extra/webcpanel/webcpanel.cpp @@ -52,11 +52,11 @@ class ModuleWebCPanel : public Module ConfigReader reader; provider_name = reader.ReadValue("webcpanel", "server", "httpd/main", 0); template_name = reader.ReadValue("webcpanel", "template", "template", 0); - template_base = db_dir + "/modules/webcpanel/templates/" + template_name; + template_base = Anope::DataDir + "/modules/webcpanel/templates/" + template_name; page_title = reader.ReadValue("webcpanel", "title", "Anope IRC Services", 0); use_ssl = reader.ReadFlag("webcpanel", "ssl", "no", 0); // This is dumb, is there a better way to do this? - service_reference<HTTPProvider> provider("HTTPProvider", provider_name); + ServiceReference<HTTPProvider> provider("HTTPProvider", provider_name); if (!provider) throw ModuleException("Unable to find HTTPD provider. Is m_httpd loaded?"); @@ -80,7 +80,7 @@ class ModuleWebCPanel : public Module s.subsections.push_back(ss); provider->RegisterPage(&this->nickserv_info); - if (ircdproto && ircdproto->CanCertFP) + if (IRCD && IRCD->CanCertFP) { ss.name = "SSL Certificates"; ss.url = "/nickserv/cert"; @@ -160,7 +160,7 @@ class ModuleWebCPanel : public Module ~ModuleWebCPanel() { - service_reference<HTTPProvider> provider("HTTPProvider", provider_name); + ServiceReference<HTTPProvider> provider("HTTPProvider", provider_name); if (provider) { provider->UnregisterPage(&this->style_css); @@ -191,14 +191,14 @@ namespace WebPanel { void RunCommand(const Anope::string &user, NickCore *nc, const Anope::string &service, const Anope::string &c, const std::vector<Anope::string> ¶ms, TemplateFileServer::Replacements &r) { - service_reference<Command> cmd("Command", c); + ServiceReference<Command> cmd("Command", c); if (!cmd) { r["MESSAGES"] = "Unable to find command " + c; return; } - BotInfo *bi = findbot(service); + BotInfo *bi = BotInfo::Find(service); if (!bi) { if (BotListByNick->empty()) diff --git a/modules/extra/webcpanel/webcpanel.h b/modules/extra/webcpanel/webcpanel.h index 99cb2ec3a..27b8ce67a 100644 --- a/modules/extra/webcpanel/webcpanel.h +++ b/modules/extra/webcpanel/webcpanel.h @@ -46,7 +46,7 @@ class Panel : public Section, public Service if (acc.empty() || id.empty()) return NULL; - NickAlias *na = findnick(acc); + NickAlias *na = NickAlias::Find(acc); if (na == NULL) return NULL; @@ -83,7 +83,7 @@ class WebPanelProtectedPage : public WebPanelPage bool OnRequest(HTTPProvider *provider, const Anope::string &page_name, HTTPClient *client, HTTPMessage &message, HTTPReply &reply) anope_override anope_final { - service_reference<Panel> panel("Panel", "webcpanel"); + ServiceReference<Panel> panel("Panel", "webcpanel"); NickAlias *na; if (!panel || !(na = panel->GetNickFromSession(client, message))) diff --git a/modules/protocol/bahamut.cpp b/modules/protocol/bahamut.cpp index e39226dd8..839876d90 100644 --- a/modules/protocol/bahamut.cpp +++ b/modules/protocol/bahamut.cpp @@ -49,7 +49,7 @@ class BahamutIRCdProto : public IRCDProto void SendModeInternal(const BotInfo *source, const Channel *dest, const Anope::string &buf) anope_override { - if (Capab.count("TSMODE") > 0) + if (Servers::Capab.count("TSMODE") > 0) { if (source) UplinkSocket::Message(source) << "MODE " << dest->name << " " << dest->creation_time << " " << buf; @@ -93,13 +93,13 @@ class BahamutIRCdProto : public IRCDProto /* SQLINE */ void SendSQLine(User *, const XLine *x) anope_override { - UplinkSocket::Message() << "SQLINE " << x->Mask << " :" << x->GetReason(); + UplinkSocket::Message() << "SQLINE " << x->mask << " :" << x->GetReason(); } /* UNSLINE */ void SendSGLineDel(const XLine *x) anope_override { - UplinkSocket::Message() << "UNSGLINE 0 :" << x->Mask; + UplinkSocket::Message() << "UNSGLINE 0 :" << x->mask; } /* UNSZLINE */ @@ -115,13 +115,13 @@ class BahamutIRCdProto : public IRCDProto void SendSZLine(User *, const XLine *x) anope_override { // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; /* this will likely fail so its only here for legacy */ UplinkSocket::Message() << "SZLINE " << x->GetHost() << " :" << x->GetReason(); /* this is how we are supposed to deal with it */ - UplinkSocket::Message() << "AKILL " << x->GetHost() << " * " << timeleft << " " << x->By << " " << Anope::CurTime << " :" << x->GetReason(); + UplinkSocket::Message() << "AKILL " << x->GetHost() << " * " << timeleft << " " << x->by << " " << Anope::CurTime << " :" << x->GetReason(); } /* SVSNOOP */ @@ -133,7 +133,7 @@ class BahamutIRCdProto : public IRCDProto /* SGLINE */ void SendSGLine(User *, const XLine *x) anope_override { - UplinkSocket::Message() << "SGLINE " << x->Mask.length() << " :" << x->Mask << ":" << x->GetReason(); + UplinkSocket::Message() << "SGLINE " << x->mask.length() << " :" << x->mask << ":" << x->GetReason(); } /* RAKILL */ @@ -148,7 +148,7 @@ class BahamutIRCdProto : public IRCDProto if (x->GetUser() == "*") { sockaddrs(x->GetHost()); - ircdproto->SendSZLineDel(x); + IRCD->SendSZLineDel(x); return; } } @@ -166,7 +166,7 @@ class BahamutIRCdProto : public IRCDProto /* UNSQLINE */ void SendSQLineDel(const XLine *x) anope_override { - UplinkSocket::Message() << "UNSQLINE " << x->Mask; + UplinkSocket::Message() << "UNSQLINE " << x->mask; } /* JOIN - SJOIN */ @@ -182,11 +182,11 @@ class BahamutIRCdProto : public IRCDProto */ UserContainer *uc = c->FindUser(user); if (uc != NULL) - uc->Status->ClearFlags(); + uc->status->ClearFlags(); - BotInfo *setter = findbot(user->nick); + BotInfo *setter = BotInfo::Find(user->nick); for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) - if (cs.HasFlag(ModeManager::ChannelModes[i]->Name)) + if (cs.HasFlag(ModeManager::ChannelModes[i]->name)) c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); } } @@ -210,10 +210,10 @@ class BahamutIRCdProto : public IRCDProto return; /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - x = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); + x = new XLine("*@" + u->host, old->by, old->expires, old->reason, old->id); old->manager->AddXLine(x); - Log(findbot(Config->OperServ), "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->Mask; + Log(OperServ, "akill") << "AKILL: Added an akill for " << x->mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->mask; } /* ZLine if we can instead */ @@ -222,17 +222,17 @@ class BahamutIRCdProto : public IRCDProto if (x->GetUser() == "*") { sockaddrs(x->GetHost()); - ircdproto->SendSZLine(u, x); + IRCD->SendSZLine(u, x); return; } } catch (const SocketException &) { } // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; + time_t timeleft = x->expires - Anope::CurTime; if (timeleft > 172800) timeleft = 172800; - UplinkSocket::Message() << "AKILL " << x->GetHost() << " " << x->GetUser() << " " << timeleft << " " << x->By << " " << Anope::CurTime << " :" << x->GetReason(); + UplinkSocket::Message() << "AKILL " << x->GetHost() << " " << x->GetUser() << " " << timeleft << " " << x->by << " " << Anope::CurTime << " :" << x->GetReason(); } /* @@ -270,7 +270,7 @@ class BahamutIRCdProto : public IRCDProto void SendConnect() anope_override { - UplinkSocket::Message() << "PASS " << Config->Uplinks[CurrentUplink]->password << " :TS"; + UplinkSocket::Message() << "PASS " << Config->Uplinks[Anope::CurrentUplink]->password << " :TS"; UplinkSocket::Message() << "CAPAB SSJOIN NOQUIT BURST UNCONNECT NICKIP TSMODE TS3"; SendServer(Me); /* @@ -295,20 +295,18 @@ class BahamutIRCdProto : public IRCDProto void SendLogin(User *u) anope_override { - const BotInfo *ns = findbot(Config->NickServ); - ircdproto->SendMode(ns, u, "+d %d", u->timestamp); + IRCD->SendMode(NickServ, u, "+d %d", u->timestamp); } void SendLogout(User *u) anope_override { - const BotInfo *ns = findbot(Config->NickServ); - ircdproto->SendMode(ns, u, "+d 1"); + IRCD->SendMode(NickServ, u, "+d 1"); } }; struct IRCDMessageBurst : IRCDMessage { - IRCDMessageBurst() : IRCDMessage("BURST", 0) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageBurst(Module *creator) : IRCDMessage(creator, "BURST", 0) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -327,14 +325,15 @@ struct IRCDMessageBurst : IRCDMessage struct IRCDMessageMode : IRCDMessage { - IRCDMessageMode(const Anope::string &n) : IRCDMessage(n, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageMode(Module *creator, const Anope::string &sname) : IRCDMessage(creator, sname, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (params.size() > 2 && ircdproto->IsChannelValid(params[0])) + if (params.size() > 2 && IRCD->IsChannelValid(params[0])) { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); time_t ts = 0; + try { ts = convertTo<time_t>(params[1]); @@ -346,7 +345,7 @@ struct IRCDMessageMode : IRCDMessage } else { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetModesInternal("%s", params[1].c_str()); } @@ -375,7 +374,7 @@ struct IRCDMessageMode : IRCDMessage */ struct IRCDMessageNick : IRCDMessage { - IRCDMessageNick() : IRCDMessage("NICK", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageNick(Module *creator) : IRCDMessage(creator, "NICK", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -389,18 +388,18 @@ struct IRCDMessageNick : IRCDMessage } User *user = new User(params[0], params[4], params[5], "", params[8], s, params[9], params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0, params[3]); - if (user && nickserv) + if (user && NickServService) { const NickAlias *na; - if (user->timestamp == convertTo<time_t>(params[7]) && (na = findnick(user->nick))) + if (user->timestamp == convertTo<time_t>(params[7]) && (na = NickAlias::Find(user->nick))) { NickCore *nc = na->nc; user->Login(nc); if (!Config->NoNicknameOwnership && na->nc->HasFlag(NI_UNCONFIRMED) == false) - user->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + user->SetMode(NickServ, UMODE_REGISTERED); } else - nickserv->Validate(user); + NickServService->Validate(user); } } else @@ -412,7 +411,7 @@ struct IRCDMessageNick : IRCDMessage struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -424,77 +423,39 @@ struct IRCDMessageServer : IRCDMessage struct IRCDMessageSJoin : IRCDMessage { - IRCDMessageSJoin() : IRCDMessage("SJOIN", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageSJoin(Module *creator) : IRCDMessage(creator, "SJOIN", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[1]); - time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[1], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; - - /* If we need to keep their modes, and this SJOIN string contains modes */ - if (keep_their_modes && params.size() >= 4) - { - /* Set the modes internally */ - Anope::string modes; + Anope::string modes; + if (params.size() >= 4) for (unsigned i = 2; i < params.size(); ++i) modes += " " + params[i]; - if (!modes.empty()) - modes.erase(modes.begin()); - c->SetModesInternal(source, modes); - } + if (!modes.empty()) + modes.erase(modes.begin()); + + std::list<Message::Join::SJoinUser> users; /* For some reason, bahamut will send a SJOIN from the user joining a channel * if the channel already existed */ - if (!c->HasFlag(CH_SYNCING) && params.size() == 2) + if (source.GetUser()) { - User *u = source.GetUser(); - - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT == EVENT_STOP && (!c->ci || !c->ci->CheckKick(u))) - { - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); - } + Message::Join::SJoinUser sju; + sju.second = source.GetUser(); + users.push_back(sju); } else { spacesepstream sep(params[params.size() - 1]); Anope::string buf; + while (sep.GetToken(buf)) { - std::list<ChannelMode *> Status; - char ch; + Message::Join::SJoinUser sju; /* Get prefixes from the nick */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) + for (char ch; (ch = ModeManager::GetStatusChar(buf[0]));) { buf.erase(buf.begin()); ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); @@ -504,50 +465,22 @@ struct IRCDMessageSJoin : IRCDMessage continue; } - if (keep_their_modes) - Status.push_back(cm); + sju.first.SetFlag(cm->name); } - User *u = finduser(buf); - if (!u) + sju.second = User::Find(buf); + if (!sju.second) { - Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << c->name; + Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << params[1]; continue; } - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); + users.push_back(sju); } } - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) - { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } + time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : Anope::CurTime; + Message::Join::SJoin(source, params[1], ts, modes, users); return true; } @@ -555,11 +488,11 @@ struct IRCDMessageSJoin : IRCDMessage struct IRCDMessageTopic : IRCDMessage { - IRCDMessageTopic() : IRCDMessage("TOPIC", 4) { } + IRCDMessageTopic(Module *creator) : IRCDMessage(creator, "TOPIC", 4) { } bool Run(MessageSource &, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c) c->ChangeTopicInternal(params[1], params[3], Anope::string(params[2]).is_pos_number_only() ? convertTo<time_t>(params[2]) : Anope::CurTime); return true; @@ -571,23 +504,22 @@ class ProtoBahamut : public Module BahamutIRCdProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageJoin core_message_join; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - CoreIRCDMessageWhois core_message_whois; + Message::Away message_away; + Message::Capab message_capab; + Message::Error message_error; + Message::Join message_join; + Message::Kick message_kick; + Message::Kill message_kill; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Version message_version; + Message::Whois message_whois; /* Our message handlers */ IRCDMessageBurst message_burst; @@ -636,7 +568,13 @@ class ProtoBahamut : public Module public: ProtoBahamut(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), - message_mode("MODE"), message_svsmode("SVSMODE") + message_away(this), message_capab(this), message_error(this), message_join(this), + message_kick(this), message_kill(this), message_motd(this), message_part(this), + message_ping(this), message_privmsg(this), message_quit(this), message_squit(this), + message_stats(this), message_time(this), message_version(this), message_whois(this), + + message_burst(this), message_mode(this, "MODE"), message_svsmode(this, "SVSMODE"), + message_nick(this), message_server(this), message_sjoin(this), message_topic(this) { this->SetAuthor("Anope"); @@ -645,10 +583,15 @@ class ProtoBahamut : public Module ModuleManager::Attach(I_OnUserNickChange, this); } + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; + } + void OnUserNickChange(User *u, const Anope::string &) anope_override { u->RemoveModeInternal(ModeManager::FindUserModeByName(UMODE_REGISTERED)); - ircdproto->SendLogout(u); + IRCD->SendLogout(u); } }; diff --git a/modules/protocol/hybrid.cpp b/modules/protocol/hybrid.cpp index d3d67d84e..1161db3fa 100644 --- a/modules/protocol/hybrid.cpp +++ b/modules/protocol/hybrid.cpp @@ -37,44 +37,40 @@ class HybridProto : public IRCDProto UplinkSocket::Message(bi) << "PRIVMSG $$" << dest->GetName() << " :" << msg; } - void SendSQLine(User *, const XLine *x) anope_override + void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) anope_override { - const BotInfo *bi = findbot(Config->OperServ); + UplinkSocket::Message(source) << "OPERWALL :" << buf; + } - UplinkSocket::Message(bi) << "RESV * " << x->Mask << " :" << x->GetReason(); + void SendSQLine(User *, const XLine *x) anope_override + { + UplinkSocket::Message(OperServ) << "RESV * " << x->mask << " :" << x->GetReason(); } void SendSGLineDel(const XLine *x) anope_override { - const BotInfo *bi = findbot(Config->OperServ); - - UplinkSocket::Message(bi) << "UNXLINE * " << x->Mask; + UplinkSocket::Message(OperServ) << "UNXLINE * " << x->mask; } void SendSGLine(User *, const XLine *x) anope_override { - const BotInfo *bi = findbot(Config->OperServ); - - UplinkSocket::Message(bi) << "XLINE * " << x->Mask << " 0 :" << x->GetReason(); + UplinkSocket::Message(OperServ) << "XLINE * " << x->mask << " 0 :" << x->GetReason(); } void SendSZLineDel(const XLine *x) anope_override { - const BotInfo *bi = findbot(Config->OperServ); - - UplinkSocket::Message(bi) << "UNDLINE * " << x->GetHost(); + UplinkSocket::Message(OperServ) << "UNDLINE * " << x->GetHost(); } void SendSZLine(User *, const XLine *x) anope_override { - const BotInfo *bi = findbot(Config->OperServ); /* Calculate the time left before this would expire, capping it at 2 days */ - time_t timeleft = x->Expires - Anope::CurTime; + time_t timeleft = x->expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message(bi) << "DLINE * " << timeleft << " " << x->GetHost() << " :" << x->GetReason(); + UplinkSocket::Message(OperServ) << "DLINE * " << timeleft << " " << x->GetHost() << " :" << x->GetReason(); } void SendAkillDel(const XLine *x) anope_override @@ -82,16 +78,12 @@ class HybridProto : public IRCDProto if (x->IsRegex() || x->HasNickOrReal()) return; - const BotInfo *bi = findbot(Config->OperServ); - - UplinkSocket::Message(bi) << "UNKLINE * " << x->GetUser() << " " << x->GetHost(); + UplinkSocket::Message(OperServ) << "UNKLINE * " << x->GetUser() << " " << x->GetHost(); } void SendSQLineDel(const XLine *x) anope_override { - const BotInfo *bi = findbot(Config->OperServ); - - UplinkSocket::Message(bi) << "UNRESV * " << x->Mask; + UplinkSocket::Message(OperServ) << "UNRESV * " << x->mask; } void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override @@ -111,14 +103,12 @@ class HybridProto : public IRCDProto UserContainer *uc = c->FindUser(user); if (uc != NULL) - *uc->Status = *status; + *uc->status = *status; } } void SendAkill(User *u, XLine *x) anope_override { - const BotInfo *bi = findbot(Config->OperServ); - if (x->IsRegex() || x->HasNickOrReal()) { if (!u) @@ -140,32 +130,35 @@ class HybridProto : public IRCDProto return; /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - XLine *xline = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); + XLine *xline = new XLine("*@" + u->host, old->by, old->expires, old->reason, old->id); old->manager->AddXLine(xline); x = xline; - Log(bi, "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" - << u->realname << " matches " << old->Mask; + Log(OperServ, "akill") << "AKILL: Added an akill for " << x->mask << " because " << u->GetMask() << "#" + << u->realname << " matches " << old->mask; } /* Calculate the time left before this would expire, capping it at 2 days */ - time_t timeleft = x->Expires - Anope::CurTime; + time_t timeleft = x->expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message(bi) << "KLINE * " << timeleft << " " << x->GetUser() << " " << x->GetHost() << " :" << x->GetReason(); + UplinkSocket::Message(OperServ) << "KLINE * " << timeleft << " " << x->GetUser() << " " << x->GetHost() << " :" << x->GetReason(); } void SendServer(const Server *server) anope_override { - UplinkSocket::Message() << "SERVER " << server->GetName() << " " << server->GetHops() << " :" << server->GetDescription(); + if (server == Me) + UplinkSocket::Message() << "SERVER " << server->GetName() << " " << server->GetHops() << " :" << server->GetDescription(); + else + UplinkSocket::Message(Me) << "SID " << server->GetName() << " " << server->GetHops() << " " << server->GetSID() << " :" << server->GetDescription(); } void SendConnect() anope_override { - UplinkSocket::Message() << "PASS " << Config->Uplinks[CurrentUplink]->password << " TS 6 :" << Me->GetSID(); + UplinkSocket::Message() << "PASS " << Config->Uplinks[Anope::CurrentUplink]->password << " TS 6 :" << Me->GetSID(); /* * As of October 13, 2012, ircd-hybrid-8 does support the following capabilities @@ -213,16 +206,12 @@ class HybridProto : public IRCDProto void SendLogin(User *u) anope_override { - const BotInfo *ns = findbot(Config->NickServ); - - ircdproto->SendMode(ns, u, "+d %s", u->Account()->display.c_str()); + IRCD->SendMode(NickServ, u, "+d %s", u->Account()->display.c_str()); } void SendLogout(User *u) anope_override { - const BotInfo *ns = findbot(Config->NickServ); - - ircdproto->SendMode(ns, u, "+d 0"); + IRCD->SendMode(NickServ, u, "+d 0"); } void SendChannel(Channel *c) anope_override @@ -256,13 +245,13 @@ class HybridProto : public IRCDProto struct IRCDMessageBMask : IRCDMessage { - IRCDMessageBMask() : IRCDMessage("BMASK", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageBMask(Module *creator) : IRCDMessage(creator, "BMASK", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* 0 1 2 3 */ /* :0MC BMASK 1350157102 #channel b :*!*@*.test.com */ bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[1]); + Channel *c = Channel::Find(params[1]); if (c) { @@ -270,20 +259,16 @@ struct IRCDMessageBMask : IRCDMessage *except = ModeManager::FindChannelModeByName(CMODE_EXCEPT), *invex = ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE); - Anope::string bans = params[3]; - - int count = myNumToken(bans, ' '), i; - - for (i = 0; i < count; ++i) + spacesepstream bans(params[3]); + Anope::string token; + while (bans.GetToken(token)) { - Anope::string b = myStrGetToken(bans, ' ', i); - if (ban && params[2].equals_cs("b")) - c->SetModeInternal(source, ban, b); + c->SetModeInternal(source, ban, token); else if (except && params[2].equals_cs("e")) - c->SetModeInternal(source, except, b); + c->SetModeInternal(source, except, token); else if (invex && params[2].equals_cs("I")) - c->SetModeInternal(source, invex, b); + c->SetModeInternal(source, invex, token); } } @@ -291,57 +276,36 @@ struct IRCDMessageBMask : IRCDMessage } }; -struct IRCDMessageJoin : CoreIRCDMessageJoin +struct IRCDMessageEOB : IRCDMessage { - IRCDMessageJoin() : CoreIRCDMessageJoin("JOIN") { } + IRCDMessageEOB(Module *craetor) : IRCDMessage(craetor, "EOB", 0) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (params.size() < 2) - return true; - - std::vector<Anope::string> p = params; - p.erase(p.begin()); - - return CoreIRCDMessageJoin::Run(source, p); + source.GetServer()->Sync(true); + return true; } }; -struct IRCDMessageMode : IRCDMessage +struct IRCDMessageJoin : Message::Join { - IRCDMessageMode(const Anope::string &n) : IRCDMessage(n, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageJoin(Module *creator) : Message::Join(creator, "JOIN") { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (params.size() > 2 && ircdproto->IsChannelValid(params[0])) - { - Channel *c = findchan(params[0]); - time_t ts = 0; - - try - { - ts = convertTo<time_t>(params[1]); - } - catch (const ConvertException &) { } - - if (c) - c->SetModesInternal(source, params[2], ts); - } - else - { - User *u = finduser(params[0]); + if (params.size() < 2) + return true; - if (u) - u->SetModesInternal("%s", params[1].c_str()); - } + std::vector<Anope::string> p = params; + p.erase(p.begin()); - return true; + return Message::Join::Run(source, p); } }; struct IRCDMessageNick : IRCDMessage { - IRCDMessageNick() : IRCDMessage("NICK", 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageNick(Module *creator) : IRCDMessage(creator, "NICK", 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } /* 0 1 */ /* :0MCAAAAAB NICK newnick 1350157102 */ @@ -354,7 +318,7 @@ struct IRCDMessageNick : IRCDMessage struct IRCDMessagePass : IRCDMessage { - IRCDMessagePass() : IRCDMessage("PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessagePass(Module *creator) : IRCDMessage(creator, "PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* 0 1 2 3 */ /* PASS password TS 6 0MC */ @@ -367,7 +331,7 @@ struct IRCDMessagePass : IRCDMessage struct IRCDMessagePong : IRCDMessage { - IRCDMessagePong() : IRCDMessage("PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessagePong(Module *creator) : IRCDMessage(creator, "PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -378,7 +342,7 @@ struct IRCDMessagePong : IRCDMessage struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* 0 1 2 */ /* SERVER hades.arpa 1 :ircd-hybrid test server */ @@ -390,14 +354,14 @@ struct IRCDMessageServer : IRCDMessage new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], 1, params[2], UplinkSID); - ircdproto->SendPing(Config->ServerName, params[0]); + IRCD->SendPing(Config->ServerName, params[0]); return true; } }; struct IRCDMessageSID : IRCDMessage { - IRCDMessageSID() : IRCDMessage("SID", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageSID(Module *creator) : IRCDMessage(creator, "SID", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* 0 1 2 3 */ /* :0MC SID hades.arpa 2 4XY :ircd-hybrid test server */ @@ -406,64 +370,37 @@ struct IRCDMessageSID : IRCDMessage unsigned int hops = params[1].is_pos_number_only() ? convertTo<unsigned>(params[1]) : 0; new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], hops, params[3], params[2]); - ircdproto->SendPing(Config->ServerName, params[0]); + IRCD->SendPing(Config->ServerName, params[0]); return true; } }; -struct IRCDMessageSjoin : IRCDMessage +struct IRCDMessageSJoin : IRCDMessage { - IRCDMessageSjoin() : IRCDMessage("SJOIN", 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageSJoin(Module *creator) : IRCDMessage(creator, "SJOIN", 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[1]); - time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[1], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; - - /* If we need to keep their modes, and this SJOIN string contains modes */ - if (keep_their_modes && params.size() >= 3) - { - Anope::string modes; - + Anope::string modes; + if (params.size() >= 3) for (unsigned i = 2; i < params.size() - 1; ++i) modes += " " + params[i]; + if (!modes.empty()) + modes.erase(modes.begin()); - if (!modes.empty()) - modes.erase(modes.begin()); - - /* Set the modes internally */ - c->SetModesInternal(source, modes); - } + std::list<Message::Join::SJoinUser> users; spacesepstream sep(params[params.size() - 1]); Anope::string buf; while (sep.GetToken(buf)) { - std::list<ChannelMode *> Status; - char ch; + Message::Join::SJoinUser sju; /* Get prefixes from the nick */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) + for (char ch; (ch = ModeManager::GetStatusChar(buf[0]));) { buf.erase(buf.begin()); - ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); if (!cm) @@ -472,66 +409,60 @@ struct IRCDMessageSjoin : IRCDMessage continue; } - if (keep_their_modes) - Status.push_back(cm); + sju.first.SetFlag(cm->name); } - User *u = finduser(buf); - - if (!u) + sju.second = User::Find(buf); + if (!sju.second) { - Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << c->name; + Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << params[1]; continue; } - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* - * Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); + users.push_back(sju); + } - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); + time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : Anope::CurTime; + Message::Join::SJoin(source, params[1], ts, modes, users); - /* - * Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; + return true; + } +}; - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); - } +struct IRCDMessageSVSMode : IRCDMessage +{ + IRCDMessageSVSMode(Module *creator) : IRCDMessage(creator, "SVSMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + /* + * parv[0] = nickname + * parv[1] = TS + * parv[2] = mode + * parv[3] = optional argument (services id) + */ + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + User *u = User::Find(params[0]); + if (!u) + return true; - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) - { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } + if (!params[1].is_pos_number_only() || convertTo<time_t>(params[1]) != u->timestamp) + return true; + u->SetModesInternal("%s", params[2].c_str()); return true; } }; struct IRCDMessageTBurst : IRCDMessage { - IRCDMessageTBurst() : IRCDMessage("TBURST", 5) { } + IRCDMessageTBurst(Module *creator) : IRCDMessage(creator, "TBURST", 5) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Anope::string setter = myStrGetToken(params[3], '!', 0); + Anope::string setter; + sepstream(params[3], '!').GetToken(setter, 0); time_t topic_time = Anope::string(params[2]).is_pos_number_only() ? convertTo<time_t>(params[2]) : Anope::CurTime; - Channel *c = findchan(params[1]); + Channel *c = Channel::Find(params[1]); if (c) c->ChangeTopicInternal(setter, params[4], topic_time); @@ -542,7 +473,7 @@ struct IRCDMessageTBurst : IRCDMessage struct IRCDMessageTMode : IRCDMessage { - IRCDMessageTMode() : IRCDMessage("TMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageTMode(Module *creator) : IRCDMessage(creator, "TMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -554,7 +485,7 @@ struct IRCDMessageTMode : IRCDMessage } catch (const ConvertException &) { } - Channel *c = findchan(params[1]); + Channel *c = Channel::Find(params[1]); Anope::string modes = params[2]; for (unsigned i = 3; i < params.size(); ++i) @@ -569,7 +500,7 @@ struct IRCDMessageTMode : IRCDMessage struct IRCDMessageUID : IRCDMessage { - IRCDMessageUID() : IRCDMessage("UID", 10) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageUID(Module *creator) : IRCDMessage(creator, "UID", 10) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* 0 1 2 3 4 5 6 7 8 9 */ /* :0MC UID Steve 1 1350157102 +oi ~steve resolved.host 10.0.0.1 0MCAAAAAB 1350157108 :Mining all the time */ @@ -586,22 +517,22 @@ struct IRCDMessageUID : IRCDMessage params[9], params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0, params[3], params[7]); - if (user && nickserv) + if (user && NickServService) { const NickAlias *na = NULL; if (params[8] != "0") - na = findnick(params[8]); + na = NickAlias::Find(params[8]); if (na) { user->Login(na->nc); if (!Config->NoNicknameOwnership && na->nc->HasFlag(NI_UNCONFIRMED) == false) - user->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + user->SetMode(NickServ, UMODE_REGISTERED); } else - nickserv->Validate(user); + NickServService->Validate(user); } return true; @@ -613,33 +544,35 @@ class ProtoHybrid : public Module HybridProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - CoreIRCDMessageWhois core_message_whois; + Message::Away message_away; + Message::Capab message_capab; + Message::Error message_error; + Message::Kick message_kick; + Message::Kill message_kill; + Message::Mode message_mode; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Topic message_topic; + Message::Version message_version; + Message::Whois message_whois; /* Our message handlers */ IRCDMessageBMask message_bmask; + IRCDMessageEOB message_eob; IRCDMessageJoin message_join; - IRCDMessageMode message_mode, message_svsmode; IRCDMessageNick message_nick; IRCDMessagePass message_pass; IRCDMessagePong message_pong; IRCDMessageServer message_server; IRCDMessageSID message_sid; - IRCDMessageSjoin message_sjoin; + IRCDMessageSJoin message_sjoin; + IRCDMessageSVSMode message_svsmode; IRCDMessageTBurst message_tburst; IRCDMessageTMode message_tmode; IRCDMessageUID message_uid; @@ -663,12 +596,15 @@ class ProtoHybrid : public Module /* v/h/o/a/q */ ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_VOICE, 'v', '+', 0)); - ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_OP, 'o', '@', 1)); + ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_HALFOP, 'h', '%', 1)); + ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_OP, 'o', '@', 2)); + + /* l/k */ + ModeManager::AddChannelMode(new ChannelModeParam(CMODE_LIMIT, 'l')); + ModeManager::AddChannelMode(new ChannelModeKey('k')); /* Add channel modes */ ModeManager::AddChannelMode(new ChannelMode(CMODE_INVITE, 'i')); - ModeManager::AddChannelMode(new ChannelModeKey('k')); - ModeManager::AddChannelMode(new ChannelModeParam(CMODE_LIMIT, 'l')); ModeManager::AddChannelMode(new ChannelMode(CMODE_MODERATED, 'm')); ModeManager::AddChannelMode(new ChannelMode(CMODE_NOEXTERNAL, 'n')); ModeManager::AddChannelMode(new ChannelMode(CMODE_PRIVATE, 'p')); @@ -681,8 +617,15 @@ class ProtoHybrid : public Module } public: - ProtoHybrid(const Anope::string &modname, const Anope::string &creator) : - Module(modname, creator, PROTOCOL), message_mode("MODE"), message_svsmode("SVSMODE") + ProtoHybrid(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), + message_away(this), message_capab(this), message_error(this), message_kick(this), message_kill(this), + message_mode(this), message_motd(this), message_part(this), message_ping(this), message_privmsg(this), + message_quit(this), message_squit(this), message_stats(this), message_time(this), message_topic(this), + message_version(this), message_whois(this), + + message_bmask(this), message_eob(this), message_join(this), + message_nick(this), message_pass(this), message_pong(this), message_server(this), message_sid(this), + message_sjoin(this), message_svsmode(this), message_tburst(this), message_tmode(this), message_uid(this) { this->SetAuthor("Anope"); this->AddModes(); @@ -691,7 +634,7 @@ public: if (Config->Numeric.empty()) { - Anope::string numeric = ts6_sid_retrieve(); + Anope::string numeric = Servers::TS6_SID_Retrieve(); Me->SetSID(numeric); Config->Numeric = numeric; } @@ -700,10 +643,14 @@ public: it->second->GenerateUID(); } + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; + } + void OnUserNickChange(User *u, const Anope::string &) anope_override { u->RemoveModeInternal(ModeManager::FindUserModeByName(UMODE_REGISTERED)); - ircdproto->SendLogout(u); } }; diff --git a/modules/protocol/inspircd-ts6.h b/modules/protocol/inspircd-ts6.h deleted file mode 100644 index 7e0fe971d..000000000 --- a/modules/protocol/inspircd-ts6.h +++ /dev/null @@ -1,817 +0,0 @@ -/* Inspircd 1.2+ generic TS6 functions - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - -class ChannelModeFlood : public ChannelModeParam -{ - public: - ChannelModeFlood(char modeChar, bool minusNoArg) : ChannelModeParam(CMODE_FLOOD, modeChar, minusNoArg) { } - - bool IsValid(const Anope::string &value) const anope_override - { - try - { - Anope::string rest; - if (!value.empty() && value[0] != ':' && convertTo<int>(value[0] == '*' ? value.substr(1) : value, rest, false) > 0 && rest[0] == ':' && rest.length() > 1 && convertTo<int>(rest.substr(1), rest, false) > 0 && rest.empty()) - return true; - } - catch (const ConvertException &) { } - - return false; - } -}; - -class InspIRCdTS6Proto : public IRCDProto -{ - private: - void SendChgIdentInternal(const Anope::string &nick, const Anope::string &vIdent) - { - if (!has_chgidentmod) - Log() << "CHGIDENT not loaded!"; - else - UplinkSocket::Message(findbot(Config->HostServ)) << "CHGIDENT " << nick << " " << vIdent; - } - - void SendChgHostInternal(const Anope::string &nick, const Anope::string &vhost) - { - if (!has_chghostmod) - Log() << "CHGHOST not loaded!"; - else - UplinkSocket::Message(Me) << "CHGHOST " << nick << " " << vhost; - } - - void SendAddLine(const Anope::string &type, const Anope::string &mask, time_t duration, const Anope::string &addedby, const Anope::string &reason) - { - UplinkSocket::Message(Me) << "ADDLINE " << type << " " << mask << " " << addedby << " " << Anope::CurTime << " " << duration << " :" << reason; - } - - void SendDelLine(const Anope::string &type, const Anope::string &mask) - { - UplinkSocket::Message(Me) << "DELLINE " << type << " " << mask; - } - - protected: - InspIRCdTS6Proto(const Anope::string &name) : IRCDProto(name) - { - DefaultPseudoclientModes = "+I"; - CanSVSNick = true; - CanSetVHost = true; - CanSetVIdent = true; - CanSQLine = true; - CanSZLine = true; - CanSVSHold = true; - CanCertFP = true; - RequiresID = true; - MaxModes = 20; - } - - void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override - { - UplinkSocket::Message(bi) << "NOTICE $" << dest->GetName() << " :" << msg; - } - - void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override - { - UplinkSocket::Message(bi) << "PRIVMSG $" << dest->GetName() << " :" << msg; - } - - void SendAkillDel(const XLine *x) anope_override - { - /* InspIRCd may support regex bans */ - if (x->IsRegex() && has_rlinemod) - { - Anope::string mask = x->Mask; - size_t h = x->Mask.find('#'); - if (h != Anope::string::npos) - mask = mask.replace(h, 1, ' '); - SendDelLine("R", mask); - return; - } - else if (x->IsRegex() || x->HasNickOrReal()) - return; - - SendDelLine("G", x->Mask); - } - - void SendTopic(BotInfo *whosets, Channel *c) anope_override - { - if (has_svstopic_topiclock) - { - UplinkSocket::Message(c->ci->WhoSends()) << "SVSTOPIC " << c->name << " " << c->topic_ts << " " << c->topic_setter << " :" << c->topic; - } - else - { - /* If the last time a topic was set is after the TS we want for this topic we must bump this topic's timestamp to now */ - time_t ts = c->topic_ts; - if (c->topic_time > ts) - ts = Anope::CurTime; - /* But don't modify c->topic_ts, it should remain set to the real TS we want as ci->last_topic_time pulls from it */ - UplinkSocket::Message(whosets) << "FTOPIC " << c->name << " " << ts << " " << c->topic_setter << " :" << c->topic; - } - } - - void SendVhostDel(User *u) anope_override - { - if (u->HasMode(UMODE_CLOAK)) - this->SendChgHostInternal(u->nick, u->chost); - else - this->SendChgHostInternal(u->nick, u->host); - - if (has_chgidentmod && u->GetIdent() != u->GetVIdent()) - this->SendChgIdentInternal(u->nick, u->GetIdent()); - } - - void SendAkill(User *u, XLine *x) anope_override - { - // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) - timeleft = 172800; - - const BotInfo *bi = findbot(Config->OperServ); - /* InspIRCd may support regex bans, if they do we can send this and forget about it */ - if (x->IsRegex() && has_rlinemod) - { - Anope::string mask = x->Mask; - size_t h = x->Mask.find('#'); - if (h != Anope::string::npos) - mask = mask.replace(h, 1, ' '); - SendAddLine("R", mask, timeleft, x->By, x->GetReason()); - return; - } - else if (x->IsRegex() || x->HasNickOrReal()) - { - if (!u) - { - /* No user (this akill was just added), and contains nick and/or realname. Find users that match and ban them */ - for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) - if (x->manager->Check(it->second, x)) - this->SendAkill(it->second, x); - return; - } - - const XLine *old = x; - - if (old->manager->HasEntry("*@" + u->host)) - return; - - /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - x = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); - old->manager->AddXLine(x); - - Log(bi, "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->Mask; - } - - /* ZLine if we can instead */ - try - { - if (x->GetUser() == "*") - { - sockaddrs(x->GetHost()); - ircdproto->SendSZLine(u, x); - return; - } - } - catch (const SocketException &) { } - SendAddLine("G", x->GetUser() + "@" + x->GetHost(), timeleft, x->By, x->GetReason()); - } - - void SendNumericInternal(int numeric, const Anope::string &dest, const Anope::string &buf) anope_override - { - UplinkSocket::Message() << "PUSH " << dest << " ::" << Me->GetName() << " " << numeric << " " << dest << " " << buf; - } - - void SendModeInternal(const BotInfo *source, const Channel *dest, const Anope::string &buf) anope_override - { - UplinkSocket::Message(source) << "FMODE " << dest->name << " " << dest->creation_time << " " << buf; - } - - void SendModeInternal(const BotInfo *bi, const User *u, const Anope::string &buf) anope_override - { - UplinkSocket::Message(bi) << "MODE " << u->GetUID() << " " << buf; - } - - void SendClientIntroduction(const User *u) anope_override - { - Anope::string modes = "+" + u->GetModes(); - UplinkSocket::Message(Me) << "UID " << u->GetUID() << " " << u->timestamp << " " << u->nick << " " << u->host << " " << u->host << " " << u->GetIdent() << " 0.0.0.0 " << u->timestamp << " " << modes << " :" << u->realname; - } - - /* SERVER services-dev.chatspike.net password 0 :Description here */ - void SendServer(const Server *server) anope_override - { - UplinkSocket::Message() << "SERVER " << server->GetName() << " " << Config->Uplinks[CurrentUplink]->password << " " << server->GetHops() << " " << server->GetSID() << " :" << server->GetDescription(); - } - - /* JOIN */ - void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override - { - UplinkSocket::Message(Me) << "FJOIN " << c->name << " " << c->creation_time << " +" << c->GetModes(true, true) << " :," << user->GetUID(); - /* Note that we can send this with the FJOIN but choose not to - * because the mode stacker will handle this and probably will - * merge these modes with +nrt and other mlocked modes - */ - if (status) - { - /* First save the channel status incase uc->Status == status */ - ChannelStatus cs = *status; - /* If the user is internally on the channel with flags, kill them so that - * the stacker will allow this. - */ - UserContainer *uc = c->FindUser(user); - if (uc != NULL) - uc->Status->ClearFlags(); - - BotInfo *setter = findbot(user->nick); - for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) - if (cs.HasFlag(ModeManager::ChannelModes[i]->Name)) - c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); - } - } - - /* UNSQLINE */ - void SendSQLineDel(const XLine *x) anope_override - { - SendDelLine("Q", x->Mask); - } - - /* SQLINE */ - void SendSQLine(User *, const XLine *x) anope_override - { - // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) - timeleft = 172800; - SendAddLine("Q", x->Mask, timeleft, x->By, x->GetReason()); - } - - /* Functions that use serval cmd functions */ - - void SendVhost(User *u, const Anope::string &vIdent, const Anope::string &vhost) anope_override - { - if (!vIdent.empty()) - this->SendChgIdentInternal(u->nick, vIdent); - if (!vhost.empty()) - this->SendChgHostInternal(u->nick, vhost); - } - - void SendConnect() anope_override - { - SendServer(Me); - UplinkSocket::Message(Me) << "BURST"; - Module *enc = ModuleManager::FindFirstOf(ENCRYPTION); - UplinkSocket::Message(Me) << "VERSION :Anope-" << Anope::Version() << " " << Config->ServerName << " :" << ircdproto->GetProtocolName() << " - (" << (enc ? enc->name : "unknown") << ") -- " << Anope::VersionBuildString(); - } - - /* SVSHOLD - set */ - void SendSVSHold(const Anope::string &nick) anope_override - { - const BotInfo *bi = findbot(Config->NickServ); - if (bi) - UplinkSocket::Message(bi) << "SVSHOLD " << nick << " " << Config->NSReleaseTimeout << " :Being held for registered user"; - } - - /* SVSHOLD - release */ - void SendSVSHoldDel(const Anope::string &nick) anope_override - { - const BotInfo *bi = findbot(Config->NickServ); - if (bi) - UplinkSocket::Message(bi) << "SVSHOLD " << nick; - } - - /* UNSZLINE */ - void SendSZLineDel(const XLine *x) anope_override - { - SendDelLine("Z", x->GetHost()); - } - - /* SZLINE */ - void SendSZLine(User *, const XLine *x) anope_override - { - // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) - timeleft = 172800; - SendAddLine("Z", x->GetHost(), timeleft, x->By, x->GetReason()); - } - - void SendSVSJoin(const BotInfo *source, const Anope::string &nick, const Anope::string &chan, const Anope::string &) anope_override - { - User *u = finduser(nick); - UplinkSocket::Message(source) << "SVSJOIN " << u->GetUID() << " " << chan; - } - - void SendSWhois(const BotInfo *, const Anope::string &who, const Anope::string &mask) anope_override - { - User *u = finduser(who); - - UplinkSocket::Message(Me) << "METADATA " << u->GetUID() << " swhois :" << mask; - } - - void SendBOB() anope_override - { - UplinkSocket::Message(Me) << "BURST " << Anope::CurTime; - } - - void SendEOB() anope_override - { - UplinkSocket::Message(Me) << "ENDBURST"; - } - - void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) - { - if (has_globopsmod) - UplinkSocket::Message(source) << "SNONOTICE g :" << buf; - else - UplinkSocket::Message(source) << "SNONOTICE A :" << buf; - } - - void SendLogin(User *u) anope_override - { - if (!u->Account() || u->Account()->HasFlag(NI_UNCONFIRMED)) - return; - - UplinkSocket::Message(Me) << "METADATA " << u->GetUID() << " accountname :" << u->Account()->display; - } - - void SendLogout(User *u) anope_override - { - UplinkSocket::Message(Me) << "METADATA " << u->GetUID() << " accountname :"; - } - - void SendChannel(Channel *c) anope_override - { - UplinkSocket::Message(Me) << "FJOIN " << c->name << " " << c->creation_time << " +" << c->GetModes(true, true) << " :"; - } - - bool IsNickValid(const Anope::string &nick) anope_override - { - /* InspIRCd, like TS6, uses UIDs on collision, so... */ - if (isdigit(nick[0])) - return false; - - return true; - } - - void SendOper(User *u) anope_override - { - } -}; - -struct IRCDMessageEndburst : IRCDMessage -{ - IRCDMessageEndburst() : IRCDMessage("ENDBURST", 0) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - Server *s = source.GetServer(); - - Log(LOG_DEBUG) << "Processed ENDBURST for " << s->GetName(); - - s->Sync(true); - return true; - } -}; - -struct IRCDMessageFHost : IRCDMessage -{ - IRCDMessageFHost(const Anope::string &n) : IRCDMessage(n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - source.GetUser()->SetDisplayedHost(params[0]); - return true; - } -}; - -struct IRCDMessageFJoin : IRCDMessage -{ - IRCDMessageFJoin() : IRCDMessage("FJOIN", 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - Channel *c = findchan(params[0]); - time_t ts = Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[0], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; - - /* If we need to keep their modes, and this FJOIN string contains modes */ - if (keep_their_modes && params.size() >= 3) - { - Anope::string modes; - for (unsigned i = 2; i < params.size() - 1; ++i) - modes += " " + params[i]; - if (!modes.empty()) - modes.erase(modes.begin()); - /* Set the modes internally */ - c->SetModesInternal(source, modes); - } - - spacesepstream sep(params[params.size() - 1]); - Anope::string buf; - while (sep.GetToken(buf)) - { - std::list<ChannelMode *> Status; - - /* Loop through prefixes and find modes for them */ - while (buf[0] != ',') - { - ChannelMode *cm = ModeManager::FindChannelModeByChar(buf[0]); - if (!cm) - { - Log() << "Received unknown mode prefix " << buf[0] << " in FJOIN string"; - buf.erase(buf.begin()); - continue; - } - - buf.erase(buf.begin()); - if (keep_their_modes) - Status.push_back(cm); - } - buf.erase(buf.begin()); - - User *u = finduser(buf); - if (!u) - { - Log(LOG_DEBUG) << "FJOIN for nonexistant user " << buf << " on " << c->name; - continue; - } - - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); - } - - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) - { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } - - return true; - } -}; - -struct IRCDMessageFMode : IRCDMessage -{ - IRCDMessageFMode() : IRCDMessage("FMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - /* :source FMODE #test 12345678 +nto foo */ - - Anope::string modes = params[2]; - for (unsigned n = 3; n < params.size(); ++n) - modes += " " + params[n]; - - Channel *c = findchan(params[0]); - time_t ts; - - try - { - ts = convertTo<time_t>(params[1]); - } - catch (const ConvertException &) - { - ts = 0; - } - - if (c) - c->SetModesInternal(source, modes, ts); - - return true; - } -}; - -struct IRCDMessageFTopic : IRCDMessage -{ - IRCDMessageFTopic() : IRCDMessage("FTOPIC", 4) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - /* :source FTOPIC channel topicts setby :topic */ - - Channel *c = findchan(params[0]); - if (c) - c->ChangeTopicInternal(params[2], params[3], Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : Anope::CurTime); - - return true; - } -}; - -struct IRCDMessageIdle : IRCDMessage -{ - IRCDMessageIdle() : IRCDMessage("IDLE", 1) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - const BotInfo *bi = findbot(params[0]); - if (bi) - UplinkSocket::Message(bi) << "IDLE " << source.GetSource() << " " << start_time << " " << (Anope::CurTime - bi->lastmsg); - return true; - } -}; - -/* - * source = numeric of the sending server - * params[0] = uuid - * params[1] = metadata name - * params[2] = data - */ -struct IRCDMessageMetadata : IRCDMessage -{ - IRCDMessageMetadata() : IRCDMessage("METADATA", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - if (isdigit(params[0][0])) - { - if (params[1].equals_cs("accountname")) - { - User *u = finduser(params[0]); - NickCore *nc = findcore(params[2]); - if (u && nc) - { - u->Login(nc); - - const BotInfo *bi = findbot(Config->NickServ); - const NickAlias *user_na = findnick(u->nick); - if (!Config->NoNicknameOwnership && nickserv && user_na && user_na->nc == nc && user_na->nc->HasFlag(NI_UNCONFIRMED) == false) - u->SetMode(bi, UMODE_REGISTERED); - - /* Sometimes a user connects, we send them the usual "this nickname is registered" mess (if - * their server isn't syncing) and then we receive this.. so tell them about it. - */ - if (u->server->IsSynced() && bi) - u->SendMessage(bi, _("You have been logged in as \2%s\2."), nc->display.c_str()); - } - } - - /* - * possible incoming ssl_cert messages: - * Received: :409 METADATA 409AAAAAA ssl_cert :vTrSe c38070ce96e41cc144ed6590a68d45a6 <...> <...> - * Received: :409 METADATA 409AAAAAC ssl_cert :vTrSE Could not get peer certificate: error:00000000:lib(0):func(0):reason(0) - */ - else if (params[1].equals_cs("ssl_cert")) - { - User *u = finduser(params[0]); - if (!u) - return true; - std::string data = params[2].c_str(); - size_t pos1 = data.find(' ') + 1; - size_t pos2 = data.find(' ', pos1); - if ((pos2 - pos1) >= 32) // inspircd supports md5 and sha1 fingerprint hashes -> size 32 or 40 bytes. - { - u->fingerprint = data.substr(pos1, pos2 - pos1); - FOREACH_MOD(I_OnFingerprint, OnFingerprint(u)); - } - } - } - else if (params[0][0] == '#') - { - } - else if (params[0] == "*") - { - // Wed Oct 3 15:40:27 2012: S[14] O :20D METADATA * modules :-m_svstopic.so - - if (params[1].equals_cs("modules") && !params[2].empty()) - { - // only interested when it comes from our uplink - Server* server = source.GetServer(); - if (!server || server->GetUplink() != Me) - return true; - - bool plus = (params[2][0] == '+'); - if (!plus && params[2][0] != '-') - return true; - - bool required = false; - Anope::string module = params[2].substr(1); - - if (module.equals_cs("m_services_account.so")) - required = true; - else if (module.equals_cs("m_hidechans.so")) - required = true; - else if (module.equals_cs("m_chghost.so")) - has_chghostmod = plus; - else if (module.equals_cs("m_chgident.so")) - has_chgidentmod = plus; - else if (module.equals_cs("m_svshold.so")) - ircdproto->CanSVSHold = plus; - else if (module.equals_cs("m_rline.so")) - has_rlinemod = plus; - else if (module.equals_cs("m_topiclock.so")) - has_svstopic_topiclock = plus; - else - return true; - - if (required) - { - if (!plus) - Log() << "Warning: InspIRCd unloaded module " << module << ", Anope won't function correctly without it"; - } - else - { - Log() << "InspIRCd " << (plus ? "loaded" : "unloaded") << " module " << module << ", adjusted functionality"; - } - - } - } - - return true; - } -}; - -struct IRCDMessageMode : IRCDMessage -{ - IRCDMessageMode() : IRCDMessage("MODE", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - if (ircdproto->IsChannelValid(params[0])) - { - Channel *c = findchan(params[0]); - - Anope::string modes = params[1]; - for (unsigned n = 2; n < params.size(); ++n) - modes += " " + params[n]; - - if (c) - c->SetModesInternal(source, modes); - } - else - { - /* InspIRCd lets opers change another - users modes, we have to kludge this - as it slightly breaks RFC1459 - */ - User *u = source.GetUser(); - // This can happen with server-origin modes. - if (!u) - u = finduser(params[0]); - // if it's still null, drop it like fire. - // most likely situation was that server introduced a nick which we subsequently akilled - if (u) - u->SetModesInternal("%s", params[1].c_str()); - } - - return true; - } -}; - -struct IRCDMessageNick : IRCDMessage -{ - IRCDMessageNick() : IRCDMessage("NICK", 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - source.GetUser()->ChangeNick(params[0]); - return true; - } -}; - -struct IRCDMessageOperType : IRCDMessage -{ - IRCDMessageOperType() : IRCDMessage("OPERTYPE", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - /* opertype is equivalent to mode +o because servers - dont do this directly */ - User *u = source.GetUser(); - if (!u->HasMode(UMODE_OPER)) - u->SetModesInternal("+o"); - - return true; - } -}; - -struct IRCDMessageRSQuit : IRCDMessage -{ - IRCDMessageRSQuit() : IRCDMessage("RSQUIT", 1) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - Server *s = Server::Find(params[0]); - if (!s) - return true; - - /* On InspIRCd we must send a SQUIT when we recieve RSQUIT for a server we have juped */ - if (s->HasFlag(SERVER_JUPED)) - UplinkSocket::Message(Me) << "SQUIT " << s->GetSID() << " :" << (params.size() > 1 ? params[1].c_str() : ""); - - FOREACH_MOD(I_OnServerQuit, OnServerQuit(s)); - - s->Delete(s->GetName() + " " + s->GetUplink()->GetName()); - - return true; - } -}; - -struct IRCDMessageServer : IRCDMessage -{ - IRCDMessageServer() : IRCDMessage("SERVER", 5) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - /* - * [Nov 04 00:08:46.308435 2009] debug: Received: SERVER irc.inspircd.com pass 0 964 :Testnet Central! - * 0: name - * 1: pass - * 2: hops - * 3: numeric - * 4: desc - */ - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - unsigned int hops = Anope::string(params[2]).is_pos_number_only() ? convertTo<unsigned>(params[2]) : 0; - new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], hops, params[4], params[3]); - return true; - } -}; - -struct IRCDMessageTime : IRCDMessage -{ - IRCDMessageTime() : IRCDMessage("TIME", 2) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - UplinkSocket::Message(Me) << "TIME " << source.GetSource() << " " << params[1] << " " << Anope::CurTime; - return true; - } -}; - -struct IRCDMessageUID : IRCDMessage -{ - IRCDMessageUID() : IRCDMessage("UID", 8) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - /* - * [Nov 03 22:09:58.176252 2009] debug: Received: :964 UID 964AAAAAC 1225746297 w00t2 localhost testnet.user w00t 127.0.0.1 1225746302 +iosw +ACGJKLNOQcdfgjklnoqtx :Robin Burchell <w00t@inspircd.org> - * 0: uid - * 1: ts - * 2: nick - * 3: host - * 4: dhost - * 5: ident - * 6: ip - * 7: signon - * 8+: modes and params -- IMPORTANT, some modes (e.g. +s) may have parameters. So don't assume a fixed position of realname! - * last: realname - */ - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - time_t ts = convertTo<time_t>(params[1]); - - Anope::string modes = params[8]; - for (unsigned i = 9; i < params.size() - 1; ++i) - modes += " " + params[i]; - - User *u = new User(params[2], params[5], params[3], params[4], params[6], source.GetServer(), params[params.size() - 1], ts, modes, params[0]); - if (u->server->IsSynced() && nickserv) - nickserv->Validate(u); - - return true; - } -}; - diff --git a/modules/protocol/inspircd11.cpp b/modules/protocol/inspircd11.cpp index 1ac97ddcc..aaaec9fef 100644 --- a/modules/protocol/inspircd11.cpp +++ b/modules/protocol/inspircd11.cpp @@ -45,7 +45,7 @@ class InspIRCdProto : public IRCDProto { if (nick.empty() || vIdent.empty()) return; - UplinkSocket::Message(findbot(Config->OperServ)) << "CHGIDENT " << nick << " " << vIdent; + UplinkSocket::Message(OperServ) << "CHGIDENT " << nick << " " << vIdent; } else Log() << "CHGIDENT not loaded!"; @@ -57,7 +57,7 @@ class InspIRCdProto : public IRCDProto { if (nick.empty() || vhost.empty()) return; - UplinkSocket::Message(findbot(Config->OperServ)) << "CHGHOST " << nick << " " << vhost; + UplinkSocket::Message(OperServ) << "CHGHOST " << nick << " " << vhost; } else Log() << "CHGHOST not loaded!"; @@ -84,13 +84,13 @@ class InspIRCdProto : public IRCDProto if (x->GetUser() == "*") { sockaddrs(x->GetHost()); - ircdproto->SendSZLineDel(x); + IRCD->SendSZLineDel(x); return; } } catch (const SocketException &) { } - UplinkSocket::Message(findbot(Config->OperServ)) << "GLINE " << x->Mask; + UplinkSocket::Message(OperServ) << "GLINE " << x->mask; } void SendTopic(BotInfo *whosets, Channel *c) anope_override @@ -128,10 +128,10 @@ class InspIRCdProto : public IRCDProto return; /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - x = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); + x = new XLine("*@" + u->host, old->by, old->expires, old->reason, old->id); old->manager->AddXLine(x); - Log(findbot(Config->OperServ), "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->Mask; + Log(OperServ, "akill") << "AKILL: Added an akill for " << x->mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->mask; } /* ZLine if we can instead */ @@ -140,17 +140,17 @@ class InspIRCdProto : public IRCDProto if (x->GetUser() == "*") { sockaddrs(x->GetHost()); - ircdproto->SendSZLine(u, x); + IRCD->SendSZLine(u, x); return; } } catch (const SocketException &) { } // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message(Me) << "ADDLINE G " << x->Mask << " " << x->By << " " << Anope::CurTime << " " << timeleft << " :" << x->GetReason(); + UplinkSocket::Message(Me) << "ADDLINE G " << x->mask << " " << x->by << " " << Anope::CurTime << " " << timeleft << " :" << x->GetReason(); } void SendSVSKillInternal(const BotInfo *source, User *user, const Anope::string &buf) anope_override @@ -214,11 +214,11 @@ class InspIRCdProto : public IRCDProto */ UserContainer *uc = c->FindUser(user); if (uc != NULL) - uc->Status->ClearFlags(); + uc->status->ClearFlags(); - BotInfo *setter = findbot(user->nick); + BotInfo *setter = BotInfo::Find(user->nick); for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) - if (cs.HasFlag(ModeManager::ChannelModes[i]->Name)) + if (cs.HasFlag(ModeManager::ChannelModes[i]->name)) c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); } } @@ -226,17 +226,17 @@ class InspIRCdProto : public IRCDProto /* UNSQLINE */ void SendSQLineDel(const XLine *x) anope_override { - UplinkSocket::Message(findbot(Config->OperServ)) << "QLINE " << x->Mask; + UplinkSocket::Message(OperServ) << "QLINE " << x->mask; } /* SQLINE */ void SendSQLine(User *, const XLine *x) anope_override { // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message(Me) << "ADDLINE Q " << x->Mask << " " << x->By << " " << Anope::CurTime << " " << timeleft << " :" << x->GetReason(); + UplinkSocket::Message(Me) << "ADDLINE Q " << x->mask << " " << x->by << " " << Anope::CurTime << " " << timeleft << " :" << x->GetReason(); } /* Functions that use serval cmd functions */ @@ -251,7 +251,7 @@ class InspIRCdProto : public IRCDProto void SendConnect() anope_override { - current_pass = Config->Uplinks[CurrentUplink]->password; + current_pass = Config->Uplinks[Anope::CurrentUplink]->password; SendServer(Me); UplinkSocket::Message() << "BURST"; Module *enc = ModuleManager::FindFirstOf(ENCRYPTION); @@ -261,29 +261,29 @@ class InspIRCdProto : public IRCDProto /* SVSHOLD - set */ void SendSVSHold(const Anope::string &nick) anope_override { - UplinkSocket::Message(findbot(Config->OperServ)) << "SVSHOLD " << nick << " " << Config->NSReleaseTimeout << "s :Being held for registered user"; + UplinkSocket::Message(OperServ) << "SVSHOLD " << nick << " " << Config->NSReleaseTimeout << "s :Being held for registered user"; } /* SVSHOLD - release */ void SendSVSHoldDel(const Anope::string &nick) anope_override { - UplinkSocket::Message(findbot(Config->OperServ)) << "SVSHOLD " << nick; + UplinkSocket::Message(OperServ) << "SVSHOLD " << nick; } /* UNSZLINE */ void SendSZLineDel(const XLine *x) anope_override { - UplinkSocket::Message(findbot(Config->OperServ)) << "ZLINE " << x->GetHost(); + UplinkSocket::Message(OperServ) << "ZLINE " << x->GetHost(); } /* SZLINE */ void SendSZLine(User *, const XLine *x) anope_override { // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message(Me) << "ADDLINE Z " << x->GetHost() << " " << x->By << " " << Anope::CurTime << " " << timeleft << " :" << x->GetReason(); + UplinkSocket::Message(Me) << "ADDLINE Z " << x->GetHost() << " " << x->by << " " << Anope::CurTime << " " << timeleft << " :" << x->GetReason(); } void SendSVSJoin(const BotInfo *source, const Anope::string &nick, const Anope::string &chan, const Anope::string &) anope_override @@ -334,11 +334,11 @@ class ChannelModeFlood : public ChannelModeParam } }; -struct IRCDMessageCapab : IRCDMessage +struct IRCDMessageCapab : Message::Capab { - IRCDMessageCapab() : IRCDMessage("CAPAB", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageCapab(Module *creator) : Message::Capab(creator, "CAPAB") { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - bool Run(MessageSource &, const std::vector<Anope::string> ¶ms) anope_override + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { if (params[0].equals_cs("START")) { @@ -348,7 +348,7 @@ struct IRCDMessageCapab : IRCDMessage has_chghostmod = false; has_chgidentmod = false; has_hidechansmod = false; - ircdproto->CanSVSHold = false; + IRCD->CanSVSHold = false; } else if (params[0].equals_cs("MODULES") && params.size() > 1) { @@ -357,7 +357,7 @@ struct IRCDMessageCapab : IRCDMessage if (params[1].find("m_services.so") != Anope::string::npos) has_servicesmod = true; if (params[1].find("m_svshold.so") != Anope::string::npos) - ircdproto->CanSVSHold = true; + IRCD->CanSVSHold = true; if (params[1].find("m_chghost.so") != Anope::string::npos) has_chghostmod = true; if (params[1].find("m_chgident.so") != Anope::string::npos) @@ -531,7 +531,7 @@ struct IRCDMessageCapab : IRCDMessage else if (capab.find("MAXMODES=") != Anope::string::npos) { Anope::string maxmodes(capab.begin() + 9, capab.end()); - ircdproto->MaxModes = maxmodes.is_pos_number_only() ? convertTo<unsigned>(maxmodes) : 3; + IRCD->MaxModes = maxmodes.is_pos_number_only() ? convertTo<unsigned>(maxmodes) : 3; } } } @@ -540,25 +540,25 @@ struct IRCDMessageCapab : IRCDMessage if (!has_globopsmod) { UplinkSocket::Message() << "ERROR :m_globops is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server does not have the m_globops module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server does not have the m_globops module loaded, and this is required."; + Anope::Quitting = true; return false; } if (!has_servicesmod) { UplinkSocket::Message() << "ERROR :m_services is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server does not have the m_services module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server does not have the m_services module loaded, and this is required."; + Anope::Quitting = true; return false; } if (!has_hidechansmod) { UplinkSocket::Message() << "ERROR :m_hidechans.so is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server deos not have the m_hidechans module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server deos not have the m_hidechans module loaded, and this is required."; + Anope::Quitting = true; return false; } - if (!ircdproto->CanSVSHold) + if (!IRCD->CanSVSHold) Log() << "SVSHOLD missing, Usage disabled until module is loaded."; if (!has_chghostmod) Log() << "CHGHOST missing, Usage disabled until module is loaded."; @@ -566,17 +566,17 @@ struct IRCDMessageCapab : IRCDMessage Log() << "CHGIDENT missing, Usage disabled until module is loaded."; } - return true; + return Message::Capab::Run(source, params); } }; struct IRCDMessageChgIdent : IRCDMessage { - IRCDMessageChgIdent(const Anope::string &n) : IRCDMessage(n, 2) { } + IRCDMessageChgIdent(Module *creator, const Anope::string &n) : IRCDMessage(creator, n, 2) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (!u) { Log(LOG_DEBUG) << "CHGIDENT for nonexistent user " << params[0]; @@ -590,7 +590,7 @@ struct IRCDMessageChgIdent : IRCDMessage struct IRCDMessageChgName : IRCDMessage { - IRCDMessageChgName(const Anope::string &n) : IRCDMessage(n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageChgName(Module *creator, const Anope::string &n) : IRCDMessage(creator, n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -601,7 +601,7 @@ struct IRCDMessageChgName : IRCDMessage struct IRCDMessageEndBurst : IRCDMessage { - IRCDMessageEndBurst() : IRCDMessage("ENDBURST", 0) { } + IRCDMessageEndBurst(Module *creator) : IRCDMessage(creator, "ENDBURST", 0) { } bool Run(MessageSource &, const std::vector<Anope::string> ¶ms) anope_override { @@ -612,7 +612,7 @@ struct IRCDMessageEndBurst : IRCDMessage struct IRCDMessageFHost : IRCDMessage { - IRCDMessageFHost(const Anope::string &n) : IRCDMessage(n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageFHost(Module *creator, const Anope::string &n) : IRCDMessage(creator, n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -623,94 +623,47 @@ struct IRCDMessageFHost : IRCDMessage struct IRCDMessageFJoin : IRCDMessage { - IRCDMessageFJoin() : IRCDMessage("FJOIN", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageFJoin(Module *creator) : IRCDMessage(creator, "FJOIN", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); - time_t ts = Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[0], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; + std::list<Message::Join::SJoinUser> users; spacesepstream sep(params[params.size() - 1]); Anope::string buf; + while (sep.GetToken(buf)) { - std::list<ChannelMode *> Status; - char ch; + Message::Join::SJoinUser sju; /* Loop through prefixes */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) + for (char ch; (ch = ModeManager::GetStatusChar(buf[0]));) { ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); + buf.erase(buf.begin()); if (!cm) { - Log() << "Received unknown mode prefix " << buf[0] << " in FJOIN string"; - buf.erase(buf.begin()); + Log() << "Received unknown mode prefix " << ch << " in FJOIN string"; continue; } - buf.erase(buf.begin()); - if (keep_their_modes) - Status.push_back(cm); + sju.first.SetFlag(cm->name); } /* Erase the , */ buf.erase(buf.begin()); - User *u = finduser(buf); - if (!u) + sju.second = User::Find(buf); + if (!sju.second) { - Log(LOG_DEBUG) << "FJOIN for nonexistant user " << buf << " on " << c->name; + Log(LOG_DEBUG) << "FJOIN for nonexistant user " << buf << " on " << params[0]; continue; } - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); } - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) - { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } + time_t ts = Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : Anope::CurTime; + Message::Join::SJoin(source, params[0], ts, "", users); return true; } @@ -718,13 +671,13 @@ struct IRCDMessageFJoin : IRCDMessage struct IRCDMessageFMode : IRCDMessage { - IRCDMessageFMode() : IRCDMessage("FMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageFMode(Module *creator) : IRCDMessage(creator, "FMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { /* :source FMODE #test 12345678 +nto foo */ - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (!c) return true; time_t ts = Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : 0; @@ -742,11 +695,11 @@ struct IRCDMessageFMode : IRCDMessage struct IRCDMessageFTopic : IRCDMessage { - IRCDMessageFTopic() : IRCDMessage("FTOPIC", 4) { } + IRCDMessageFTopic(Module *creator) : IRCDMessage(creator, "FTOPIC", 4) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c) c->ChangeTopicInternal(params[2], params[3], Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : Anope::CurTime); @@ -756,25 +709,25 @@ struct IRCDMessageFTopic : IRCDMessage struct IRCDMessageIdle : IRCDMessage { - IRCDMessageIdle() : IRCDMessage("IDLE", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageIdle(Module *creator) : IRCDMessage(creator, "IDLE", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - const BotInfo *bi = findbot(params[0]); - UplinkSocket::Message(bi) << "IDLE " << source.GetSource() << " " << start_time << " " << (bi ? Anope::CurTime - bi->lastmsg : 0); + const BotInfo *bi = BotInfo::Find(params[0]); + UplinkSocket::Message(bi) << "IDLE " << source.GetSource() << " " << Anope::StartTime << " " << (bi ? Anope::CurTime - bi->lastmsg : 0); return true; } }; struct IRCDMessageMode : IRCDMessage { - IRCDMessageMode() : IRCDMessage("MODE", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageMode(Module *creator) : IRCDMessage(creator, "MODE", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (ircdproto->IsChannelValid(params[0])) + if (IRCD->IsChannelValid(params[0])) { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); time_t ts; try @@ -791,7 +744,7 @@ struct IRCDMessageMode : IRCDMessage } else { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetModesInternal("%s", params[1].c_str()); } @@ -802,7 +755,7 @@ struct IRCDMessageMode : IRCDMessage struct IRCDMessageNick : IRCDMessage { - IRCDMessageNick() : IRCDMessage("NICK", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageNick(Module *creator) : IRCDMessage(creator, "NICK", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -811,19 +764,19 @@ struct IRCDMessageNick : IRCDMessage time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : Anope::CurTime; User *user = new User(params[1], params[4], params[2], params[3], params[6], source.GetServer(), params[7], ts, params[5]); - if (nickserv) + if (NickServService) { - NickAlias *na = findnick(user->nick); + NickAlias *na = NickAlias::Find(user->nick); Anope::string *svidbuf = na ? na->nc->GetExt<ExtensibleItemClass<Anope::string> *>("authenticationtoken") : NULL; if (na && svidbuf && *svidbuf == params[0]) { NickCore *nc = na->nc; user->Login(nc); if (!Config->NoNicknameOwnership && na->nc->HasFlag(NI_UNCONFIRMED) == false) - user->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + user->SetMode(NickServ, UMODE_REGISTERED); } - else if (nickserv) - nickserv->Validate(user); + else + NickServService->Validate(user); } } else if (params.size() == 1 && source.GetUser()) @@ -835,7 +788,7 @@ struct IRCDMessageNick : IRCDMessage struct IRCDMessageOperType : IRCDMessage { - IRCDMessageOperType() : IRCDMessage("OPERTYPE", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageOperType(Module *creator) : IRCDMessage(creator, "OPERTYPE", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -851,7 +804,7 @@ struct IRCDMessageOperType : IRCDMessage struct IRCDMessageRSQuit : IRCDMessage { - IRCDMessageRSQuit() : IRCDMessage("RSQUIT", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageRSQuit(Module *creator) : IRCDMessage(creator, "RSQUIT", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -873,7 +826,7 @@ struct IRCDMessageRSQuit : IRCDMessage struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -888,22 +841,21 @@ class ProtoInspIRCd : public Module InspIRCdProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageJoin core_message_join; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; + Message::Away message_away; + Message::Error message_error; + Message::Join message_join; + Message::Kick message_kick; + Message::Kill message_kill; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Topic message_topic; + Message::Version message_version; /* Our message handlers */ IRCDMessageCapab message_capab; @@ -934,19 +886,30 @@ class ProtoInspIRCd : public Module public: ProtoInspIRCd(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), - message_chgident("CHGIDENT"), message_setident("SETIDENT"), - message_chgname("CHGNAME"), message_setname("SETNAME"), - message_fhost("FHOST"), message_sethost("SETHOST") + message_away(this), message_error(this), message_join(this), message_kick(this), message_kill(this), + message_motd(this), message_part(this), message_ping(this), message_privmsg(this), message_quit(this), + message_squit(this), message_stats(this), message_time(this), message_topic(this), message_version(this), + + message_capab(this), message_chgident(this, "CHGIDENT"), message_setident(this, "SETIDENT"), + message_chgname(this, "CHGNAME"), message_setname(this, "SETNAME"), message_endburst(this), + message_fhost(this, "FHOST"), message_sethost(this, "SETHOST"), message_fjoin(this), + message_fmode(this), message_ftopic(this), message_idle(this), message_mode(this), + message_nick(this), message_opertype(this), message_rsquit(this), message_server(this) { this->SetAuthor("Anope"); - Capab.insert("NOQUIT"); + Servers::Capab.insert("NOQUIT"); this->AddModes(); ModuleManager::Attach(I_OnUserNickChange, this); } + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; + } + void OnUserNickChange(User *u, const Anope::string &) anope_override { u->RemoveModeInternal(ModeManager::FindUserModeByName(UMODE_REGISTERED)); diff --git a/modules/protocol/inspircd12.cpp b/modules/protocol/inspircd12.cpp index 3d925bd4a..09ba57f00 100644 --- a/modules/protocol/inspircd12.cpp +++ b/modules/protocol/inspircd12.cpp @@ -13,22 +13,354 @@ #include "module.h" -/* inspircd-ts6.h uses these */ static bool has_globopsmod = false; static bool has_chghostmod = false; static bool has_chgidentmod = false; static bool has_rlinemod = false; static bool has_svstopic_topiclock = false; -//static unsigned int spanningtree_proto_ver = 1201; -#include "inspircd-ts6.h" - static bool has_servicesmod = false; static bool has_hidechansmod = false; -class InspIRCd12Proto : public InspIRCdTS6Proto +class ChannelModeFlood : public ChannelModeParam +{ + public: + ChannelModeFlood(char modeChar, bool minusNoArg) : ChannelModeParam(CMODE_FLOOD, modeChar, minusNoArg) { } + + bool IsValid(const Anope::string &value) const anope_override + { + try + { + Anope::string rest; + if (!value.empty() && value[0] != ':' && convertTo<int>(value[0] == '*' ? value.substr(1) : value, rest, false) > 0 && rest[0] == ':' && rest.length() > 1 && convertTo<int>(rest.substr(1), rest, false) > 0 && rest.empty()) + return true; + } + catch (const ConvertException &) { } + + return false; + } +}; + +class InspIRCd12Proto : public IRCDProto { + private: + void SendChgIdentInternal(const Anope::string &nick, const Anope::string &vIdent) + { + if (!has_chgidentmod) + Log() << "CHGIDENT not loaded!"; + else + UplinkSocket::Message(HostServ) << "CHGIDENT " << nick << " " << vIdent; + } + + void SendChgHostInternal(const Anope::string &nick, const Anope::string &vhost) + { + if (!has_chghostmod) + Log() << "CHGHOST not loaded!"; + else + UplinkSocket::Message(Me) << "CHGHOST " << nick << " " << vhost; + } + + void SendAddLine(const Anope::string &type, const Anope::string &mask, time_t duration, const Anope::string &addedby, const Anope::string &reason) + { + UplinkSocket::Message(Me) << "ADDLINE " << type << " " << mask << " " << addedby << " " << Anope::CurTime << " " << duration << " :" << reason; + } + + void SendDelLine(const Anope::string &type, const Anope::string &mask) + { + UplinkSocket::Message(Me) << "DELLINE " << type << " " << mask; + } + public: - InspIRCd12Proto() : InspIRCdTS6Proto("InspIRCd 1.2") { } + InspIRCd12Proto() : IRCDProto("InspIRCd 1.2") + { + DefaultPseudoclientModes = "+I"; + CanSVSNick = true; + CanSetVHost = true; + CanSetVIdent = true; + CanSQLine = true; + CanSZLine = true; + CanSVSHold = true; + CanCertFP = true; + RequiresID = true; + MaxModes = 20; + } + + void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override + { + UplinkSocket::Message(bi) << "NOTICE $" << dest->GetName() << " :" << msg; + } + + void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override + { + UplinkSocket::Message(bi) << "PRIVMSG $" << dest->GetName() << " :" << msg; + } + + void SendAkillDel(const XLine *x) anope_override + { + /* InspIRCd may support regex bans */ + if (x->IsRegex() && has_rlinemod) + { + Anope::string mask = x->mask; + size_t h = x->mask.find('#'); + if (h != Anope::string::npos) + mask = mask.replace(h, 1, ' '); + SendDelLine("R", mask); + return; + } + else if (x->IsRegex() || x->HasNickOrReal()) + return; + + SendDelLine("G", x->mask); + } + + void SendTopic(BotInfo *whosets, Channel *c) anope_override + { + if (has_svstopic_topiclock) + { + UplinkSocket::Message(c->ci->WhoSends()) << "SVSTOPIC " << c->name << " " << c->topic_ts << " " << c->topic_setter << " :" << c->topic; + } + else + { + /* If the last time a topic was set is after the TS we want for this topic we must bump this topic's timestamp to now */ + time_t ts = c->topic_ts; + if (c->topic_time > ts) + ts = Anope::CurTime; + /* But don't modify c->topic_ts, it should remain set to the real TS we want as ci->last_topic_time pulls from it */ + UplinkSocket::Message(whosets) << "FTOPIC " << c->name << " " << ts << " " << c->topic_setter << " :" << c->topic; + } + } + + void SendVhostDel(User *u) anope_override + { + if (u->HasMode(UMODE_CLOAK)) + this->SendChgHostInternal(u->nick, u->chost); + else + this->SendChgHostInternal(u->nick, u->host); + + if (has_chgidentmod && u->GetIdent() != u->GetVIdent()) + this->SendChgIdentInternal(u->nick, u->GetIdent()); + } + + void SendAkill(User *u, XLine *x) anope_override + { + // Calculate the time left before this would expire, capping it at 2 days + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) + timeleft = 172800; + + /* InspIRCd may support regex bans, if they do we can send this and forget about it */ + if (x->IsRegex() && has_rlinemod) + { + Anope::string mask = x->mask; + size_t h = x->mask.find('#'); + if (h != Anope::string::npos) + mask = mask.replace(h, 1, ' '); + SendAddLine("R", mask, timeleft, x->by, x->GetReason()); + return; + } + else if (x->IsRegex() || x->HasNickOrReal()) + { + if (!u) + { + /* No user (this akill was just added), and contains nick and/or realname. Find users that match and ban them */ + for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) + if (x->manager->Check(it->second, x)) + this->SendAkill(it->second, x); + return; + } + + const XLine *old = x; + + if (old->manager->HasEntry("*@" + u->host)) + return; + + /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ + x = new XLine("*@" + u->host, old->by, old->expires, old->reason, old->id); + old->manager->AddXLine(x); + + Log(OperServ, "akill") << "AKILL: Added an akill for " << x->mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->mask; + } + + /* ZLine if we can instead */ + try + { + if (x->GetUser() == "*") + { + sockaddrs(x->GetHost()); + IRCD->SendSZLine(u, x); + return; + } + } + catch (const SocketException &) { } + SendAddLine("G", x->GetUser() + "@" + x->GetHost(), timeleft, x->by, x->GetReason()); + } + + void SendNumericInternal(int numeric, const Anope::string &dest, const Anope::string &buf) anope_override + { + UplinkSocket::Message() << "PUSH " << dest << " ::" << Me->GetName() << " " << numeric << " " << dest << " " << buf; + } + + void SendModeInternal(const BotInfo *source, const Channel *dest, const Anope::string &buf) anope_override + { + UplinkSocket::Message(source) << "FMODE " << dest->name << " " << dest->creation_time << " " << buf; + } + + void SendModeInternal(const BotInfo *bi, const User *u, const Anope::string &buf) anope_override + { + UplinkSocket::Message(bi) << "MODE " << u->GetUID() << " " << buf; + } + + void SendClientIntroduction(const User *u) anope_override + { + Anope::string modes = "+" + u->GetModes(); + UplinkSocket::Message(Me) << "UID " << u->GetUID() << " " << u->timestamp << " " << u->nick << " " << u->host << " " << u->host << " " << u->GetIdent() << " 0.0.0.0 " << u->timestamp << " " << modes << " :" << u->realname; + } + + /* SERVER services-dev.chatspike.net password 0 :Description here */ + void SendServer(const Server *server) anope_override + { + UplinkSocket::Message() << "SERVER " << server->GetName() << " " << Config->Uplinks[Anope::CurrentUplink]->password << " " << server->GetHops() << " " << server->GetSID() << " :" << server->GetDescription(); + } + + /* JOIN */ + void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override + { + UplinkSocket::Message(Me) << "FJOIN " << c->name << " " << c->creation_time << " +" << c->GetModes(true, true) << " :," << user->GetUID(); + /* Note that we can send this with the FJOIN but choose not to + * because the mode stacker will handle this and probably will + * merge these modes with +nrt and other mlocked modes + */ + if (status) + { + /* First save the channel status incase uc->Status == status */ + ChannelStatus cs = *status; + /* If the user is internally on the channel with flags, kill them so that + * the stacker will allow this. + */ + UserContainer *uc = c->FindUser(user); + if (uc != NULL) + uc->status->ClearFlags(); + + BotInfo *setter = BotInfo::Find(user->nick); + for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) + if (cs.HasFlag(ModeManager::ChannelModes[i]->name)) + c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); + } + } + + /* UNSQLINE */ + void SendSQLineDel(const XLine *x) anope_override + { + SendDelLine("Q", x->mask); + } + + /* SQLINE */ + void SendSQLine(User *, const XLine *x) anope_override + { + // Calculate the time left before this would expire, capping it at 2 days + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) + timeleft = 172800; + SendAddLine("Q", x->mask, timeleft, x->by, x->GetReason()); + } + + /* Functions that use serval cmd functions */ + + void SendVhost(User *u, const Anope::string &vIdent, const Anope::string &vhost) anope_override + { + if (!vIdent.empty()) + this->SendChgIdentInternal(u->nick, vIdent); + if (!vhost.empty()) + this->SendChgHostInternal(u->nick, vhost); + } + + void SendConnect() anope_override + { + SendServer(Me); + UplinkSocket::Message(Me) << "BURST"; + Module *enc = ModuleManager::FindFirstOf(ENCRYPTION); + UplinkSocket::Message(Me) << "VERSION :Anope-" << Anope::Version() << " " << Config->ServerName << " :" << IRCD->GetProtocolName() << " - (" << (enc ? enc->name : "unknown") << ") -- " << Anope::VersionBuildString(); + } + + /* SVSHOLD - set */ + void SendSVSHold(const Anope::string &nick) anope_override + { + UplinkSocket::Message(NickServ) << "SVSHOLD " << nick << " " << Config->NSReleaseTimeout << " :Being held for registered user"; + } + + /* SVSHOLD - release */ + void SendSVSHoldDel(const Anope::string &nick) anope_override + { + UplinkSocket::Message(NickServ) << "SVSHOLD " << nick; + } + + /* UNSZLINE */ + void SendSZLineDel(const XLine *x) anope_override + { + SendDelLine("Z", x->GetHost()); + } + + /* SZLINE */ + void SendSZLine(User *, const XLine *x) anope_override + { + // Calculate the time left before this would expire, capping it at 2 days + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) + timeleft = 172800; + SendAddLine("Z", x->GetHost(), timeleft, x->by, x->GetReason()); + } + + void SendSVSJoin(const BotInfo *source, const Anope::string &nick, const Anope::string &chan, const Anope::string &) anope_override + { + User *u = User::Find(nick); + UplinkSocket::Message(source) << "SVSJOIN " << u->GetUID() << " " << chan; + } + + void SendSWhois(const BotInfo *, const Anope::string &who, const Anope::string &mask) anope_override + { + User *u = User::Find(who); + + UplinkSocket::Message(Me) << "METADATA " << u->GetUID() << " swhois :" << mask; + } + + void SendBOB() anope_override + { + UplinkSocket::Message(Me) << "BURST " << Anope::CurTime; + } + + void SendEOB() anope_override + { + UplinkSocket::Message(Me) << "ENDBURST"; + } + + void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) + { + if (has_globopsmod) + UplinkSocket::Message(source) << "SNONOTICE g :" << buf; + else + UplinkSocket::Message(source) << "SNONOTICE A :" << buf; + } + + void SendLogin(User *u) anope_override + { + if (!u->Account() || u->Account()->HasFlag(NI_UNCONFIRMED)) + return; + + UplinkSocket::Message(Me) << "METADATA " << u->GetUID() << " accountname :" << u->Account()->display; + } + + void SendLogout(User *u) anope_override + { + UplinkSocket::Message(Me) << "METADATA " << u->GetUID() << " accountname :"; + } + + void SendChannel(Channel *c) anope_override + { + UplinkSocket::Message(Me) << "FJOIN " << c->name << " " << c->creation_time << " +" << c->GetModes(true, true) << " :"; + } + + void SendOper(User *u) anope_override + { + } }; class InspIRCdExtBan : public ChannelModeList @@ -44,7 +376,7 @@ class InspIRCdExtBan : public ChannelModeList { Anope::string real_mask = mask.substr(2); - Entry en(this->Name, real_mask); + Entry en(this->name, real_mask); if (en.Matches(u)) return true; } @@ -52,7 +384,7 @@ class InspIRCdExtBan : public ChannelModeList { Anope::string real_mask = mask.substr(2); - Channel *c = findchan(real_mask); + Channel *c = Channel::Find(real_mask); if (c != NULL && c->FindUser(u) != NULL) return true; } @@ -82,9 +414,9 @@ class InspIRCdExtBan : public ChannelModeList } }; -struct IRCDMessageCapab : IRCDMessage +struct IRCDMessageCapab : Message::Capab { - IRCDMessageCapab() : IRCDMessage("CAPAB", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageCapab(Module *creator) : Message::Capab(creator, "CAPAB") { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -96,7 +428,7 @@ struct IRCDMessageCapab : IRCDMessage has_chghostmod = false; has_chgidentmod = false; has_hidechansmod = false; - ircdproto->CanSVSHold = false; + IRCD->CanSVSHold = false; } else if (params[0].equals_cs("MODULES") && params.size() > 1) { @@ -105,7 +437,7 @@ struct IRCDMessageCapab : IRCDMessage if (params[1].find("m_services_account.so") != Anope::string::npos) has_servicesmod = true; if (params[1].find("m_svshold.so") != Anope::string::npos) - ircdproto->CanSVSHold = true; + IRCD->CanSVSHold = true; if (params[1].find("m_chghost.so") != Anope::string::npos) has_chghostmod = true; if (params[1].find("m_chgident.so") != Anope::string::npos) @@ -113,7 +445,7 @@ struct IRCDMessageCapab : IRCDMessage if (params[1].find("m_hidechans.so") != Anope::string::npos) has_hidechansmod = true; if (params[1].find("m_servprotect.so") != Anope::string::npos) - ircdproto->DefaultPseudoclientModes = "+Ik"; + IRCD->DefaultPseudoclientModes = "+Ik"; if (params[1].find("m_rline.so") != Anope::string::npos) has_rlinemod = true; } @@ -383,7 +715,7 @@ struct IRCDMessageCapab : IRCDMessage else if (capab.find("MAXMODES=") != Anope::string::npos) { Anope::string maxmodes(capab.begin() + 9, capab.end()); - ircdproto->MaxModes = maxmodes.is_pos_number_only() ? convertTo<unsigned>(maxmodes) : 3; + IRCD->MaxModes = maxmodes.is_pos_number_only() ? convertTo<unsigned>(maxmodes) : 3; } } } @@ -392,25 +724,25 @@ struct IRCDMessageCapab : IRCDMessage if (!has_globopsmod) { UplinkSocket::Message() << "ERROR :m_globops is not loaded. This is required by Anope"; - quitmsg = "Remote server does not have the m_globops module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "Remote server does not have the m_globops module loaded, and this is required."; + Anope::Quitting = true; return false; } if (!has_servicesmod) { UplinkSocket::Message() << "ERROR :m_services_account.so is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server does not have the m_services_account module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server does not have the m_services_account module loaded, and this is required."; + Anope::Quitting = true; return false; } if (!has_hidechansmod) { UplinkSocket::Message() << "ERROR :m_hidechans.so is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server does not have the m_hidechans module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server does not have the m_hidechans module loaded, and this is required."; + Anope::Quitting = true; return false; } - if (!ircdproto->CanSVSHold) + if (!IRCD->CanSVSHold) Log() << "SVSHOLD missing, Usage disabled until module is loaded."; if (!has_chghostmod) Log() << "CHGHOST missing, Usage disabled until module is loaded."; @@ -418,17 +750,19 @@ struct IRCDMessageCapab : IRCDMessage Log() << "CHGIDENT missing, Usage disabled until module is loaded."; } - return true; + Servers::Capab.insert("NOQUIT"); + + return Message::Capab::Run(source, params); } }; struct IRCDMessageChgIdent : IRCDMessage { - IRCDMessageChgIdent() : IRCDMessage("CHGIDENT", 2) { } + IRCDMessageChgIdent(Module *creator) : IRCDMessage(creator, "CHGIDENT", 2) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetIdent(params[1]); return true; @@ -437,7 +771,7 @@ struct IRCDMessageChgIdent : IRCDMessage struct IRCDMessageChgName : IRCDMessage { - IRCDMessageChgName(const Anope::string &n) : IRCDMessage(n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageChgName(Module *creator, const Anope::string &n) : IRCDMessage(creator, n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -446,9 +780,345 @@ struct IRCDMessageChgName : IRCDMessage } }; +struct IRCDMessageEndburst : IRCDMessage +{ + IRCDMessageEndburst(Module *creator) : IRCDMessage(creator, "ENDBURST", 0) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + Server *s = source.GetServer(); + + Log(LOG_DEBUG) << "Processed ENDBURST for " << s->GetName(); + + s->Sync(true); + return true; + } +}; + +struct IRCDMessageFHost : IRCDMessage +{ + IRCDMessageFHost(Module *creator, const Anope::string &n) : IRCDMessage(creator, n, 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + source.GetUser()->SetDisplayedHost(params[0]); + return true; + } +}; + +struct IRCDMessageFJoin : IRCDMessage +{ + IRCDMessageFJoin(Module *creator) : IRCDMessage(creator, "FJOIN", 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + Anope::string modes; + if (params.size() >= 3) + { + for (unsigned i = 2; i < params.size() - 1; ++i) + modes += " " + params[i]; + if (!modes.empty()) + modes.erase(modes.begin()); + } + + std::list<Message::Join::SJoinUser> users; + + spacesepstream sep(params[params.size() - 1]); + Anope::string buf; + while (sep.GetToken(buf)) + { + Message::Join::SJoinUser sju; + + /* Loop through prefixes and find modes for them */ + for (char c; (c = buf[0]) != ',';) + { + ChannelMode *cm = ModeManager::FindChannelModeByChar(c); + if (!cm) + { + Log() << "Received unknown mode prefix " << c << " in FJOIN string"; + continue; + } + + sju.first.SetFlag(cm->name); + } + /* Erase the , */ + buf.erase(buf.begin()); + + sju.second = User::Find(buf); + if (!sju.second) + { + Log(LOG_DEBUG) << "FJOIN for nonexistant user " << buf << " on " << params[0]; + continue; + } + + users.push_back(sju); + } + + time_t ts = Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : Anope::CurTime; + Message::Join::SJoin(source, params[0], ts, "", users); + + return true; + } +}; + +struct IRCDMessageFMode : IRCDMessage +{ + IRCDMessageFMode(Module *creator) : IRCDMessage(creator, "FMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + /* :source FMODE #test 12345678 +nto foo */ + + Anope::string modes = params[2]; + for (unsigned n = 3; n < params.size(); ++n) + modes += " " + params[n]; + + Channel *c = Channel::Find(params[0]); + time_t ts; + + try + { + ts = convertTo<time_t>(params[1]); + } + catch (const ConvertException &) + { + ts = 0; + } + + if (c) + c->SetModesInternal(source, modes, ts); + + return true; + } +}; + +struct IRCDMessageFTopic : IRCDMessage +{ + IRCDMessageFTopic(Module *creator) : IRCDMessage(creator, "FTOPIC", 4) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + /* :source FTOPIC channel topicts setby :topic */ + + Channel *c = Channel::Find(params[0]); + if (c) + c->ChangeTopicInternal(params[2], params[3], Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : Anope::CurTime); + + return true; + } +}; + +struct IRCDMessageIdle : IRCDMessage +{ + IRCDMessageIdle(Module *creator) : IRCDMessage(creator, "IDLE", 1) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + const BotInfo *bi = BotInfo::Find(params[0]); + if (bi) + UplinkSocket::Message(bi) << "IDLE " << source.GetSource() << " " << Anope::StartTime << " " << (Anope::CurTime - bi->lastmsg); + return true; + } +}; + +/* + * source = numeric of the sending server + * params[0] = uuid + * params[1] = metadata name + * params[2] = data + */ +struct IRCDMessageMetadata : IRCDMessage +{ + IRCDMessageMetadata(Module *creator) : IRCDMessage(creator, "METADATA", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + if (isdigit(params[0][0])) + { + if (params[1].equals_cs("accountname")) + { + User *u = User::Find(params[0]); + NickCore *nc = NickCore::Find(params[2]); + if (u && nc) + { + u->Login(nc); + + const NickAlias *user_na = NickAlias::Find(u->nick); + if (!Config->NoNicknameOwnership && user_na && user_na->nc == nc && user_na->nc->HasFlag(NI_UNCONFIRMED) == false) + u->SetMode(NickServ, UMODE_REGISTERED); + + /* Sometimes a user connects, we send them the usual "this nickname is registered" mess (if + * their server isn't syncing) and then we receive this.. so tell them about it. + */ + if (u->server->IsSynced() && NickServ) + u->SendMessage(NickServ, _("You have been logged in as \2%s\2."), nc->display.c_str()); + } + } + + /* + * possible incoming ssl_cert messages: + * Received: :409 METADATA 409AAAAAA ssl_cert :vTrSe c38070ce96e41cc144ed6590a68d45a6 <...> <...> + * Received: :409 METADATA 409AAAAAC ssl_cert :vTrSE Could not get peer certificate: error:00000000:lib(0):func(0):reason(0) + */ + else if (params[1].equals_cs("ssl_cert")) + { + User *u = User::Find(params[0]); + if (!u) + return true; + std::string data = params[2].c_str(); + size_t pos1 = data.find(' ') + 1; + size_t pos2 = data.find(' ', pos1); + if ((pos2 - pos1) >= 32) // inspircd supports md5 and sha1 fingerprint hashes -> size 32 or 40 bytes. + { + u->fingerprint = data.substr(pos1, pos2 - pos1); + FOREACH_MOD(I_OnFingerprint, OnFingerprint(u)); + } + } + } + else if (params[0][0] == '#') + { + } + else if (params[0] == "*") + { + // Wed Oct 3 15:40:27 2012: S[14] O :20D METADATA * modules :-m_svstopic.so + + if (params[1].equals_cs("modules") && !params[2].empty()) + { + // only interested when it comes from our uplink + Server* server = source.GetServer(); + if (!server || server->GetUplink() != Me) + return true; + + bool plus = (params[2][0] == '+'); + if (!plus && params[2][0] != '-') + return true; + + bool required = false; + Anope::string module = params[2].substr(1); + + if (module.equals_cs("m_services_account.so")) + required = true; + else if (module.equals_cs("m_hidechans.so")) + required = true; + else if (module.equals_cs("m_chghost.so")) + has_chghostmod = plus; + else if (module.equals_cs("m_chgident.so")) + has_chgidentmod = plus; + else if (module.equals_cs("m_svshold.so")) + IRCD->CanSVSHold = plus; + else if (module.equals_cs("m_rline.so")) + has_rlinemod = plus; + else if (module.equals_cs("m_topiclock.so")) + has_svstopic_topiclock = plus; + else + return true; + + if (required) + { + if (!plus) + Log() << "Warning: InspIRCd unloaded module " << module << ", Anope won't function correctly without it"; + } + else + { + Log() << "InspIRCd " << (plus ? "loaded" : "unloaded") << " module " << module << ", adjusted functionality"; + } + + } + } + + return true; + } +}; + +struct IRCDMessageMode : IRCDMessage +{ + IRCDMessageMode(Module *creator) : IRCDMessage(creator, "MODE", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + if (IRCD->IsChannelValid(params[0])) + { + Channel *c = Channel::Find(params[0]); + + Anope::string modes = params[1]; + for (unsigned n = 2; n < params.size(); ++n) + modes += " " + params[n]; + + if (c) + c->SetModesInternal(source, modes); + } + else + { + /* InspIRCd lets opers change another + users modes, we have to kludge this + as it slightly breaks RFC1459 + */ + User *u = source.GetUser(); + // This can happen with server-origin modes. + if (!u) + u = User::Find(params[0]); + // if it's still null, drop it like fire. + // most likely situation was that server introduced a nick which we subsequently akilled + if (u) + u->SetModesInternal("%s", params[1].c_str()); + } + + return true; + } +}; + +struct IRCDMessageNick : IRCDMessage +{ + IRCDMessageNick(Module *creator) : IRCDMessage(creator, "NICK", 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + source.GetUser()->ChangeNick(params[0]); + return true; + } +}; + +struct IRCDMessageOperType : IRCDMessage +{ + IRCDMessageOperType(Module *creator) : IRCDMessage(creator, "OPERTYPE", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_USER); } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + /* opertype is equivalent to mode +o because servers + dont do this directly */ + User *u = source.GetUser(); + if (!u->HasMode(UMODE_OPER)) + u->SetModesInternal("+o"); + + return true; + } +} +; +struct IRCDMessageRSQuit : IRCDMessage +{ + IRCDMessageRSQuit(Module *creator) : IRCDMessage(creator, "RSQUIT", 1) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + Server *s = Server::Find(params[0]); + if (!s) + return true; + + /* On InspIRCd we must send a SQUIT when we recieve RSQUIT for a server we have juped */ + if (s->HasFlag(SERVER_JUPED)) + UplinkSocket::Message(Me) << "SQUIT " << s->GetSID() << " :" << (params.size() > 1 ? params[1].c_str() : ""); + + FOREACH_MOD(I_OnServerQuit, OnServerQuit(s)); + + s->Delete(s->GetName() + " " + s->GetUplink()->GetName()); + + return true; + } +}; + struct IRCDMessageSetIdent : IRCDMessage { - IRCDMessageSetIdent() : IRCDMessage("SETIDENT", 0) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageSetIdent(Module *creator) : IRCDMessage(creator, "SETIDENT", 0) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -457,28 +1127,94 @@ struct IRCDMessageSetIdent : IRCDMessage } }; +struct IRCDMessageServer : IRCDMessage +{ + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 5) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + + /* + * [Nov 04 00:08:46.308435 2009] debug: Received: SERVER irc.inspircd.com pass 0 964 :Testnet Central! + * 0: name + * 1: pass + * 2: hops + * 3: numeric + * 4: desc + */ + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + unsigned int hops = Anope::string(params[2]).is_pos_number_only() ? convertTo<unsigned>(params[2]) : 0; + new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], hops, params[4], params[3]); + return true; + } +}; + +struct IRCDMessageTime : IRCDMessage +{ + IRCDMessageTime(Module *creator) : IRCDMessage(creator, "TIME", 2) { } + + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + UplinkSocket::Message(Me) << "TIME " << source.GetSource() << " " << params[1] << " " << Anope::CurTime; + return true; + } +}; + +struct IRCDMessageUID : IRCDMessage +{ + IRCDMessageUID(Module *creator) : IRCDMessage(creator, "UID", 8) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + + /* + * [Nov 03 22:09:58.176252 2009] debug: Received: :964 UID 964AAAAAC 1225746297 w00t2 localhost testnet.user w00t 127.0.0.1 1225746302 +iosw +ACGJKLNOQcdfgjklnoqtx :Robin Burchell <w00t@inspircd.org> + * 0: uid + * 1: ts + * 2: nick + * 3: host + * 4: dhost + * 5: ident + * 6: ip + * 7: signon + * 8+: modes and params -- IMPORTANT, some modes (e.g. +s) may have parameters. So don't assume a fixed position of realname! + * last: realname + */ + bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override + { + time_t ts = convertTo<time_t>(params[1]); + + Anope::string modes = params[8]; + for (unsigned i = 9; i < params.size() - 1; ++i) + modes += " " + params[i]; + + User *u = new User(params[2], params[5], params[3], params[4], params[6], source.GetServer(), params[params.size() - 1], ts, modes, params[0]); + if (u->server->IsSynced() && NickServService) + NickServService->Validate(u); + + return true; + } +}; + class ProtoInspIRCd : public Module { InspIRCd12Proto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageJoin core_message_join; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - - /* inspircd-ts6.h message handlers */ + Message::Away message_away; + Message::Error message_error; + Message::Join message_join; + Message::Kick message_kick; + Message::Kill message_kill; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Topic message_topic; + Message::Version message_version; + + /* Our message handlers */ + IRCDMessageChgIdent message_chgident; + IRCDMessageChgName message_setname, message_chgname; + IRCDMessageCapab message_capab; IRCDMessageEndburst message_endburst; IRCDMessageFHost message_fhost, message_sethost; IRCDMessageFJoin message_sjoin; @@ -490,31 +1226,30 @@ class ProtoInspIRCd : public Module IRCDMessageNick message_nick; IRCDMessageOperType message_opertype; IRCDMessageRSQuit message_rsquit; + IRCDMessageSetIdent message_setident; IRCDMessageServer message_server; IRCDMessageTime message_time; IRCDMessageUID message_uid; - /* Our message handlers */ - IRCDMessageChgIdent message_chgident; - IRCDMessageChgName message_setname, message_chgname; - IRCDMessageCapab message_capab; - IRCDMessageSetIdent message_setident; - public: ProtoInspIRCd(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), - message_fhost("FHOST"), message_sethost("SETHOST"), - message_setname("SETNAME"), message_chgname("FNAME") + message_away(this), message_error(this), message_join(this), message_kick(this), message_kill(this), + message_motd(this), message_part(this), message_ping(this), message_privmsg(this), message_quit(this), + message_squit(this), message_stats(this), message_topic(this), message_version(this), + + message_chgident(this), message_setname(this, "SETNAME"), message_chgname(this, "FNAME"), message_capab(this), message_endburst(this), + message_fhost(this, "FHOST"), message_sethost(this, "SETHOST"), message_sjoin(this), message_fmode(this), message_ftopic(this), + message_idle(this), message_metadata(this), message_mode(this), message_nick(this), message_opertype(this), message_rsquit(this), + message_setident(this), message_server(this), message_time(this), message_uid(this) { this->SetAuthor("Anope"); - Capab.insert("NOQUIT"); - Implementation i[] = { I_OnUserNickChange, I_OnServerSync }; ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); if (Config->Numeric.empty()) { - Anope::string numeric = ts6_sid_retrieve(); + Anope::string numeric = Servers::TS6_SID_Retrieve(); Me->SetSID(numeric); Config->Numeric = numeric; } @@ -523,22 +1258,27 @@ class ProtoInspIRCd : public Module it->second->GenerateUID(); } + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; + } + void OnUserNickChange(User *u, const Anope::string &) anope_override { /* InspIRCd 1.2 doesn't set -r on nick change, remove -r here. Note that if we have to set +r later * this will cancel out this -r, resulting in no mode changes. */ - u->RemoveMode(findbot(Config->NickServ), UMODE_REGISTERED); + u->RemoveMode(NickServ, UMODE_REGISTERED); } void OnServerSync(Server *s) anope_override { - if (nickserv) + if (NickServService) for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) { User *u = it->second; if (u->server == s && !u->IsIdentified()) - nickserv->Validate(u); + NickServService->Validate(u); } } }; diff --git a/modules/protocol/inspircd20.cpp b/modules/protocol/inspircd20.cpp index 9bb3d9e1a..85cfd9088 100644 --- a/modules/protocol/inspircd20.cpp +++ b/modules/protocol/inspircd20.cpp @@ -13,29 +13,67 @@ #include "module.h" -/* inspircd-ts6.h uses these */ static bool has_chghostmod = false; static bool has_chgidentmod = false; -static bool has_globopsmod = true; // Not a typo static bool has_rlinemod = false; static bool has_svstopic_topiclock = false; static unsigned int spanningtree_proto_ver = 0; -#include "inspircd-ts6.h" - static bool has_servicesmod = false; -class InspIRCd20Proto : public InspIRCdTS6Proto +static IRCDProto *insp12; + +class InspIRCd20Proto : public IRCDProto { public: - InspIRCd20Proto() : InspIRCdTS6Proto("InspIRCd 2.0") { } + InspIRCd20Proto() : IRCDProto("InspIRCd 2.0") + { + DefaultPseudoclientModes = "+I"; + CanSVSNick = true; + CanSetVHost = true; + CanSetVIdent = true; + CanSQLine = true; + CanSZLine = true; + CanSVSHold = true; + CanCertFP = true; + RequiresID = true; + MaxModes = 20; + } void SendConnect() anope_override { UplinkSocket::Message() << "CAPAB START 1202"; UplinkSocket::Message() << "CAPAB CAPABILITIES :PROTOCOL=1202"; UplinkSocket::Message() << "CAPAB END"; - InspIRCdTS6Proto::SendConnect(); + insp12->SendConnect(); } + + void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { insp12->SendGlobalNotice(bi, dest, msg); } + void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { insp12->SendGlobalPrivmsg(bi, dest, msg); } + void SendAkillDel(const XLine *x) anope_override { insp12->SendAkillDel(x); } + void SendTopic(BotInfo *whosets, Channel *c) anope_override { insp12->SendTopic(whosets, c); }; + void SendVhostDel(User *u) anope_override { insp12->SendVhostDel(u); } + void SendAkill(User *u, XLine *x) anope_override { insp12->SendAkill(u, x); } + void SendNumericInternal(int numeric, const Anope::string &dest, const Anope::string &buf) anope_override { insp12->SendNumericInternal(numeric, dest, buf); } + void SendModeInternal(const BotInfo *source, const Channel *dest, const Anope::string &buf) anope_override { insp12->SendModeInternal(source, dest, buf); } + void SendModeInternal(const BotInfo *bi, const User *u, const Anope::string &buf) anope_override { insp12->SendModeInternal(bi, u, buf); } + void SendClientIntroduction(const User *u) anope_override { insp12->SendClientIntroduction(u); } + void SendServer(const Server *server) anope_override { insp12->SendServer(server); } + void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override { insp12->SendJoin(user, c, status); } + void SendSQLineDel(const XLine *x) anope_override { insp12->SendSQLineDel(x); } + void SendSQLine(User *u, const XLine *x) anope_override { insp12->SendSQLine(u, x); } + void SendVhost(User *u, const Anope::string &vident, const Anope::string &vhost) anope_override { insp12->SendVhost(u, vident, vhost); } + void SendSVSHold(const Anope::string &nick) anope_override { insp12->SendSVSHold(nick); } + void SendSVSHoldDel(const Anope::string &nick) anope_override { insp12->SendSVSHoldDel(nick); } + void SendSZLineDel(const XLine *x) anope_override { insp12->SendSZLineDel(x); } + void SendSZLine(User *u, const XLine *x) anope_override { insp12->SendSZLine(u, x); } + void SendSVSJoin(const BotInfo *source, const Anope::string &nick, const Anope::string &chan, const Anope::string &other) anope_override { insp12->SendSVSJoin(source, nick, chan, other); } + void SendSWhois(const BotInfo *bi, const Anope::string &who, const Anope::string &mask) anope_override { insp12->SendSWhois(bi, who, mask); } + void SendBOB() anope_override { insp12->SendBOB(); } + void SendEOB() anope_override { insp12->SendEOB(); } + void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) { insp12->SendGlobopsInternal(source, buf); } + void SendLogin(User *u) anope_override { insp12->SendLogin(u); } + void SendLogout(User *u) anope_override { insp12->SendLogout(u); } + void SendChannel(Channel *c) anope_override { insp12->SendChannel(c); } }; class InspIRCdExtBan : public ChannelModeList @@ -51,7 +89,7 @@ class InspIRCdExtBan : public ChannelModeList { Anope::string real_mask = mask.substr(3); - Entry en(this->Name, real_mask); + Entry en(this->name, real_mask); if (en.Matches(u)) return true; } @@ -65,16 +103,16 @@ class InspIRCdExtBan : public ChannelModeList char modeChar = ModeManager::GetStatusChar(channel[0]); channel.erase(channel.begin()); cm = ModeManager::FindChannelModeByChar(modeChar); - if (cm != NULL && cm->Type != MODE_STATUS) + if (cm != NULL && cm->type != MODE_STATUS) cm = NULL; } - Channel *c = findchan(channel); + Channel *c = Channel::Find(channel); if (c != NULL) { UserContainer *uc = c->FindUser(u); if (uc != NULL) - if (cm == NULL || uc->Status->HasFlag(cm->Name)) + if (cm == NULL || uc->status->HasFlag(cm->name)) return true; } } @@ -111,9 +149,28 @@ class InspIRCdExtBan : public ChannelModeList } }; -struct IRCDMessageCapab : IRCDMessage +class ChannelModeFlood : public ChannelModeParam { - IRCDMessageCapab() : IRCDMessage("CAPAB", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + public: + ChannelModeFlood(char modeChar, bool minusNoArg) : ChannelModeParam(CMODE_FLOOD, modeChar, minusNoArg) { } + + bool IsValid(const Anope::string &value) const anope_override + { + try + { + Anope::string rest; + if (!value.empty() && value[0] != ':' && convertTo<int>(value[0] == '*' ? value.substr(1) : value, rest, false) > 0 && rest[0] == ':' && rest.length() > 1 && convertTo<int>(rest.substr(1), rest, false) > 0 && rest.empty()) + return true; + } + catch (const ConvertException &) { } + + return false; + } +}; + +struct IRCDMessageCapab : Message::Capab +{ + IRCDMessageCapab(Module *creator) : Message::Capab(creator, "CAPAB") { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -125,8 +182,8 @@ struct IRCDMessageCapab : IRCDMessage if (spanningtree_proto_ver < 1202) { UplinkSocket::Message() << "ERROR :Protocol mismatch, no or invalid protocol version given in CAPAB START"; - quitmsg = "Protocol mismatch, no or invalid protocol version given in CAPAB START"; - quitting = true; + Anope::QuitReason = "Protocol mismatch, no or invalid protocol version given in CAPAB START"; + Anope::Quitting = true; return false; } @@ -135,7 +192,7 @@ struct IRCDMessageCapab : IRCDMessage has_chghostmod = false; has_chgidentmod = false; has_svstopic_topiclock = false; - ircdproto->CanSVSHold = false; + IRCD->CanSVSHold = false; } else if (params[0].equals_cs("CHANMODES") && params.size() > 1) { @@ -275,7 +332,7 @@ struct IRCDMessageCapab : IRCDMessage else if (modename.equals_cs("servprotect")) { um = new UserMode(UMODE_PROTECTED, modechar[0]); - ircdproto->DefaultPseudoclientModes += "k"; + IRCD->DefaultPseudoclientModes += "k"; } else if (modename.equals_cs("showwhois")) um = new UserMode(UMODE_WHOIS, modechar[0]); @@ -302,7 +359,7 @@ struct IRCDMessageCapab : IRCDMessage while (ssep.GetToken(module)) { if (module.equals_cs("m_svshold.so")) - ircdproto->CanSVSHold = true; + IRCD->CanSVSHold = true; else if (module.find("m_rline.so") == 0) { has_rlinemod = true; @@ -392,7 +449,7 @@ struct IRCDMessageCapab : IRCDMessage else if (capab.find("MAXMODES=") != Anope::string::npos) { Anope::string maxmodes(capab.begin() + 9, capab.end()); - ircdproto->MaxModes = maxmodes.is_pos_number_only() ? convertTo<unsigned>(maxmodes) : 3; + IRCD->MaxModes = maxmodes.is_pos_number_only() ? convertTo<unsigned>(maxmodes) : 3; } else if (capab.find("PREFIX=") != Anope::string::npos) { @@ -403,7 +460,7 @@ struct IRCDMessageCapab : IRCDMessage for (size_t t = 0, end = modes.length(); t < end; ++t) { ChannelMode *cm = ModeManager::FindChannelModeByChar(modes[t]); - if (cm == NULL || cm->Type != MODE_STATUS) + if (cm == NULL || cm->type != MODE_STATUS) { Log() << "CAPAB PREFIX gave unknown channel status mode " << modes[t]; continue; @@ -420,18 +477,18 @@ struct IRCDMessageCapab : IRCDMessage if (!has_servicesmod) { UplinkSocket::Message() << "ERROR :m_services_account.so is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server does not have the m_services_account module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server does not have the m_services_account module loaded, and this is required."; + Anope::Quitting = true; return false; } if (!ModeManager::FindUserModeByName(UMODE_PRIV)) { UplinkSocket::Message() << "ERROR :m_hidechans.so is not loaded. This is required by Anope"; - quitmsg = "ERROR: Remote server does not have the m_hidechans module loaded, and this is required."; - quitting = true; + Anope::QuitReason = "ERROR: Remote server does not have the m_hidechans module loaded, and this is required."; + Anope::Quitting = true; return false; } - if (!ircdproto->CanSVSHold) + if (!IRCD->CanSVSHold) Log() << "SVSHOLD missing, Usage disabled until module is loaded."; if (!has_chghostmod) Log() << "CHGHOST missing, Usage disabled until module is loaded."; @@ -441,15 +498,15 @@ struct IRCDMessageCapab : IRCDMessage Log() << "m_topiclock missing, server side topic locking disabled until module is loaded."; } - return true; + Servers::Capab.insert("NOQUIT"); + + return Message::Capab::Run(source, params); } }; struct IRCDMessageEncap : IRCDMessage { - Module *me; - - IRCDMessageEncap(Module *m) : IRCDMessage("ENCAP", 4), me(m) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageEncap(Module *creator) : IRCDMessage(creator, "ENCAP", 4) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -458,7 +515,7 @@ struct IRCDMessageEncap : IRCDMessage if (params[1] == "CHGIDENT") { - User *u = finduser(params[2]); + User *u = User::Find(params[2]); if (!u || u->server != Me) return true; @@ -467,7 +524,7 @@ struct IRCDMessageEncap : IRCDMessage } else if (params[1] == "CHGHOST") { - User *u = finduser(params[2]); + User *u = User::Find(params[2]); if (!u || u->server != Me) return true; @@ -476,7 +533,7 @@ struct IRCDMessageEncap : IRCDMessage } else if (params[1] == "CHGNAME") { - User *u = finduser(params[2]); + User *u = User::Find(params[2]); if (!u || u->server != Me) return true; @@ -502,7 +559,7 @@ struct IRCDMessageEncap : IRCDMessage { UplinkSocket::Message(Me) << "ENCAP " << this->uid.substr(0, 3) << " SASL " << Me->GetSID() << " " << this->uid << " " << " D F"; - Log(findbot(Config->NickServ)) << "A user failed to identify for account " << this->GetAccount() << " using SASL"; + Log(NickServ) << "A user failed to identify for account " << this->GetAccount() << " using SASL"; } }; @@ -534,7 +591,7 @@ struct IRCDMessageEncap : IRCDMessage if (acc.empty() || pass.empty()) return true; - IdentifyRequest *req = new InspIRCDSASLIdentifyRequest(me, params[2], acc, pass); + IdentifyRequest *req = new InspIRCDSASLIdentifyRequest(this->owner, params[2], acc, pass); FOREACH_MOD(I_OnCheckAuthentication, OnCheckAuthentication(NULL, req)); req->Dispatch(); } @@ -546,7 +603,7 @@ struct IRCDMessageEncap : IRCDMessage struct IRCDMessageFIdent : IRCDMessage { - IRCDMessageFIdent() : IRCDMessage("FIDENT", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageFIdent(Module *creator) : IRCDMessage(creator, "FIDENT", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -557,40 +614,31 @@ struct IRCDMessageFIdent : IRCDMessage class ProtoInspIRCd : public Module { + Module *m_insp12; + InspIRCd20Proto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageJoin core_message_join; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - - /* inspircd-ts6.h message handlers */ - IRCDMessageEndburst message_endburst; - IRCDMessageFHost message_fhost; - IRCDMessageFJoin message_sjoin; - IRCDMessageFMode message_fmode; - IRCDMessageFTopic message_ftopic; - IRCDMessageIdle message_idle; - IRCDMessageMetadata message_metadata; - IRCDMessageMode message_mode; - IRCDMessageNick message_nick; - IRCDMessageOperType message_opertype; - IRCDMessageRSQuit message_rsquit; - IRCDMessageServer message_server; - IRCDMessageTime message_time; - IRCDMessageUID message_uid; + Message::Away message_away; + Message::Error message_error; + Message::Join message_join; + Message::Kick message_kick; + Message::Kill message_kill; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Topic message_topic; + Message::Version message_version; + + /* InspIRCd 1.2 message handlers */ + ServiceAlias message_endburst, message_fhost, message_sjoin, message_fmode, + message_ftopic, message_idle, message_metadata, message_mode, + message_nick, message_opertype, message_rsquit, message_server, + message_time, message_uid; /* Our message handlers */ IRCDMessageCapab message_capab; @@ -604,24 +652,51 @@ class ProtoInspIRCd : public Module public: ProtoInspIRCd(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), - message_fhost("FHOST"), message_encap(this) + message_away(this), message_error(this), message_join(this), message_kick(this), message_kill(this), + message_motd(this), message_part(this), message_ping(this), message_privmsg(this), message_quit(this), + message_squit(this), message_stats(this), message_topic(this), message_version(this), + + message_endburst("IRCDMessage", "inspircd20/endburst", "inspircd12/endburst"), + message_fhost("IRCDMessage", "inspircd20/fhost", "inspircd12/fhost"), + message_sjoin("IRCDMessage", "inspircd20/sjoin", "inspircd12/sjoin"), + message_fmode("IRCDMessage", "inspircd20/mode", "inspircd12/fmode"), + message_ftopic("IRCDMessage", "inspircd20/ftopic", "inspircd12/ftopic"), + message_idle("IRCDMessage", "inspircd20/idle", "inspircd12/idle"), + message_metadata("IRCDMessage", "inspircd20/metadata", "inspircd12/metadata"), + message_mode("IRCDMessage", "inspircd20/mode", "inspircd12/mode"), + message_nick("IRCDMessage", "inspircd20/nick", "inspircd12/nick"), + message_opertype("IRCDMessage", "inspircd20/opertype", "inspircd12/opertype"), + message_rsquit("IRCDMessage", "inspircd20/rsquit", "inspircd12/rsquit"), + message_server("IRCDMessage", "inspircd20/server", "inspircd12/server"), + message_time("IRCDMessage", "inspircd20/time", "inspircd12/time"), + message_uid("IRCDMessage", "inspircd20/uid", "inspircd12/uid"), + + message_capab(this), message_encap(this), message_fident(this) { this->SetAuthor("Anope"); - Capab.insert("NOQUIT"); + if (ModuleManager::LoadModule("inspircd12", User::Find(creator)) != MOD_ERR_OK) + throw ModuleException("Unable to load inspircd12"); + m_insp12 = ModuleManager::FindModule("inspircd12"); + if (!m_insp12) + throw ModuleException("Unable to find inspircd12"); + insp12 = m_insp12->GetIRCDProto(); + if (!insp12) + throw ModuleException("No protocol interface for insp12"); + ModuleManager::DetachAll(m_insp12); Implementation i[] = { I_OnUserNickChange, I_OnServerSync, I_OnChannelCreate, I_OnChanRegistered, I_OnDelChan, I_OnMLock, I_OnUnMLock, I_OnSetChannelOption }; ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); + } - if (Config->Numeric.empty()) - { - Anope::string numeric = ts6_sid_retrieve(); - Me->SetSID(numeric); - Config->Numeric = numeric; - } + ~ProtoInspIRCd() + { + ModuleManager::UnloadModule(m_insp12, NULL); + } - for (botinfo_map::iterator it = BotListByNick->begin(), it_end = BotListByNick->end(); it != it_end; ++it) - it->second->GenerateUID(); + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; } void OnUserNickChange(User *u, const Anope::string &) anope_override @@ -631,13 +706,7 @@ class ProtoInspIRCd : public Module void OnServerSync(Server *s) anope_override { - if (nickserv) - for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) - { - User *u = it->second; - if (u->server == s && !u->IsIdentified()) - nickserv->Validate(u); - } + m_insp12->OnServerSync(s); } void OnChannelCreate(Channel *c) anope_override @@ -673,9 +742,9 @@ class ProtoInspIRCd : public Module EventReturn OnMLock(ChannelInfo *ci, ModeLock *lock) anope_override { ChannelMode *cm = ModeManager::FindChannelModeByName(lock->name); - if (cm && ci->c && (cm->Type == MODE_REGULAR || cm->Type == MODE_PARAM) && Config->UseServerSideMLock) + if (cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Config->UseServerSideMLock) { - Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "") + cm->ModeChar; + Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "") + cm->mchar; SendChannelMetadata(ci->c, "mlock", modes); } @@ -685,9 +754,9 @@ class ProtoInspIRCd : public Module EventReturn OnUnMLock(ChannelInfo *ci, ModeLock *lock) anope_override { ChannelMode *cm = ModeManager::FindChannelModeByName(lock->name); - if (cm && ci->c && (cm->Type == MODE_REGULAR || cm->Type == MODE_PARAM) && Config->UseServerSideMLock) + if (cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Config->UseServerSideMLock) { - Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "").replace_all_cs(cm->ModeChar, ""); + Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "").replace_all_cs(cm->mchar, ""); SendChannelMetadata(ci->c, "mlock", modes); } diff --git a/modules/protocol/ngircd.cpp b/modules/protocol/ngircd.cpp index f822922fa..28d534d2a 100644 --- a/modules/protocol/ngircd.cpp +++ b/modules/protocol/ngircd.cpp @@ -28,15 +28,15 @@ class ngIRCdProto : public IRCDProto void SendAkill(User *u, XLine *x) anope_override { // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message(Me) << "GLINE " << x->Mask << " " << timeleft << " :" << x->GetReason() << " (" << x->By << ")"; + UplinkSocket::Message(Me) << "GLINE " << x->mask << " " << timeleft << " :" << x->GetReason() << " (" << x->by << ")"; } void SendAkillDel(const XLine *x) anope_override { - UplinkSocket::Message(Me) << "GLINE " << x->Mask; + UplinkSocket::Message(Me) << "GLINE " << x->mask; } void SendChannel(Channel *c) anope_override @@ -53,7 +53,7 @@ class ngIRCdProto : public IRCDProto void SendConnect() anope_override { - UplinkSocket::Message() << "PASS " << Config->Uplinks[CurrentUplink]->password << " 0210-IRC+ Anope|" << Anope::VersionShort() << ":CLHMSo P"; + UplinkSocket::Message() << "PASS " << Config->Uplinks[Anope::CurrentUplink]->password << " 0210-IRC+ Anope|" << Anope::VersionShort() << ":CLHMSo P"; /* Make myself known to myself in the serverlist */ SendServer(Me); /* finish the enhanced server handshake and register the connection */ @@ -95,11 +95,11 @@ class ngIRCdProto : public IRCDProto */ UserContainer *uc = c->FindUser(user); if (uc != NULL) - uc->Status->ClearFlags(); + uc->status->ClearFlags(); - BotInfo *setter = findbot(user->nick); + BotInfo *setter = BotInfo::Find(user->nick); for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) - if (cs.HasFlag(ModeManager::ChannelModes[i]->Name)) + if (cs.HasFlag(ModeManager::ChannelModes[i]->name)) c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); } } @@ -176,7 +176,7 @@ class ngIRCdProto : public IRCDProto struct IRCDMessage005 : IRCDMessage { - IRCDMessage005() : IRCDMessage("005", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessage005(Module *creator) : IRCDMessage(creator, "005", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } // Please see <http://www.irc.org/tech_docs/005.html> for details. bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override @@ -193,7 +193,7 @@ struct IRCDMessage005 : IRCDMessage if (parameter == "MODES") { unsigned maxmodes = convertTo<unsigned>(data); - ircdproto->MaxModes = maxmodes; + IRCD->MaxModes = maxmodes; } else if (parameter == "NICKLEN") { @@ -212,7 +212,7 @@ struct IRCDMessage005 : IRCDMessage struct IRCDMessage376 : IRCDMessage { - IRCDMessage376() : IRCDMessage("376", 2) { } + IRCDMessage376(Module *creator) : IRCDMessage(creator, "376", 2) { } /* * :ngircd.dev.anope.de 376 services.anope.de :End of MOTD command @@ -230,7 +230,7 @@ struct IRCDMessage376 : IRCDMessage struct IRCDMessageChaninfo : IRCDMessage { - IRCDMessageChaninfo() : IRCDMessage("CHANINFO", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageChaninfo(Module *creator) : IRCDMessage(creator, "CHANINFO", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* * CHANINFO is used by servers to inform each other about a channel: its @@ -252,7 +252,7 @@ struct IRCDMessageChaninfo : IRCDMessage bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (!c) c = new Channel(params[0]); @@ -284,9 +284,9 @@ struct IRCDMessageChaninfo : IRCDMessage } }; -struct IRCDMessageJoin : IRCDMessage +struct IRCDMessageJoin : Message::Join { - IRCDMessageJoin() : IRCDMessage("JOIN", 1) { } + IRCDMessageJoin(Module *creator) : Message::Join(creator, "JOIN") { } /* * <@po||ux> DukeP: RFC 2813, 4.2.1: the JOIN command on server-server links @@ -296,7 +296,6 @@ struct IRCDMessageJoin : IRCDMessage */ bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *chan; User *user = source.GetUser(); size_t pos = params[0].find('\7'); Anope::string channel, modes; @@ -311,41 +310,16 @@ struct IRCDMessageJoin : IRCDMessage channel = params[0]; } - chan = findchan(channel); - /* Channel doesn't exist, create it */ - if (!chan) - { - chan = new Channel(channel, Anope::CurTime); - chan->SetFlag(CH_SYNCING); - } - - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(user, chan)); + std::vector<Anope::string> new_params; + new_params.push_back(channel); - /* Join the user to the channel */ - chan->JoinUser(user); + Message::Join::Run(source, new_params); if (!modes.empty()) - chan->SetModesInternal(source, modes); - - /* Set the proper modes on the user */ - chan_set_correct_modes(user, chan, 1, true); - - /* Modules may want to allow this user in the channel, check. - * If not, CheckKick will kick/ban them, don't call OnJoinChannel after this as the user will have - * been destroyed - */ - if (MOD_RESULT != EVENT_STOP && (!chan->ci || !chan->ci->CheckKick(user))) - { - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(user, chan)); - } - - /* Channel is done syncing */ - if (chan->HasFlag(CH_SYNCING)) { - /* Unset the syncing flag */ - chan->UnsetFlag(CH_SYNCING); - chan->Sync(); + Channel *c = Channel::Find(channel); + if (c) + c->SetModesInternal(source, modes); } return true; @@ -395,7 +369,7 @@ struct IRCDMessageMetadata : IRCDMessage struct IRCDMessageMode : IRCDMessage { - IRCDMessageMode() : IRCDMessage("MODE", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageMode(Module *creator) : IRCDMessage(creator, "MODE", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } /* * Received: :DukeP MODE #anope +b *!*@*.aol.com @@ -412,16 +386,16 @@ struct IRCDMessageMode : IRCDMessage for (size_t i = 2; i < params.size(); ++i) modes += " " + params[i]; - if (ircdproto->IsChannelValid(params[0])) + if (IRCD->IsChannelValid(params[0])) { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c) c->SetModesInternal(source, modes); } else { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetModesInternal("%s", params[1].c_str()); @@ -432,7 +406,7 @@ struct IRCDMessageMode : IRCDMessage struct IRCDMessageNick : IRCDMessage { - IRCDMessageNick() : IRCDMessage("NICK", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageNick(Module *creator) : IRCDMessage(creator, "NICK", 1) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } /* * NICK - NEW @@ -464,8 +438,8 @@ struct IRCDMessageNick : IRCDMessage { // a new user is connecting to the network User *user = new User(params[0], params[2], params[3], "", "", source.GetServer(), params[6], Anope::CurTime, params[5], ""); - if (user && nickserv) - nickserv->Validate(user); + if (user && NickServService) + NickServService->Validate(user); } else { @@ -477,7 +451,7 @@ struct IRCDMessageNick : IRCDMessage struct IRCDMessageNJoin : IRCDMessage { - IRCDMessageNJoin() : IRCDMessage("NJOIN",2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); }; + IRCDMessageNJoin(Module *creator) : IRCDMessage(creator, "NJOIN",2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); }; /* * RFC 2813, 4.2.2: Njoin Message: @@ -492,76 +466,46 @@ struct IRCDMessageNJoin : IRCDMessage */ bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + std::list<Message::Join::SJoinUser> users; + commasepstream sep(params[1]); Anope::string buf; - - if (!c) - { - c = new Channel(params[0], Anope::CurTime); - c->SetFlag(CH_SYNCING); - } - while (sep.GetToken(buf)) { - std::list<ChannelMode *> Status; - char ch; + + Message::Join::SJoinUser sju; /* Get prefixes from the nick */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) + for (char ch; (ch = ModeManager::GetStatusChar(buf[0]));) { - buf.erase(buf.begin()); ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); + buf.erase(buf.begin()); if (!cm) { Log(LOG_DEBUG) << "Received unknown mode prefix " << ch << " in NJOIN string."; continue; } - Status.push_back(cm); + + sju.first.SetFlag(cm->name); } - User *u = finduser(buf); - if (!u) + + sju.second = User::Find(buf); + if (!sju.second) { - Log(LOG_DEBUG) << "NJOIN for nonexistant user " << buf << " on " << c->name; + Log(LOG_DEBUG) << "NJOIN for nonexistant user " << buf << " on " << params[0]; continue; } + } - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); + Message::Join::SJoin(source, params[0], 0, "", users); - /* Add the user to the Channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); - } /* while */ - - if (c->HasFlag(CH_SYNCING)) - { - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } return true; } }; struct IRCDMessagePong : IRCDMessage { - IRCDMessagePong() : IRCDMessage("PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessagePong(Module *creator) : IRCDMessage(creator, "PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* * ngIRCd does not send an EOB, so we send a PING immediately @@ -578,7 +522,7 @@ struct IRCDMessagePong : IRCDMessage struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } /* * SERVER tolsun.oulu.fi 1 :Experimental server @@ -624,19 +568,19 @@ struct IRCDMessageServer : IRCDMessage * when receiving a new server and then finish sync once we * get a pong back from that server. */ - ircdproto->SendPing(Config->ServerName, params[0]); + IRCD->SendPing(Config->ServerName, params[0]); return true; } }; struct IRCDMessageTopic : IRCDMessage { - IRCDMessageTopic() : IRCDMessage("TOPIC", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageTopic(Module *creator) : IRCDMessage(creator, "TOPIC", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } // Received: :DukeP TOPIC #anope :test bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (!c) { Log(LOG_DEBUG) << "TOPIC for nonexistant channel " << params[0]; @@ -654,19 +598,19 @@ class ProtongIRCd : public Module ngIRCdProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg, core_message_squery; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageVersion core_message_version; + Message::Capab message_capab; + Message::Error message_error; + Message::Kick message_kick; + Message::Kill message_kill; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg, message_squery; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Version message_version; /* Our message handlers */ IRCDMessage005 message_005; @@ -728,11 +672,17 @@ class ProtongIRCd : public Module public: ProtongIRCd(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), - core_message_squery("SQUERY") + message_capab(this), message_error(this), message_kick(this), message_kill(this), message_motd(this), + message_part(this), message_ping(this), message_privmsg(this), message_squery(this, "SQUERY"), + message_quit(this), message_squit(this), message_stats(this), message_time(this), message_version(this), + + message_005(this), message_376(this), message_chaninfo(this), message_join(this), message_mode(this), + message_nick(this), message_njoin(this), message_pong(this), message_server(this), message_topic(this) + { this->SetAuthor("Anope"); - Capab.insert("QS"); + Servers::Capab.insert("QS"); this->AddModes(); @@ -740,6 +690,11 @@ class ProtongIRCd : public Module ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); } + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; + } + void OnUserNickChange(User *u, const Anope::string &) anope_override { u->RemoveModeInternal(ModeManager::FindUserModeByName(UMODE_REGISTERED)); diff --git a/modules/protocol/plexus.cpp b/modules/protocol/plexus.cpp index 432cc3c02..53efdbd88 100644 --- a/modules/protocol/plexus.cpp +++ b/modules/protocol/plexus.cpp @@ -12,6 +12,7 @@ #include "module.h" static Anope::string UplinkSID; +static IRCDProto *hybrid; class PlexusProto : public IRCDProto { @@ -31,51 +32,17 @@ class PlexusProto : public IRCDProto MaxModes = 4; } - void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override - { - UplinkSocket::Message(bi) << "NOTICE $$" << dest->GetName() << " :" << msg; - } - - void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override - { - UplinkSocket::Message(bi) << "PRIVMSG $$" << dest->GetName() << " :" << msg; - } - - void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) anope_override - { - UplinkSocket::Message(source) << "OPERWALL :" << buf; - } - - void SendSQLine(User *, const XLine *x) anope_override - { - UplinkSocket::Message(Me) << "RESV * " << x->Mask << " :" << x->GetReason(); - } - - void SendSGLineDel(const XLine *x) anope_override - { - const BotInfo *bi = findbot(Config->OperServ); - UplinkSocket::Message(bi) << "UNXLINE * " << x->Mask; - } - - void SendSGLine(User *, const XLine *x) anope_override - { - const BotInfo *bi = findbot(Config->OperServ); - UplinkSocket::Message(bi) << "XLINE * " << x->Mask << " 0 :" << x->GetReason(); - } - - void SendAkillDel(const XLine *x) anope_override - { - if (x->IsRegex() || x->HasNickOrReal()) - return; - - const BotInfo *bi = findbot(Config->OperServ); - UplinkSocket::Message(bi) << "UNKLINE * " << x->GetUser() << " " << x->GetHost(); - } - - void SendSQLineDel(const XLine *x) anope_override - { - UplinkSocket::Message(Me) << "UNRESV * " << x->Mask; - } + void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { hybrid->SendGlobalNotice(bi, dest, msg); } + void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { hybrid->SendGlobalPrivmsg(bi, dest, msg); } + void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) anope_override { hybrid->SendGlobopsInternal(source, buf); } + void SendSQLine(User *u, const XLine *x) anope_override { hybrid->SendSQLine(u, x); } + void SendSQLineDel(const XLine *x) anope_override { hybrid->SendSQLineDel(x); } + void SendSGLineDel(const XLine *x) anope_override { hybrid->SendSGLineDel(x); } + void SendSGLine(User *u, const XLine *x) anope_override { hybrid->SendSGLine(u, x); } + void SendAkillDel(const XLine *x) anope_override { hybrid->SendAkillDel(x); } + void SendAkill(User *u, XLine *x) anope_override { hybrid->SendAkill(u, x); } + void SendServer(const Server *server) anope_override { hybrid->SendServer(server); } + void SendChannel(Channel *c) anope_override { hybrid->SendChannel(c); } void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override { @@ -89,82 +56,38 @@ class PlexusProto : public IRCDProto */ UserContainer *uc = c->FindUser(user); if (uc != NULL) - uc->Status->ClearFlags(); + uc->status->ClearFlags(); - BotInfo *setter = findbot(user->nick); + BotInfo *setter = BotInfo::Find(user->nick); for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) - if (cs.HasFlag(ModeManager::ChannelModes[i]->Name)) + if (cs.HasFlag(ModeManager::ChannelModes[i]->name)) c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); } } - void SendAkill(User *u, XLine *x) anope_override - { - const BotInfo *bi = findbot(Config->OperServ); - - if (x->IsRegex() || x->HasNickOrReal()) - { - if (!u) - { - /* No user (this akill was just added), and contains nick and/or realname. Find users that match and ban them */ - for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) - if (x->manager->Check(it->second, x)) - this->SendAkill(it->second, x); - return; - } - - const XLine *old = x; - - if (old->manager->HasEntry("*@" + u->host)) - return; - - /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - XLine *xline = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); - old->manager->AddXLine(xline); - x = xline; - - Log(bi, "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->Mask; - } - - // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) - timeleft = 172800; - UplinkSocket::Message(bi) << "KLINE * " << timeleft << " " << x->GetUser() << " " << x->GetHost() << " :" << x->GetReason(); - } - - void SendServer(const Server *server) anope_override + void SendForceNickChange(const User *u, const Anope::string &newnick, time_t when) anope_override { - if (server == Me) - UplinkSocket::Message() << "SERVER " << server->GetName() << " " << server->GetHops() << " :" << server->GetDescription(); - else - UplinkSocket::Message(Me) << "SID " << server->GetName() << " " << server->GetHops() << " " << server->GetSID() << " :" << server->GetDescription(); + UplinkSocket::Message(Me) << "ENCAP " << u->server->GetName() << " SVSNICK " << u->GetUID() << " " << u->timestamp << " " << newnick << " " << when; } - void SendForceNickChange(const User *u, const Anope::string &newnick, time_t when) anope_override + void SendVhost(User *u, const Anope::string &ident, const Anope::string &host) anope_override { - UplinkSocket::Message(Me) << "ENCAP " << u->server->GetName() << " SVSNICK " << u->GetUID() << " " << u->timestamp << " " << newnick << " " << when; + if (!ident.empty()) + UplinkSocket::Message(Me) << "ENCAP * CHGIDENT " << u->GetUID() << " " << ident; + UplinkSocket::Message(Me) << "ENCAP * CHGHOST " << u->GetUID() << " " << host; } void SendVhostDel(User *u) anope_override { - const BotInfo *bi = findbot(Config->HostServ); if (u->HasMode(UMODE_CLOAK)) - u->RemoveMode(bi, UMODE_CLOAK); + u->RemoveMode(HostServ, UMODE_CLOAK); else this->SendVhost(u, u->GetIdent(), u->chost); } - void SendVhost(User *u, const Anope::string &ident, const Anope::string &host) anope_override - { - if (!ident.empty()) - UplinkSocket::Message(Me) << "ENCAP * CHGIDENT " << u->GetUID() << " " << ident; - UplinkSocket::Message(Me) << "ENCAP * CHGHOST " << u->GetUID() << " " << host; - } - void SendConnect() anope_override { - UplinkSocket::Message() << "PASS " << Config->Uplinks[CurrentUplink]->password << " TS 6 :" << Me->GetSID(); + UplinkSocket::Message() << "PASS " << Config->Uplinks[Anope::CurrentUplink]->password << " TS 6 :" << Me->GetSID(); /* CAPAB * QS - Can handle quit storm removal * EX - Can do channel +e exemptions @@ -227,53 +150,11 @@ class PlexusProto : public IRCDProto { UplinkSocket::Message(bi) << "ENCAP * TOPIC " << c->name << " " << c->topic_setter << " " << c->topic_ts << " :" << c->topic; } - - void SendChannel(Channel *c) anope_override - { - Anope::string modes = c->GetModes(true, true); - if (modes.empty()) - modes = "+"; - UplinkSocket::Message(Me) << "SJOIN " << c->creation_time << " " << c->name << " " << modes << " :"; - } -}; - -struct IRCDMessageBMask : IRCDMessage -{ - IRCDMessageBMask() : IRCDMessage("BMASK", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - /* :42X BMASK 1106409026 #ircops b :*!*@*.aol.com */ - /* 0 1 2 3 */ - Channel *c = findchan(params[1]); - - if (c) - { - ChannelMode *ban = ModeManager::FindChannelModeByName(CMODE_BAN), - *except = ModeManager::FindChannelModeByName(CMODE_EXCEPT), - *invex = ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE); - - Anope::string bans = params[3]; - int count = myNumToken(bans, ' '), i; - for (i = 0; i < count; ++i) - { - Anope::string b = myStrGetToken(bans, ' ', i); - if (ban && params[2].equals_cs("b")) - c->SetModeInternal(source, ban, b); - else if (except && params[2].equals_cs("e")) - c->SetModeInternal(source, except, b); - if (invex && params[2].equals_cs("I")) - c->SetModeInternal(source, invex, b); - } - } - - return true; - } }; struct IRCDMessageEncap : IRCDMessage { - IRCDMessageEncap() : IRCDMessage("ENCAP", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageEncap(Module *creator) : IRCDMessage(creator, "ENCAP", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -286,14 +167,14 @@ struct IRCDMessageEncap : IRCDMessage */ if (params[1].equals_cs("SU")) { - User *u = finduser(params[2]); - const NickAlias *user_na = findnick(params[2]); - NickCore *nc = findcore(params[3]); + User *u = User::Find(params[2]); + const NickAlias *user_na = NickAlias::Find(params[2]); + NickCore *nc = NickCore::Find(params[3]); if (u && nc) { u->Login(nc); if (!Config->NoNicknameOwnership && user_na && user_na->nc == nc && user_na->nc->HasFlag(NI_UNCONFIRMED) == false) - u->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + u->SetMode(NickServ, UMODE_REGISTERED); } } @@ -306,7 +187,7 @@ struct IRCDMessageEncap : IRCDMessage */ else if (params[1].equals_cs("CERTFP")) { - User *u = finduser(params[2]); + User *u = User::Find(params[2]); if (u) { u->fingerprint = params[3]; @@ -317,82 +198,9 @@ struct IRCDMessageEncap : IRCDMessage } }; -struct IRCDMessageEOB : IRCDMessage -{ - IRCDMessageEOB() : IRCDMessage("EOB", 0) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - source.GetServer()->Sync(true); - return true; - } -}; - -struct IRCDMessageJoin : CoreIRCDMessageJoin -{ - IRCDMessageJoin() : CoreIRCDMessageJoin("JOIN") { } - - /* - * params[0] = ts - * params[1] = channel - */ - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - if (params.size() < 2) - return true; - - std::vector<Anope::string> p = params; - p.erase(p.begin()); - - return CoreIRCDMessageJoin::Run(source, p); - } -}; - -struct IRCDMessageMode : IRCDMessage -{ - IRCDMessageMode() : IRCDMessage("MODE", 3) { } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - if (ircdproto->IsChannelValid(params[0])) - { - // 0 = channel, 1 = ts, 2 = modes - Channel *c = findchan(params[0]); - time_t ts = 0; - try - { - ts = convertTo<time_t>(params[1]); - } - catch (const ConvertException &) { } - - if (c) - c->SetModesInternal(source, params[2], ts); - } - else - { - User *u = finduser(params[0]); - if (u) - u->SetModesInternal("%s", params[1].c_str()); - } - - return true; - } -}; - -struct IRCDMessageNick : IRCDMessage -{ - IRCDMessageNick() : IRCDMessage("NICK", 2) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - source.GetUser()->ChangeNick(params[0]); - return true; - } -}; - struct IRCDMessagePass : IRCDMessage { - IRCDMessagePass() : IRCDMessage("PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessagePass(Module *creator) : IRCDMessage(creator, "PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -403,206 +211,25 @@ struct IRCDMessagePass : IRCDMessage struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + /* 0 1 2 */ + /* SERVER hades.arpa 1 :ircd-hybrid test server */ bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - // Servers other then our immediate uplink are introduced via SID + /* Servers other than our immediate uplink are introduced via SID */ if (params[1] != "1") return true; - new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], 1, params[2], UplinkSID); - return true; - } -}; - -struct IRCDMessageSID : IRCDMessage -{ - IRCDMessageSID() : IRCDMessage("SID", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - /* :42X SID trystan.nomadirc.net 2 43X :ircd-plexus test server */ - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - unsigned int hops = params[1].is_pos_number_only() ? convertTo<unsigned>(params[1]) : 0; - new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], hops, params[3], params[2]); - return true; - } -}; - -struct IRCDMessageSJoin : IRCDMessage -{ - IRCDMessageSJoin() : IRCDMessage("SJOIN", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - Channel *c = findchan(params[1]); - time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[1], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; - - /* If we need to keep their modes, and this SJOIN string contains modes */ - if (keep_their_modes && params.size() >= 3) - { - Anope::string modes; - for (unsigned i = 2; i < params.size() - 1; ++i) - modes += " " + params[i]; - if (!modes.empty()) - modes.erase(modes.begin()); - /* Set the modes internally */ - c->SetModesInternal(source, modes); - } - - spacesepstream sep(params[params.size() - 1]); - Anope::string buf; - while (sep.GetToken(buf)) - { - std::list<ChannelMode *> Status; - char ch; - - /* Get prefixes from the nick */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) - { - buf.erase(buf.begin()); - ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); - if (!cm) - { - Log() << "Received unknown mode prefix " << ch << " in SJOIN string"; - continue; - } - - if (keep_their_modes) - Status.push_back(cm); - } - - User *u = finduser(buf); - if (!u) - { - Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << c->name; - continue; - } - - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); - } - - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) - { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } - return true; - } -}; - -struct IRCDMessageTBurst : IRCDMessage -{ - IRCDMessageTBurst() : IRCDMessage("TBURST", 5) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - // 0 1 2 3 4 - // :rizon.server TBURST 1298674830 #lol 1298674833 Adam!Adam@i.has.a.spoof :lol - // chan ts topic ts - - Channel *c = findchan(params[1]); - - try - { - if (!c || c->creation_time < convertTo<time_t>(params[0])) - return true; - } - catch (const ConvertException &) - { - return true; - } - - Anope::string setter = myStrGetToken(params[3], '!', 0); - time_t topic_time = Anope::string(params[2]).is_pos_number_only() ? convertTo<time_t>(params[2]) : Anope::CurTime; - c->ChangeTopicInternal(setter, params.size() > 4 ? params[4] : "", topic_time); - - return true; - } -}; - -struct IRCDMessageTMode : IRCDMessage -{ - IRCDMessageTMode() : IRCDMessage("TMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - time_t ts = 0; - try - { - ts = convertTo<time_t>(params[0]); - } - catch (const ConvertException &) { } - Channel *c = findchan(params[1]); - Anope::string modes = params[2]; - for (unsigned i = 3; i < params.size(); ++i) - modes += " " + params[i]; - - if (c) - c->SetModesInternal(source, modes, ts); - - return true; - } -}; - -struct IRCDMessageTopic : IRCDMessage -{ - IRCDMessageTopic() : IRCDMessage("TOPIC", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - Channel *c = findchan(params[0]); - if (!c) - return true; + new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], 1, params[2], UplinkSID); - c->ChangeTopicInternal(params[1], params[3], Anope::string(params[2]).is_pos_number_only() ? convertTo<time_t>(params[2]) : Anope::CurTime); return true; } }; struct IRCDMessageUID : IRCDMessage { - IRCDMessageUID() : IRCDMessage("UID", 11) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageUID(Module *creator) : IRCDMessage(creator, "UID", 11) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* params[0] = nick @@ -628,12 +255,12 @@ struct IRCDMessageUID : IRCDMessage User *user = new User(params[0], params[4], params[9], params[5], ip, source.GetServer(), params[10], params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0, params[3], params[7]); if (params[8] != "0" && params[8].is_pos_number_only() && convertTo<time_t>(params[8]) == user->timestamp) { - NickAlias *na = findnick(user->nick); + NickAlias *na = NickAlias::Find(user->nick); if (na) user->Login(na->nc); } - else if (user && user->server->IsSynced() && nickserv) - nickserv->Validate(user); + else if (user && user->server->IsSynced() && NickServService) + NickServService->Validate(user); return true; } @@ -641,127 +268,117 @@ struct IRCDMessageUID : IRCDMessage class ProtoPlexus : public Module { + Module *m_hybrid; + PlexusProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - CoreIRCDMessageWhois core_message_whois; + Message::Away message_away; + Message::Capab message_capab; + Message::Error message_error; + Message::Kick message_kick; + Message::Kill message_kill; + Message::Mode message_mode; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Topic message_topic; + Message::Version message_version; + Message::Whois message_whois; + + /* Hybrid message handlers */ + ServiceAlias message_bmask, message_eob, message_join, message_nick, message_sid, message_sjoin, + message_tburst, message_tmode; /* Our message handlers */ - IRCDMessageBMask message_bmask; IRCDMessageEncap message_encap; - IRCDMessageEOB message_eob; - IRCDMessageJoin message_join; - IRCDMessageMode message_mode; - IRCDMessageNick message_nick; IRCDMessagePass message_pass; IRCDMessageServer message_server; - IRCDMessageSID message_sid; - IRCDMessageSJoin message_sjoin; - IRCDMessageTBurst message_tburst; - IRCDMessageTMode message_tmode; - IRCDMessageTopic message_topic; IRCDMessageUID message_uid; void AddModes() { /* Add user modes */ - ModeManager::AddUserMode(new UserMode(UMODE_ADMIN, 'a')); - ModeManager::AddUserMode(new UserMode(UMODE_INVIS, 'i')); - ModeManager::AddUserMode(new UserMode(UMODE_OPER, 'o')); - ModeManager::AddUserMode(new UserMode(UMODE_SNOMASK, 's')); - ModeManager::AddUserMode(new UserMode(UMODE_WALLOPS, 'w')); + ModeManager::RemoveUserMode(ModeManager::FindUserModeByName(UMODE_HIDEOPER)); ModeManager::AddUserMode(new UserMode(UMODE_NOCTCP, 'C')); ModeManager::AddUserMode(new UserMode(UMODE_DEAF, 'D')); ModeManager::AddUserMode(new UserMode(UMODE_SOFTCALLERID, 'G')); ModeManager::AddUserMode(new UserMode(UMODE_NETADMIN, 'N')); - ModeManager::AddUserMode(new UserMode(UMODE_REGPRIV, 'R')); ModeManager::AddUserMode(new UserMode(UMODE_SSL, 'S')); ModeManager::AddUserMode(new UserMode(UMODE_WEBIRC, 'W')); ModeManager::AddUserMode(new UserMode(UMODE_CALLERID, 'g')); ModeManager::AddUserMode(new UserMode(UMODE_PRIV, 'p')); - ModeManager::AddUserMode(new UserMode(UMODE_REGISTERED, 'r')); ModeManager::AddUserMode(new UserMode(UMODE_CLOAK, 'x')); ModeManager::AddUserMode(new UserMode(UMODE_PROTECTED, 'U')); - /* b/e/I */ - ModeManager::AddChannelMode(new ChannelModeList(CMODE_BAN, 'b')); - ModeManager::AddChannelMode(new ChannelModeList(CMODE_EXCEPT, 'e')); - ModeManager::AddChannelMode(new ChannelModeList(CMODE_INVITEOVERRIDE, 'I')); - - /* l/k */ - ModeManager::AddChannelMode(new ChannelModeKey('k')); - ModeManager::AddChannelMode(new ChannelModeParam(CMODE_LIMIT, 'l')); - /* v/h/o/a/q */ - ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_VOICE, 'v', '+', 0)); - ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_HALFOP, 'h', '%', 1)); - ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_OP, 'o', '@', 2)); ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_PROTECT, 'a', '&', 3)); ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_OWNER, 'q', '~', 4)); /* Add channel modes */ + ModeManager::RemoveChannelMode(ModeManager::FindChannelModeByName(CMODE_REGISTERED)); ModeManager::AddChannelMode(new ChannelMode(CMODE_BANDWIDTH, 'B')); ModeManager::AddChannelMode(new ChannelMode(CMODE_NOCTCP, 'C')); ModeManager::AddChannelMode(new ChannelMode(CMODE_REGMODERATED, 'M')); ModeManager::AddChannelMode(new ChannelMode(CMODE_NONOTICE, 'N')); - ModeManager::AddChannelMode(new ChannelModeOper('O')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_REGISTEREDONLY, 'R')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_SSL, 'S')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_BLOCKCOLOR, 'c')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_INVITE, 'i')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_MODERATED, 'm')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_NOEXTERNAL, 'n')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_PRIVATE, 'p')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_SECRET, 's')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_TOPIC, 't')); ModeManager::AddChannelMode(new ChannelMode(CMODE_PERM, 'z')); } public: - ProtoPlexus(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL) + ProtoPlexus(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), + message_away(this), message_capab(this), message_error(this), message_kick(this), message_kill(this), + message_mode(this), message_motd(this), message_part(this), message_ping(this), message_privmsg(this), message_quit(this), + message_squit(this), message_stats(this), message_time(this), message_topic(this), message_version(this), message_whois(this), + + message_bmask("IRCDMessage", "plexus/bmask", "hybrid/bmask"), message_eob("IRCDMessage", "plexus/eob", "hybrid/eob"), + message_join("IRCDMessage", "plexus/join", "hybrid/join"), message_nick("IRCDMessage", "plexus/nick", "hybrid/nick"), + message_sid("IRCDMessage", "plexus/sid", "hybrid/sid"), + message_sjoin("IRCDMessage", "plexus/sjoin", "hybrid/sjoin"), message_tburst("IRCDMessage", "plexus/tburst", "hybrid/tburst"), + message_tmode("IRCDMessage", "plexus/tmode", "hybrid/tmode"), + + message_encap(this), message_pass(this), message_server(this), message_uid(this) { this->SetAuthor("Anope"); + if (ModuleManager::LoadModule("hybrid", User::Find(creator)) != MOD_ERR_OK) + throw ModuleException("Unable to load hybrid"); + m_hybrid = ModuleManager::FindModule("hybrid"); + if (!m_hybrid) + throw ModuleException("Unable to find hybrid"); + hybrid = m_hybrid->GetIRCDProto(); + if (!hybrid) + throw ModuleException("No protocol interface for hybrid"); + this->AddModes(); Implementation i[] = { I_OnServerSync }; ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); + } - if (Config->Numeric.empty()) - { - Anope::string numeric = ts6_sid_retrieve(); - Me->SetSID(numeric); - Config->Numeric = numeric; - } + ~ProtoPlexus() + { + ModuleManager::UnloadModule(m_hybrid, NULL); + } - for (botinfo_map::iterator it = BotListByNick->begin(), it_end = BotListByNick->end(); it != it_end; ++it) - it->second->GenerateUID(); + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; } void OnServerSync(Server *s) anope_override { - if (nickserv) + if (NickServService) for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) { User *u = it->second; if (u->server == s && !u->IsIdentified()) - nickserv->Validate(u); + NickServService->Validate(u); } } }; diff --git a/modules/protocol/ratbox.cpp b/modules/protocol/ratbox.cpp index 3ae4b6e17..32226fae7 100644 --- a/modules/protocol/ratbox.cpp +++ b/modules/protocol/ratbox.cpp @@ -12,6 +12,7 @@ #include "module.h" static Anope::string UplinkSID; +static IRCDProto *hybrid; class RatboxProto : public IRCDProto { @@ -26,112 +27,24 @@ class RatboxProto : public IRCDProto MaxModes = 4; } - void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override - { - UplinkSocket::Message(bi) << "NOTICE $$" << dest->GetName() << " :" << msg; - } - - void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override - { - UplinkSocket::Message(bi) << "PRIVMSG $$" << dest->GetName() << " :" << msg; - } - - void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) anope_override - { - UplinkSocket::Message(source) << "OPERWALL :" << buf; - } - - void SendSQLine(User *, const XLine *x) anope_override - { - UplinkSocket::Message(Me) << "RESV * " << x->Mask << " :" << x->GetReason(); - } - - void SendSGLineDel(const XLine *x) anope_override - { - const BotInfo *bi = findbot(Config->OperServ); - UplinkSocket::Message(bi) << "UNXLINE * " << x->Mask; - } - - void SendSGLine(User *, const XLine *x) anope_override - { - const BotInfo *bi = findbot(Config->OperServ); - UplinkSocket::Message(bi) << "XLINE * " << x->Mask << " 0 :" << x->GetReason(); - } - - void SendAkillDel(const XLine *x) anope_override - { - if (x->IsRegex() || x->HasNickOrReal()) - return; - - const BotInfo *bi = findbot(Config->OperServ); - UplinkSocket::Message(bi) << "UNKLINE * " << x->GetUser() << " " << x->GetHost(); - } - - void SendSQLineDel(const XLine *x) anope_override - { - UplinkSocket::Message(Me) << "UNRESV * " << x->Mask; - } - - void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override - { - /* Note that we must send our modes with the SJOIN and - * can not add them to the mode stacker because ratbox - * does not allow *any* client to op itself - */ - UplinkSocket::Message() << "SJOIN " << c->creation_time << " " << c->name << " +" << c->GetModes(true, true) << " :" << (status != NULL ? status->BuildModePrefixList() : "") << user->GetUID(); - /* And update our internal status for this user since this is not going through our mode handling system */ - if (status != NULL) - { - UserContainer *uc = c->FindUser(user); - if (uc != NULL) - *uc->Status = *status; - } - } - - void SendAkill(User *u, XLine *x) anope_override - { - const BotInfo *bi = findbot(Config->OperServ); - - if (x->IsRegex() || x->HasNickOrReal()) - { - if (!u) - { - /* No user (this akill was just added), and contains nick and/or realname. Find users that match and ban them */ - for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) - if (x->manager->Check(it->second, x)) - this->SendAkill(it->second, x); - return; - } - - const XLine *old = x; - - if (old->manager->HasEntry("*@" + u->host)) - return; - - /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - XLine *xline = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); - old->manager->AddXLine(xline); - x = xline; - - Log(bi, "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->Mask; - } - - // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) - timeleft = 172800; - UplinkSocket::Message(bi) << "KLINE * " << timeleft << " " << x->GetUser() << " " << x->GetHost() << " :" << x->GetReason(); - } - - /* SERVER name hop descript */ - void SendServer(const Server *server) anope_override - { - UplinkSocket::Message() << "SERVER " << server->GetName() << " " << server->GetHops() << " :" << server->GetDescription(); - } + void SendGlobalNotice(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { hybrid->SendGlobalNotice(bi, dest, msg); } + void SendGlobalPrivmsg(const BotInfo *bi, const Server *dest, const Anope::string &msg) anope_override { hybrid->SendGlobalPrivmsg(bi, dest, msg); } + void SendGlobopsInternal(const BotInfo *source, const Anope::string &buf) anope_override { hybrid->SendGlobopsInternal(source, buf); } + void SendSQLine(User *u, const XLine *x) anope_override { hybrid->SendSQLine(u, x); } + void SendSGLine(User *u, const XLine *x) anope_override { hybrid->SendSGLine(u, x); } + void SendSGLineDel(const XLine *x) anope_override { hybrid->SendSGLineDel(x); } + void SendAkill(User *u, XLine *x) anope_override { hybrid->SendAkill(u, x); } + void SendAkillDel(const XLine *x) anope_override { hybrid->SendAkillDel(x); } + void SendSQLineDel(const XLine *x) anope_override { hybrid->SendSQLineDel(x); } + void SendJoin(const User *user, Channel *c, const ChannelStatus *status) anope_override { hybrid->SendJoin(user, c, status); } + void SendServer(const Server *server) anope_override { hybrid->SendServer(server); } + void SendModeInternal(const BotInfo *bi, const User *u, const Anope::string &buf) anope_override { hybrid->SendModeInternal(bi, u, buf); } + void SendChannel(Channel *c) anope_override { hybrid->SendChannel(c); } + void SendTopic(BotInfo *bi, Channel *c) anope_override { hybrid->SendTopic(bi, c); } void SendConnect() anope_override { - UplinkSocket::Message() << "PASS " << Config->Uplinks[CurrentUplink]->password << " TS 6 :" << Me->GetSID(); + UplinkSocket::Message() << "PASS " << Config->Uplinks[Anope::CurrentUplink]->password << " TS 6 :" << Me->GetSID(); /* QS - Can handle quit storm removal EX - Can do channel +e exemptions @@ -162,11 +75,6 @@ class RatboxProto : public IRCDProto UplinkSocket::Message(Me) << "UID " << u->nick << " 1 " << u->timestamp << " " << modes << " " << u->GetIdent() << " " << u->host << " 0 " << u->GetUID() << " :" << u->realname; } - void SendModeInternal(const BotInfo *bi, const User *u, const Anope::string &buf) anope_override - { - UplinkSocket::Message(bi) << "SVSMODE " << u->nick << " " << buf; - } - void SendLogin(User *u) anope_override { if (!u->Account()) @@ -179,157 +87,36 @@ class RatboxProto : public IRCDProto { UplinkSocket::Message(Me) << "ENCAP * SU " << u->GetUID(); } - - void SendChannel(Channel *c) anope_override - { - Anope::string modes = c->GetModes(true, true); - if (modes.empty()) - modes = "+"; - UplinkSocket::Message() << "SJOIN " << c->creation_time << " " << c->name << " " << modes << " :"; - } - - bool IsNickValid(const Anope::string &nick) anope_override - { - /* TS6 Save extension -Certus */ - if (isdigit(nick[0])) - return false; - - return true; - } - - void SendTopic(BotInfo *bi, Channel *c) anope_override - { - bool needjoin = c->FindUser(bi) == NULL; - if (needjoin) - { - ChannelStatus status; - status.SetFlag(CMODE_OP); - bi->Join(c, &status); - } - IRCDProto::SendTopic(bi, c); - if (needjoin) - bi->Part(c); - } -}; - -struct IRCDMessageBMask : IRCDMessage -{ - IRCDMessageBMask() : IRCDMessage("BMASK", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - /* :42X BMASK 1106409026 #ircops b :*!*@*.aol.com */ - /* 0 1 2 3 */ - Channel *c = findchan(params[1]); - - if (c) - { - ChannelMode *ban = ModeManager::FindChannelModeByName(CMODE_BAN), - *except = ModeManager::FindChannelModeByName(CMODE_EXCEPT), - *invex = ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE); - - Anope::string bans = params[3]; - int count = myNumToken(bans, ' '), i; - for (i = 0; i < count; ++i) - { - Anope::string b = myStrGetToken(bans, ' ', i); - if (ban && params[2].equals_cs("b")) - c->SetModeInternal(source, ban, b); - else if (except && params[2].equals_cs("e")) - c->SetModeInternal(source, except, b); - if (invex && params[2].equals_cs("I")) - c->SetModeInternal(source, invex, b); - } - } - - return true; - } }; struct IRCDMessageEncap : IRCDMessage { - IRCDMessageEncap() : IRCDMessage("ENCAP", 3) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageEncap(Module *creator) : IRCDMessage(creator, "ENCAP", 3) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } // Debug: Received: :00BAAAAAB ENCAP * LOGIN Adam bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - if (params[1] == "LOGIN") + if (params[1] == "LOGIN" || params[1] == "SU") { User *u = source.GetUser(); - NickCore *nc = findcore(params[2]); + NickCore *nc = NickCore::Find(params[2]); if (!nc) return true; u->Login(nc); - const NickAlias *user_na = findnick(u->nick); + const NickAlias *user_na = NickAlias::Find(u->nick); if (!Config->NoNicknameOwnership && user_na && user_na->nc == nc && user_na->nc->HasFlag(NI_UNCONFIRMED) == false) - u->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); - } - - return true; - } -}; - -struct IRCDMessageJoin : CoreIRCDMessageJoin -{ - IRCDMessageJoin() : CoreIRCDMessageJoin("JOIN") { } - - /* - * params[0] = ts - * params[1] = channel - * params[2] = modes - */ - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - if (params.size() < 2) - return true; - - std::vector<Anope::string> p = params; - p.erase(p.begin()); - - return CoreIRCDMessageJoin::Run(source, p); - } -}; - -struct IRCDMessageMode : IRCDMessage -{ - IRCDMessageMode() : IRCDMessage("MODE", 2) { } - - // Received: :42CAAAIHS MODE 42CAAAIHS :+ao - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - if (ircdproto->IsChannelValid(params[0])) - { - Channel *c = findchan(params[0]); - if (c) - c->SetModesInternal(source, params[1]); - } - else - { - User *u = finduser(params[0]); - if (u) - u->SetModesInternal("%s", params[1].c_str()); + u->SetMode(NickServ, UMODE_REGISTERED); } return true; } }; -struct IRCDMessageNick : IRCDMessage -{ - IRCDMessageNick() : IRCDMessage("NICK", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - source.GetUser()->ChangeNick(params[0]); - return true; - } -}; - struct IRCDMessagePass : IRCDMessage { - IRCDMessagePass() : IRCDMessage("PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessagePass(Module *creator) : IRCDMessage(creator, "PASS", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -338,20 +125,9 @@ struct IRCDMessagePass : IRCDMessage } }; -struct IRCDMessagePong : IRCDMessage -{ - IRCDMessagePong() : IRCDMessage("PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - source.GetServer()->Sync(false); - return true; - } -}; - struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } // SERVER hades.arpa 1 :ircd-ratbox test server bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override @@ -360,166 +136,33 @@ struct IRCDMessageServer : IRCDMessage if (params[1] != "1") return true; new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], 1, params[2], UplinkSID); - ircdproto->SendPing(Config->ServerName, params[0]); - return true; - } -}; - -struct IRCDMessageSID : IRCDMessage -{ - IRCDMessageSID() : IRCDMessage("SID", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - /* :42X SID trystan.nomadirc.net 2 43X :ircd-ratbox test server */ - unsigned int hops = params[1].is_pos_number_only() ? convertTo<unsigned>(params[1]) : 0; - new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], hops, params[3], params[2]); - ircdproto->SendPing(Config->ServerName, params[0]); - return true; - } -}; - -struct IRCDMessageSjoin : IRCDMessage -{ - IRCDMessageSjoin() : IRCDMessage("SJOIN", 2) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - Channel *c = findchan(params[1]); - time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[1], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; - - /* If we need to keep their modes, and this SJOIN string contains modes */ - if (keep_their_modes && params.size() >= 3) - { - Anope::string modes; - for (unsigned i = 2; i < params.size() - 1; ++i) - modes += " " + params[i]; - if (!modes.empty()) - modes.erase(modes.begin()); - /* Set the modes internally */ - c->SetModesInternal(source, modes); - } - - spacesepstream sep(params[params.size() - 1]); - Anope::string buf; - while (sep.GetToken(buf)) - { - std::list<ChannelMode *> Status; - char ch; - - /* Get prefixes from the nick */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) - { - buf.erase(buf.begin()); - ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); - if (!cm) - { - Log() << "Received unknown mode prefix " << ch << " in SJOIN string"; - continue; - } - - if (keep_their_modes) - Status.push_back(cm); - } - - User *u = finduser(buf); - if (!u) - { - Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << c->name; - continue; - } - - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); - } - - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) - { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); - } - + IRCD->SendPing(Config->ServerName, params[0]); return true; } }; struct IRCDMessageTBurst : IRCDMessage { - IRCDMessageTBurst() : IRCDMessage("TBURST", 4) { } + IRCDMessageTBurst(Module *creator) : IRCDMessage(creator, "TB", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + /* + * params[0] = channel + * params[1] = ts + * params[2] = topic OR who set the topic + * params[3] = topic if params[2] isnt the topic + */ bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Anope::string setter = myStrGetToken(params[2], '!', 0); time_t topic_time = Anope::string(params[1]).is_pos_number_only() ? convertTo<time_t>(params[1]) : Anope::CurTime; - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (!c) return true; - c->ChangeTopicInternal(setter, params[3], topic_time); - - return true; - } -}; - -struct IRCDMessageTMode : IRCDMessage -{ - IRCDMessageTMode() : IRCDMessage("TMODE", 3) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } - - bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override - { - time_t ts = 0; - try - { - ts = convertTo<time_t>(params[0]); - } - catch (const ConvertException &) { } - Channel *c = findchan(params[1]); - Anope::string modes = params[2]; - for (unsigned i = 3; i < params.size(); ++i) - modes += " " + params[i]; + const Anope::string &setter = params.size() == 4 ? params[2] : "", + topic = params.size() == 4 ? params[3] : params[2]; - if (c) - c->SetModesInternal(source, modes, ts); + c->ChangeTopicInternal(setter, topic, topic_time); return true; } @@ -527,15 +170,15 @@ struct IRCDMessageTMode : IRCDMessage struct IRCDMessageUID : IRCDMessage { - IRCDMessageUID() : IRCDMessage("UID", 9) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageUID(Module *creator) : IRCDMessage(creator, "UID", 9) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } // :42X UID Adam 1 1348535644 +aow Adam 192.168.0.5 192.168.0.5 42XAAAAAB :Adam bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { /* Source is always the server */ User *user = new User(params[0], params[4], params[5], "", params[6], source.GetServer(), params[8], params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0, params[3], params[7]); - if (user && user->server->IsSynced() && nickserv) - nickserv->Validate(user); + if (user && user->server->IsSynced() && NickServService) + NickServService->Validate(user); return true; } @@ -543,99 +186,105 @@ struct IRCDMessageUID : IRCDMessage class ProtoRatbox : public Module { + Module *m_hybrid; + RatboxProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageCapab core_message_capab; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - CoreIRCDMessageWhois core_message_whois; + Message::Away message_away; + Message::Capab message_capab; + Message::Error message_error; + Message::Kick message_kick; + Message::Kill message_kill; + Message::Mode message_mode; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Topic message_topic; + Message::Version message_version; + Message::Whois message_whois; + + /* Hybrid message handlers */ + ServiceAlias message_bmask, message_join, message_nick, message_pong, message_sid, + message_sjoin, message_tmode; /* Our message handlers */ - IRCDMessageBMask message_bmask; IRCDMessageEncap message_encap; - IRCDMessageJoin message_join; - IRCDMessageMode message_mode; - IRCDMessageNick message_nick; IRCDMessagePass message_pass; - IRCDMessagePong message_pong; IRCDMessageServer message_server; - IRCDMessageSID message_sid; - IRCDMessageSjoin message_sjoin; IRCDMessageTBurst message_tburst; - IRCDMessageTMode message_tmode; IRCDMessageUID message_uid; void AddModes() { - /* Add user modes */ - ModeManager::AddUserMode(new UserMode(UMODE_ADMIN, 'a')); - ModeManager::AddUserMode(new UserMode(UMODE_INVIS, 'i')); - ModeManager::AddUserMode(new UserMode(UMODE_OPER, 'o')); - ModeManager::AddUserMode(new UserMode(UMODE_SNOMASK, 's')); - ModeManager::AddUserMode(new UserMode(UMODE_WALLOPS, 'w')); - - /* b/e/I */ - ModeManager::AddChannelMode(new ChannelModeList(CMODE_BAN, 'b')); - ModeManager::AddChannelMode(new ChannelModeList(CMODE_EXCEPT, 'e')); - ModeManager::AddChannelMode(new ChannelModeList(CMODE_INVITEOVERRIDE, 'I')); + /* user modes */ + ModeManager::RemoveUserMode(ModeManager::FindUserModeByName(UMODE_HIDEOPER)); + ModeManager::RemoveUserMode(ModeManager::FindUserModeByName(UMODE_REGPRIV)); /* v/h/o/a/q */ - ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_VOICE, 'v', '+', 0)); - ModeManager::AddChannelMode(new ChannelModeStatus(CMODE_OP, 'o', '@', 1)); - - /* Add channel modes */ - ModeManager::AddChannelMode(new ChannelMode(CMODE_INVITE, 'i')); - ModeManager::AddChannelMode(new ChannelModeKey('k')); - ModeManager::AddChannelMode(new ChannelModeParam(CMODE_LIMIT, 'l')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_MODERATED, 'm')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_NOEXTERNAL, 'n')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_PRIVATE, 'p')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_SECRET, 's')); - ModeManager::AddChannelMode(new ChannelMode(CMODE_TOPIC, 't')); + ModeManager::RemoveChannelMode(ModeManager::FindChannelModeByName(CMODE_HALFOP)); + + /* channel modes */ + ModeManager::RemoveChannelMode(ModeManager::FindChannelModeByName(CMODE_REGISTERED)); + ModeManager::RemoveChannelMode(ModeManager::FindChannelModeByName(CMODE_OPERONLY)); + ModeManager::RemoveChannelMode(ModeManager::FindChannelModeByName(CMODE_REGISTEREDONLY)); + ModeManager::RemoveChannelMode(ModeManager::FindChannelModeByName(CMODE_SSL)); } public: - ProtoRatbox(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL) + ProtoRatbox(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), + message_away(this), message_capab(this), message_error(this), message_kick(this), message_kill(this), + message_mode(this), message_motd(this), message_part(this), message_ping(this), message_privmsg(this), + message_quit(this), message_squit(this), message_stats(this), message_time(this), message_topic(this), + message_version(this), message_whois(this), + + message_bmask("IRCDMessage", "ratbox/bmask", "hybrid/bmask"), message_join("IRCDMessage", "ratbox/join", "hybrid/join"), + message_nick("IRCDMessage", "ratbox/nick", "hybrid/nick"), message_pong("IRCDMessage", "ratbox/pong", "hybrid/pong"), + message_sid("IRCDMessage", "ratbox/sid", "hybrid/sid"), message_sjoin("IRCDMessage", "ratbox/sjoin", "hybrid/sjoin"), + message_tmode("IRCDMessage", "ratbox/tmode", "hybrid/tmode"), + + message_encap(this), message_pass(this), message_server(this), message_tburst(this), message_uid(this) { this->SetAuthor("Anope"); + if (ModuleManager::LoadModule("hybrid", User::Find(creator)) != MOD_ERR_OK) + throw ModuleException("Unable to load hybrid"); + m_hybrid = ModuleManager::FindModule("hybrid"); + if (!m_hybrid) + throw ModuleException("Unable to find hybrid"); + hybrid = m_hybrid->GetIRCDProto(); + if (!hybrid) + throw ModuleException("No protocol interface for hybrid"); + this->AddModes(); Implementation i[] = { I_OnServerSync }; ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation)); + } - if (Config->Numeric.empty()) - { - Anope::string numeric = ts6_sid_retrieve(); - Me->SetSID(numeric); - Config->Numeric = numeric; - } + ~ProtoRatbox() + { + ModuleManager::UnloadModule(m_hybrid, NULL); + } - for (botinfo_map::iterator it = BotListByNick->begin(), it_end = BotListByNick->end(); it != it_end; ++it) - it->second->GenerateUID(); + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; } void OnServerSync(Server *s) anope_override { - if (nickserv) + if (NickServService) for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) { User *u = it->second; if (u->server == s && !u->IsIdentified()) - nickserv->Validate(u); + NickServService->Validate(u); } } }; diff --git a/modules/protocol/unreal.cpp b/modules/protocol/unreal.cpp index d07c5eaec..5e7a9f194 100644 --- a/modules/protocol/unreal.cpp +++ b/modules/protocol/unreal.cpp @@ -48,7 +48,7 @@ class UnrealIRCdProto : public IRCDProto if (x->GetUser() == "*") { sockaddrs(x->GetHost()); - ircdproto->SendSZLineDel(x); + IRCD->SendSZLineDel(x); return; } } @@ -74,11 +74,10 @@ class UnrealIRCdProto : public IRCDProto void SendVhostDel(User *u) anope_override { - const BotInfo *bi = findbot(Config->HostServ); - u->RemoveMode(bi, UMODE_CLOAK); - u->RemoveMode(bi, UMODE_VHOST); + u->RemoveMode(HostServ, UMODE_CLOAK); + u->RemoveMode(HostServ, UMODE_VHOST); ModeManager::ProcessModes(); - u->SetMode(bi, UMODE_CLOAK); + u->SetMode(HostServ, UMODE_CLOAK); } void SendAkill(User *u, XLine *x) anope_override @@ -100,11 +99,11 @@ class UnrealIRCdProto : public IRCDProto return; /* We can't akill x as it has a nick and/or realname included, so create a new akill for *@host */ - XLine *xline = new XLine("*@" + u->host, old->By, old->Expires, old->Reason, old->UID); + XLine *xline = new XLine("*@" + u->host, old->by, old->expires, old->reason, old->id); old->manager->AddXLine(xline); x = xline; - Log(findbot(Config->OperServ), "akill") << "AKILL: Added an akill for " << x->Mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->Mask; + Log(OperServ, "akill") << "AKILL: Added an akill for " << x->mask << " because " << u->GetMask() << "#" << u->realname << " matches " << old->mask; } /* ZLine if we can instead */ @@ -113,17 +112,17 @@ class UnrealIRCdProto : public IRCDProto if (x->GetUser() == "*") { sockaddrs(x->GetHost()); - ircdproto->SendSZLine(u, x); + IRCD->SendSZLine(u, x); return; } } catch (const SocketException &) { } // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message() << "BD + G " << x->GetUser() << " " << x->GetHost() << " " << x->By << " " << Anope::CurTime + timeleft << " " << x->Created << " :" << x->GetReason(); + UplinkSocket::Message() << "BD + G " << x->GetUser() << " " << x->GetHost() << " " << x->by << " " << Anope::CurTime + timeleft << " " << x->created << " :" << x->GetReason(); } void SendSVSKillInternal(const BotInfo *source, User *user, const Anope::string &buf) anope_override @@ -165,11 +164,11 @@ class UnrealIRCdProto : public IRCDProto */ UserContainer *uc = c->FindUser(user); if (uc != NULL) - uc->Status->ClearFlags(); + uc->status->ClearFlags(); - BotInfo *setter = findbot(user->nick); + BotInfo *setter = BotInfo::Find(user->nick); for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) - if (cs.HasFlag(ModeManager::ChannelModes[i]->Name)) + if (cs.HasFlag(ModeManager::ChannelModes[i]->name)) c->SetMode(setter, ModeManager::ChannelModes[i], user->GetUID(), false); } } @@ -178,7 +177,7 @@ class UnrealIRCdProto : public IRCDProto */ void SendSQLineDel(const XLine *x) anope_override { - UplinkSocket::Message() << "d " << x->Mask; + UplinkSocket::Message() << "d " << x->mask; } /* SQLINE */ @@ -188,7 +187,7 @@ class UnrealIRCdProto : public IRCDProto */ void SendSQLine(User *, const XLine *x) anope_override { - UplinkSocket::Message() << "c " << x->Mask << " :" << x->GetReason(); + UplinkSocket::Message() << "c " << x->mask << " :" << x->GetReason(); } /* @@ -239,7 +238,7 @@ class UnrealIRCdProto : public IRCDProto UplinkSocket::Message() << "PROTOCTL NICKv2 VHP UMODE2 NICKIP SJOIN SJOIN2 SJ3 NOQUIT TKLEXT ESVID MLOCK VL"; else UplinkSocket::Message() << "PROTOCTL NICKv2 VHP UMODE2 NICKIP SJOIN SJOIN2 SJ3 NOQUIT TKLEXT ESVID MLOCK"; - UplinkSocket::Message() << "PASS :" << Config->Uplinks[CurrentUplink]->password; + UplinkSocket::Message() << "PASS :" << Config->Uplinks[Anope::CurrentUplink]->password; SendServer(Me); } @@ -261,7 +260,7 @@ class UnrealIRCdProto : public IRCDProto */ void SendSGLineDel(const XLine *x) anope_override { - UplinkSocket::Message() << "BR - :" << x->Mask; + UplinkSocket::Message() << "BR - :" << x->mask; } /* UNSZLINE */ @@ -274,10 +273,10 @@ class UnrealIRCdProto : public IRCDProto void SendSZLine(User *, const XLine *x) anope_override { // Calculate the time left before this would expire, capping it at 2 days - time_t timeleft = x->Expires - Anope::CurTime; - if (timeleft > 172800 || !x->Expires) + time_t timeleft = x->expires - Anope::CurTime; + if (timeleft > 172800 || !x->expires) timeleft = 172800; - UplinkSocket::Message() << "BD + Z * " << x->GetHost() << " " << x->By << " " << Anope::CurTime + timeleft << " " << x->Created << " :" << x->GetReason(); + UplinkSocket::Message() << "BD + Z * " << x->GetHost() << " " << x->by << " " << Anope::CurTime + timeleft << " " << x->created << " :" << x->GetReason(); } /* SGLINE */ @@ -288,7 +287,7 @@ class UnrealIRCdProto : public IRCDProto { Anope::string edited_reason = x->GetReason(); edited_reason = edited_reason.replace_all_cs(" ", "_"); - UplinkSocket::Message() << "BR + " << edited_reason << " :" << x->Mask; + UplinkSocket::Message() << "BR + " << edited_reason << " :" << x->mask; } /* svsjoin @@ -323,7 +322,7 @@ class UnrealIRCdProto : public IRCDProto if (nick.equals_ci("ircd") || nick.equals_ci("irc")) return false; - return true; + return IRCDProto::IsNickValid(nick); } bool IsChannelValid(const Anope::string &chan) anope_override @@ -339,17 +338,15 @@ class UnrealIRCdProto : public IRCDProto if (!u->Account()) return; - const BotInfo *ns = findbot(Config->NickServ); - if (Capab.count("ESVID") > 0) - ircdproto->SendMode(ns, u, "+d %s", u->Account()->display.c_str()); + if (Servers::Capab.count("ESVID") > 0) + IRCD->SendMode(NickServ, u, "+d %s", u->Account()->display.c_str()); else - ircdproto->SendMode(ns, u, "+d %d", u->timestamp); + IRCD->SendMode(NickServ, u, "+d %d", u->timestamp); } void SendLogout(User *u) anope_override { - const BotInfo *ns = findbot(Config->NickServ); - ircdproto->SendMode(ns, u, "+d 0"); + IRCD->SendMode(NickServ, u, "+d 0"); } void SendChannel(Channel *c) anope_override @@ -392,16 +389,16 @@ class UnrealExtBan : public ChannelModeList char modeChar = ModeManager::GetStatusChar(channel[0]); channel.erase(channel.begin()); cm = ModeManager::FindChannelModeByChar(modeChar); - if (cm != NULL && cm->Type != MODE_STATUS) + if (cm != NULL && cm->type != MODE_STATUS) cm = NULL; } - Channel *c = findchan(channel); + Channel *c = Channel::Find(channel); if (c != NULL) { UserContainer *uc = c->FindUser(u); if (uc != NULL) - if (cm == NULL || uc->Status->HasFlag(cm->Name)) + if (cm == NULL || uc->status->HasFlag(cm->name)) return true; } } @@ -409,7 +406,7 @@ class UnrealExtBan : public ChannelModeList { Anope::string real_mask = mask.substr(3); - Entry en(this->Name, real_mask); + Entry en(this->name, real_mask); if (en.Matches(u)) return true; } @@ -494,9 +491,9 @@ class ChannelModeUnrealSSL : public ChannelMode } }; -struct IRCDMessageCapab : CoreIRCDMessageCapab +struct IRCDMessageCapab : Message::Capab { - IRCDMessageCapab() : CoreIRCDMessageCapab("PROTOCTL") { } + IRCDMessageCapab(Module *creator) : Message::Capab(creator, "PROTOCTL") { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -645,17 +642,17 @@ struct IRCDMessageCapab : CoreIRCDMessageCapab } } - return CoreIRCDMessageCapab::Run(source, params); + return Message::Capab::Run(source, params); } }; struct IRCDMessageChgHost : IRCDMessage { - IRCDMessageChgHost() : IRCDMessage("CHGHOST", 2) { } + IRCDMessageChgHost(Module *creator) : IRCDMessage(creator, "CHGHOST", 2) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetDisplayedHost(params[1]); return true; @@ -664,11 +661,11 @@ struct IRCDMessageChgHost : IRCDMessage struct IRCDMessageChgIdent : IRCDMessage { - IRCDMessageChgIdent() : IRCDMessage("CHGIDENT", 2) { } + IRCDMessageChgIdent(Module *creator) : IRCDMessage(creator, "CHGIDENT", 2) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetVIdent(params[1]); return true; @@ -677,11 +674,11 @@ struct IRCDMessageChgIdent : IRCDMessage struct IRCDMessageChgName : IRCDMessage { - IRCDMessageChgName() : IRCDMessage("CHGNAME", 2) { } + IRCDMessageChgName(Module *creator) : IRCDMessage(creator, "CHGNAME", 2) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetRealname(params[1]); return true; @@ -690,7 +687,7 @@ struct IRCDMessageChgName : IRCDMessage struct IRCDMessageMode : IRCDMessage { - IRCDMessageMode(const Anope::string &mname) : IRCDMessage(mname, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageMode(Module *creator, const Anope::string &mname) : IRCDMessage(creator, mname, 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -699,10 +696,11 @@ struct IRCDMessageMode : IRCDMessage for (unsigned i = 2; i < params.size() - (server_source ? 1 : 0); ++i) modes += " " + params[i]; - if (ircdproto->IsChannelValid(params[0])) + if (IRCD->IsChannelValid(params[0])) { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); time_t ts = 0; + try { if (server_source) @@ -715,7 +713,7 @@ struct IRCDMessageMode : IRCDMessage } else { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetModesInternal("%s", params[1].c_str()); } @@ -736,18 +734,18 @@ struct IRCDMessageMode : IRCDMessage */ struct IRCDMessageNetInfo : IRCDMessage { - IRCDMessageNetInfo() : IRCDMessage("NETINFO", 8) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageNetInfo(Module *creator) : IRCDMessage(creator, "NETINFO", 8) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - UplinkSocket::Message() << "AO " << maxusercnt << " " << Anope::CurTime << " " << convertTo<int>(params[2]) << " " << params[3] << " 0 0 0 :" << params[7]; + UplinkSocket::Message() << "AO " << MaxUserCount << " " << Anope::CurTime << " " << convertTo<int>(params[2]) << " " << params[3] << " 0 0 0 :" << params[7]; return true; } }; struct IRCDMessageNick : IRCDMessage { - IRCDMessageNick() : IRCDMessage("NICK", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageNick(Module *creator) : IRCDMessage(creator, "NICK", 2) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); } /* ** NICK - new @@ -807,21 +805,21 @@ struct IRCDMessageNick : IRCDMessage else if (params[6].is_pos_number_only()) { if (convertTo<time_t>(params[6]) == user->timestamp) - na = findnick(user->nick); + na = NickAlias::Find(user->nick); } else { - na = findnick(params[6]); + na = NickAlias::Find(params[6]); } if (na) { user->Login(na->nc); - if (!Config->NoNicknameOwnership && na->nc->HasFlag(NI_UNCONFIRMED) == false && nickserv) - user->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + if (!Config->NoNicknameOwnership && na->nc->HasFlag(NI_UNCONFIRMED) == false) + user->SetMode(NickServ, UMODE_REGISTERED); } - else if (nickserv) - nickserv->Validate(user); + else if (NickServService) + NickServService->Validate(user); } else source.GetUser()->ChangeNick(params[0]); @@ -841,7 +839,7 @@ struct IRCDMessageNick : IRCDMessage */ struct IRCDMessagePong : IRCDMessage { - IRCDMessagePong() : IRCDMessage("PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessagePong(Module *creator) : IRCDMessage(creator, "PONG", 0) { SetFlag(IRCDMESSAGE_SOFT_LIMIT); SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -878,13 +876,11 @@ struct IRCDMessageSASL : IRCDMessage UplinkSocket::Message() << "SASL " << this->uid.substr(0, p) << " " << this->uid << " D F"; - Log(findbot(Config->NickServ)) << "A user failed to identify for account " << this->GetAccount() << " using SASL"; + Log(NickServ) << "A user failed to identify for account " << this->GetAccount() << " using SASL"; } }; - Module *me; - - IRCDMessageSASL(Module *m) : IRCDMessage("SASL", 4), me(m) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageSASL(Module *creator) : IRCDMessage(creator, "SASL", 4) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } /* Received: :irc.foonet.com SASL services.localhost.net irc.foonet.com!1.57290 S PLAIN * uid @@ -920,7 +916,7 @@ struct IRCDMessageSASL : IRCDMessage if (acc.empty() || pass.empty()) return true; - IdentifyRequest *req = new UnrealSASLIdentifyRequest(me, params[1], acc, pass); + IdentifyRequest *req = new UnrealSASLIdentifyRequest(this->owner, params[1], acc, pass); FOREACH_MOD(I_OnCheckAuthentication, OnCheckAuthentication(NULL, req)); req->Dispatch(); } @@ -931,7 +927,7 @@ struct IRCDMessageSASL : IRCDMessage struct IRCDMessageSDesc : IRCDMessage { - IRCDMessageSDesc() : IRCDMessage("SDESC", 1) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageSDesc(Module *creator) : IRCDMessage(creator, "SDESC", 1) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -942,7 +938,7 @@ struct IRCDMessageSDesc : IRCDMessage struct IRCDMessageSetHost : IRCDMessage { - IRCDMessageSetHost() : IRCDMessage("SETHOST", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageSetHost(Module *creator) : IRCDMessage(creator, "SETHOST", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -960,7 +956,7 @@ struct IRCDMessageSetHost : IRCDMessage struct IRCDMessageSetIdent : IRCDMessage { - IRCDMessageSetIdent() : IRCDMessage("SETIDENT", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageSetIdent(Module *creator) : IRCDMessage(creator, "SETIDENT", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -972,11 +968,11 @@ struct IRCDMessageSetIdent : IRCDMessage struct IRCDMessageSetName : IRCDMessage { - IRCDMessageSetName() : IRCDMessage("SETNAME", 1) { } + IRCDMessageSetName(Module *creator) : IRCDMessage(creator, "SETNAME", 1) { } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u) u->SetRealname(params[1]); return true; @@ -985,7 +981,7 @@ struct IRCDMessageSetName : IRCDMessage struct IRCDMessageServer : IRCDMessage { - IRCDMessageServer() : IRCDMessage("SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } + IRCDMessageServer(Module *creator) : IRCDMessage(creator, "SERVER", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -993,16 +989,15 @@ struct IRCDMessageServer : IRCDMessage if (params[1].equals_cs("1")) { - Anope::string vl = myStrGetToken(params[2], ' ', 0); - Anope::string upnumeric = myStrGetToken(vl, '-', 2); - Anope::string desc = myStrGetTokenRemainder(params[2], ' ', 1); + Anope::string desc; + spacesepstream(params[2]).GetTokenRemainder(desc, 1); new Server(source.GetServer() == NULL ? Me : source.GetServer(), params[0], hops, desc); } else new Server(source.GetServer(), params[0], hops, params[2]); - ircdproto->SendPing(Config->ServerName, params[0]); + IRCD->SendPing(Config->ServerName, params[0]); return true; } @@ -1010,44 +1005,20 @@ struct IRCDMessageServer : IRCDMessage struct IRCDMessageSJoin : IRCDMessage { - IRCDMessageSJoin() : IRCDMessage("SJOIN", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } + IRCDMessageSJoin(Module *creator) : IRCDMessage(creator, "SJOIN", 3) { SetFlag(IRCDMESSAGE_REQUIRE_SERVER); SetFlag(IRCDMESSAGE_SOFT_LIMIT); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[1]); - time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : 0; - bool keep_their_modes = true; - - if (!c) - { - c = new Channel(params[1], ts); - c->SetFlag(CH_SYNCING); - } - /* Our creation time is newer than what the server gave us */ - else if (c->creation_time > ts) - { - c->creation_time = ts; - c->Reset(); - } - /* Their TS is newer than ours, our modes > theirs, unset their modes if need be */ - else if (ts > c->creation_time) - keep_their_modes = false; - - /* If we need to keep their modes, and this SJOIN string contains modes */ - if (keep_their_modes && params.size() >= 4) - { - Anope::string modes; + Anope::string modes; + if (params.size() >= 4) for (unsigned i = 2; i < params.size() - 1; ++i) modes += " " + params[i]; - if (!modes.empty()) - modes.erase(modes.begin()); - /* Set the modes internally */ - c->SetModesInternal(source, modes); - } + if (!modes.empty()) + modes.erase(modes.begin()); + + std::list<Anope::string> bans, excepts, invites; + std::list<Message::Join::SJoinUser> users; - ChannelMode *ban = ModeManager::FindChannelModeByName(CMODE_BAN), - *except = ModeManager::FindChannelModeByName(CMODE_EXCEPT), - *invex = ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE); spacesepstream sep(params[params.size() - 1]); Anope::string buf; while (sep.GetToken(buf)) @@ -1056,82 +1027,72 @@ struct IRCDMessageSJoin : IRCDMessage if (buf[0] == '&') { buf.erase(buf.begin()); - if (keep_their_modes && ban) - c->SetModeInternal(source, ban, buf); + bans.push_back(buf); } /* Except */ else if (buf[0] == '"') { buf.erase(buf.begin()); - if (keep_their_modes && except) - c->SetModeInternal(source, except, buf); + excepts.push_back(buf); } /* Invex */ else if (buf[0] == '\'') { buf.erase(buf.begin()); - if (keep_their_modes && invex) - c->SetModeInternal(source, invex, buf); + invites.push_back(buf); } else { - std::list<ChannelMode *> Status; - char ch; + Message::Join::SJoinUser sju; /* Get prefixes from the nick */ - while ((ch = ModeManager::GetStatusChar(buf[0]))) + for (char ch; (ch = ModeManager::GetStatusChar(buf[0]));) { buf.erase(buf.begin()); ChannelMode *cm = ModeManager::FindChannelModeByChar(ch); if (!cm) { - Log() << "Received unknown mode prefix " << ch << " in SJOIN string"; + Log(LOG_DEBUG) << "Received unknown mode prefix " << ch << " in SJOIN string"; continue; } - if (keep_their_modes) - Status.push_back(cm); + sju.first.SetFlag(cm->name); } - User *u = finduser(buf); - if (!u) + sju.second = User::Find(buf); + if (!sju.second) { - Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << c->name; + Log(LOG_DEBUG) << "SJOIN for nonexistant user " << buf << " on " << params[1]; continue; } - EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); - - /* Add the user to the channel */ - c->JoinUser(u); - - /* Update their status internally on the channel - * This will enforce secureops etc on the user - */ - for (std::list<ChannelMode *>::iterator it = Status.begin(), it_end = Status.end(); it != it_end; ++it) - c->SetModeInternal(source, *it, buf); - - /* Now set whatever modes this user is allowed to have on the channel */ - chan_set_correct_modes(u, c, 1, true); - - /* Check to see if modules want the user to join, if they do - * check to see if they are allowed to join (CheckKick will kick/ban them) - * Don't trigger OnJoinChannel event then as the user will be destroyed - */ - if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) - continue; - - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); + users.push_back(sju); } } + + time_t ts = Anope::string(params[0]).is_pos_number_only() ? convertTo<time_t>(params[0]) : Anope::CurTime; + Message::Join::SJoin(source, params[1], ts, modes, users); - /* Channel is done syncing */ - if (c->HasFlag(CH_SYNCING)) + if (!bans.empty() || !excepts.empty() || !invites.empty()) { - /* Unset the syncing flag */ - c->UnsetFlag(CH_SYNCING); - c->Sync(); + Channel *c = Channel::Find(params[1]); + + if (!c || c->creation_time != ts) + return true; + + ChannelMode *ban = ModeManager::FindChannelModeByName(CMODE_BAN), + *except = ModeManager::FindChannelModeByName(CMODE_EXCEPT), + *invex = ModeManager::FindChannelModeByName(CMODE_INVITEOVERRIDE); + + if (ban) + for (std::list<Anope::string>::iterator it = bans.begin(), it_end = bans.end(); it != it_end; ++it) + c->SetModeInternal(source, ban, *it); + if (except) + for (std::list<Anope::string>::iterator it = excepts.begin(), it_end = excepts.end(); it != it_end; ++it) + c->SetModeInternal(source, except, *it); + if (invex) + for (std::list<Anope::string>::iterator it = invites.begin(), it_end = invites.end(); it != it_end; ++it) + c->SetModeInternal(source, invex, *it); } return true; @@ -1140,7 +1101,7 @@ struct IRCDMessageSJoin : IRCDMessage struct IRCDMessageTopic : IRCDMessage { - IRCDMessageTopic() : IRCDMessage("TOPIC", 4) { } + IRCDMessageTopic(Module *creator) : IRCDMessage(creator, "TOPIC", 4) { } /* ** source = sender prefix @@ -1151,7 +1112,7 @@ struct IRCDMessageTopic : IRCDMessage */ bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c) c->ChangeTopicInternal(params[1], params[3], Anope::string(params[2]).is_pos_number_only() ? convertTo<time_t>(params[2]) : Anope::CurTime); @@ -1162,7 +1123,7 @@ struct IRCDMessageTopic : IRCDMessage struct IRCDMessageUmode2 : IRCDMessage { - IRCDMessageUmode2() : IRCDMessage("UMODE2", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } + IRCDMessageUmode2(Module *creator) : IRCDMessage(creator, "UMODE2", 1) { SetFlag(IRCDMESSAGE_REQUIRE_USER); } bool Run(MessageSource &source, const std::vector<Anope::string> ¶ms) anope_override { @@ -1176,22 +1137,21 @@ class ProtoUnreal : public Module UnrealIRCdProto ircd_proto; /* Core message handlers */ - CoreIRCDMessageAway core_message_away; - CoreIRCDMessageError core_message_error; - CoreIRCDMessageJoin core_message_join; - CoreIRCDMessageKick core_message_kick; - CoreIRCDMessageKill core_message_kill; - CoreIRCDMessageMOTD core_message_motd; - CoreIRCDMessagePart core_message_part; - CoreIRCDMessagePing core_message_ping; - CoreIRCDMessagePrivmsg core_message_privmsg; - CoreIRCDMessageQuit core_message_quit; - CoreIRCDMessageSQuit core_message_squit; - CoreIRCDMessageStats core_message_stats; - CoreIRCDMessageTime core_message_time; - CoreIRCDMessageTopic core_message_topic; - CoreIRCDMessageVersion core_message_version; - CoreIRCDMessageWhois core_message_whois; + Message::Away message_away; + Message::Error message_error; + Message::Join message_join; + Message::Kick message_kick; + Message::Kill message_kill; + Message::MOTD message_motd; + Message::Part message_part; + Message::Ping message_ping; + Message::Privmsg message_privmsg; + Message::Quit message_quit; + Message::SQuit message_squit; + Message::Stats message_stats; + Message::Time message_time; + Message::Version message_version; + Message::Whois message_whois; /* Our message handlers */ IRCDMessageCapab message_capab; @@ -1252,7 +1212,15 @@ class ProtoUnreal : public Module public: ProtoUnreal(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PROTOCOL), - message_mode("MODE"), message_svsmode("SVSMODE"), message_svs2mode("SVS2MODE"), message_sasl(this) + message_away(this), message_error(this), message_join(this), message_kick(this), message_kill(this), + message_motd(this), message_part(this), message_ping(this), message_privmsg(this), message_quit(this), + message_squit(this), message_stats(this), message_time(this), message_version(this), + message_whois(this), + + message_capab(this), message_chghost(this), message_chgident(this), message_chgname(this), message_mode(this, "MODE"), + message_svsmode(this, "SVSMODE"), message_svs2mode(this, "SVS2MODE"), message_netinfo(this), message_nick(this), message_pong(this), + message_sasl(this), message_sdesc(this), message_sethost(this), message_setident(this), message_setname(this), message_server(this), + message_sjoin(this), message_topic(this), message_umode2(this) { this->SetAuthor("Anope"); @@ -1263,15 +1231,21 @@ class ProtoUnreal : public Module ModuleManager::SetPriority(this, PRIORITY_FIRST); } + IRCDProto *GetIRCDProto() anope_override + { + return &ircd_proto; + } + void OnUserNickChange(User *u, const Anope::string &) anope_override { u->RemoveModeInternal(ModeManager::FindUserModeByName(UMODE_REGISTERED)); - ircdproto->SendLogout(u); + if (Servers::Capab.count("ESVID") == 0) + IRCD->SendLogout(u); } void OnChannelCreate(Channel *c) anope_override { - if (Config->UseServerSideMLock && Capab.count("MLOCK") > 0 && c->ci) + if (Config->UseServerSideMLock && Servers::Capab.count("MLOCK") > 0 && c->ci) { Anope::string modes = c->ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", ""); UplinkSocket::Message(Me) << "MLOCK " << static_cast<long>(c->creation_time) << " " << c->ci->name << " " << modes; @@ -1296,9 +1270,9 @@ class ProtoUnreal : public Module EventReturn OnMLock(ChannelInfo *ci, ModeLock *lock) anope_override { ChannelMode *cm = ModeManager::FindChannelModeByName(lock->name); - if (cm && ci->c && (cm->Type == MODE_REGULAR || cm->Type == MODE_PARAM) && Capab.count("MLOCK") > 0 && Config->UseServerSideMLock) + if (cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Servers::Capab.count("MLOCK") > 0 && Config->UseServerSideMLock) { - Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "") + cm->ModeChar; + Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "") + cm->mchar; UplinkSocket::Message(Me) << "MLOCK " << static_cast<long>(ci->c->creation_time) << " " << ci->name << " " << modes; } @@ -1308,9 +1282,9 @@ class ProtoUnreal : public Module EventReturn OnUnMLock(ChannelInfo *ci, ModeLock *lock) anope_override { ChannelMode *cm = ModeManager::FindChannelModeByName(lock->name); - if (cm && ci->c && (cm->Type == MODE_REGULAR || cm->Type == MODE_PARAM) && Capab.count("MLOCK") > 0 && Config->UseServerSideMLock) + if (cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Servers::Capab.count("MLOCK") > 0 && Config->UseServerSideMLock) { - Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "").replace_all_cs(cm->ModeChar, ""); + Anope::string modes = ci->GetMLockAsString(false).replace_all_cs("+", "").replace_all_cs("-", "").replace_all_cs(cm->mchar, ""); UplinkSocket::Message(Me) << "MLOCK " << static_cast<long>(ci->c->creation_time) << " " << ci->name << " " << modes; } diff --git a/modules/pseudoclients/botserv.cpp b/modules/pseudoclients/botserv.cpp index e653e7d3e..f78d0a6de 100644 --- a/modules/pseudoclients/botserv.cpp +++ b/modules/pseudoclients/botserv.cpp @@ -20,8 +20,8 @@ class BotServCore : public Module { this->SetAuthor("Anope"); - const BotInfo *BotServ = findbot(Config->BotServ); - if (BotServ == NULL) + BotServ = BotInfo::Find(Config->BotServ); + if (!BotServ) throw ModuleException("No bot named " + Config->BotServ); Implementation i[] = { I_OnPrivmsg, I_OnJoinChannel, I_OnLeaveChannel, @@ -41,7 +41,7 @@ class BotServCore : public Module Anope::string ctcp = msg; ctcp.erase(ctcp.begin()); ctcp.erase(ctcp.length() - 1); - ircdproto->SendCTCP(c->ci->bi, u->nick, "%s", ctcp.c_str()); + IRCD->SendCTCP(c->ci->bi, u->nick, "%s", ctcp.c_str()); } Anope::string realbuf = msg; @@ -56,7 +56,8 @@ class BotServCore : public Module if (realbuf.empty() || !c->ci->botflags.HasFlag(BS_FANTASY)) return; - std::vector<Anope::string> params = BuildStringVector(realbuf); + std::vector<Anope::string> params; + spacesepstream(realbuf).GetTokens(params); if (!realbuf.find(c->ci->bi->nick)) params.erase(params.begin()); @@ -87,7 +88,7 @@ class BotServCore : public Module return; const CommandInfo &info = it->second; - service_reference<Command> cmd("Command", info.name); + ServiceReference<Command> cmd("Command", info.name); if (!cmd) { Log(LOG_DEBUG) << "Fantasy command " << it->first << " exists for nonexistant service " << info.name << "!"; @@ -97,10 +98,10 @@ class BotServCore : public Module for (unsigned i = 0, j = params.size() - (count - 1); i < j; ++i) params.erase(params.begin()); - while (cmd->MaxParams > 0 && params.size() > cmd->MaxParams) + while (cmd->max_params > 0 && params.size() > cmd->max_params) { - params[cmd->MaxParams - 1] += " " + params[cmd->MaxParams]; - params.erase(params.begin() + cmd->MaxParams); + params[cmd->max_params - 1] += " " + params[cmd->max_params]; + params.erase(params.begin() + cmd->max_params); } /* All ChanServ commands take the channel as a first parameter */ @@ -111,7 +112,7 @@ class BotServCore : public Module if (!cmd->HasFlag(CFLAG_ALLOW_UNREGISTERED) && !u->Account()) return; - if (params.size() < cmd->MinParams) + if (params.size() < cmd->min_params) return; CommandSource source(u->nick, u, u->Account(), u, c->ci->bi); @@ -139,8 +140,8 @@ class BotServCore : public Module if (MOD_RESULT == EVENT_STOP) return; - dynamic_reference<User> user_reference(u); - dynamic_reference<NickCore> nc_reference(u->Account()); + Reference<User> user_reference(u); + Reference<NickCore> nc_reference(u->Account()); cmd->Execute(source, params); if (user_reference && nc_reference) @@ -160,14 +161,14 @@ class BotServCore : public Module * legit users - Rob **/ if (c->users.size() >= Config->BSMinUsers && !c->FindUser(c->ci->bi)) - c->ci->bi->Join(c, &Config->BotModeList); + c->ci->bi->Join(c, &ModeManager::DefaultBotModes); /* Only display the greet if the main uplink we're connected * to has synced, or we'll get greet-floods when the net * recovers from a netsplit. -GD */ if (c->FindUser(c->ci->bi) && c->ci->botflags.HasFlag(BS_GREET) && user->Account() && !user->Account()->greet.empty() && c->ci->AccessFor(user).HasPriv("GREET") && user->server->IsSynced()) { - ircdproto->SendPrivmsg(c->ci->bi, c->name, "[%s] %s", user->Account()->display.c_str(), user->Account()->greet.c_str()); + IRCD->SendPrivmsg(c->ci->bi, c->name, "[%s] %s", user->Account()->display.c_str(), user->Account()->greet.c_str()); c->ci->bi->lastmsg = Anope::CurTime; } } diff --git a/modules/pseudoclients/botserv.h b/modules/pseudoclients/botserv.h new file mode 100644 index 000000000..9757e5d4e --- /dev/null +++ b/modules/pseudoclients/botserv.h @@ -0,0 +1,6 @@ +#ifndef BOTSERV_H +#define BOTSERV_H + +static Reference<BotInfo> BotServ; + +#endif // BOTSERV_H diff --git a/modules/pseudoclients/chanserv.cpp b/modules/pseudoclients/chanserv.cpp index c3a6e6479..7a5b482bb 100644 --- a/modules/pseudoclients/chanserv.cpp +++ b/modules/pseudoclients/chanserv.cpp @@ -20,7 +20,7 @@ class ExpireCallback : public CallBack void Tick(time_t) anope_override { - if (!Config->CSExpire || noexpire || readonly) + if (!Config->CSExpire || Anope::NoExpire || Anope::ReadOnly) return; for (registered_channel_map::const_iterator it = RegisteredChannelList->begin(), it_end = RegisteredChannelList->end(); it != it_end; ) @@ -30,7 +30,7 @@ class ExpireCallback : public CallBack bool expire = false; - if (!ci->c && Config->CSExpire && Anope::CurTime - ci->last_used >= Config->CSExpire) + if (!ci->c && Anope::CurTime - ci->last_used >= Config->CSExpire) expire = true; if (ci->HasFlag(CI_NO_EXPIRE)) @@ -46,7 +46,7 @@ class ExpireCallback : public CallBack Log(LOG_NORMAL, "chanserv/expire") << "Expiring " << extra << "channel " << ci->name << " (founder: " << (ci->GetFounder() ? ci->GetFounder()->display : "(none)") << ")"; FOREACH_MOD(I_OnChanExpire, OnChanExpire(ci)); - ci->destroy(); + ci->Destroy(); } } } @@ -61,8 +61,8 @@ class ChanServCore : public Module { this->SetAuthor("Anope"); - const BotInfo *ChanServ = findbot(Config->ChanServ); - if (ChanServ == NULL) + ChanServ = BotInfo::Find(Config->ChanServ); + if (!ChanServ) throw ModuleException("No bot named " + Config->ChanServ); Implementation i[] = { I_OnBotPrivmsg, I_OnDelCore, I_OnPreHelp, I_OnPostHelp, I_OnCheckModes }; @@ -99,7 +99,7 @@ class ChanServCore : public Module for (unsigned j = 0; j < ci->GetAccessCount(); ++j) { const ChanAccess *ca = ci->GetAccess(j); - const NickCore *anc = findcore(ca->mask); + const NickCore *anc = NickCore::Find(ca->mask); if (!anc || (!anc->IsServicesOper() && Config->CSMaxReg && anc->channelcount >= Config->CSMaxReg) || (anc == nc)) continue; @@ -107,7 +107,7 @@ class ChanServCore : public Module highest = ca; } if (highest) - newowner = findcore(highest->mask); + newowner = NickCore::Find(highest->mask); } if (newowner) @@ -120,7 +120,7 @@ class ChanServCore : public Module { Log(LOG_NORMAL, "chanserv/expire") << "Deleting channel " << ci->name << " owned by deleted nick " << nc->display; - ci->destroy(); + ci->Destroy(); continue; } } @@ -131,7 +131,7 @@ class ChanServCore : public Module for (unsigned j = 0; j < ci->GetAccessCount(); ++j) { const ChanAccess *ca = ci->GetAccess(j); - const NickCore *anc = findcore(ca->mask); + const NickCore *anc = NickCore::Find(ca->mask); if (anc && anc == nc) { diff --git a/modules/pseudoclients/chanserv.h b/modules/pseudoclients/chanserv.h new file mode 100644 index 000000000..6c9ccd6c6 --- /dev/null +++ b/modules/pseudoclients/chanserv.h @@ -0,0 +1,6 @@ +#ifndef CHANSERV_H +#define CHANSERV_H + +static Reference<BotInfo> ChanServ; + +#endif // CHANSERV_H diff --git a/modules/pseudoclients/global.cpp b/modules/pseudoclients/global.cpp index 13e7570ce..a5e1eb573 100644 --- a/modules/pseudoclients/global.cpp +++ b/modules/pseudoclients/global.cpp @@ -53,8 +53,8 @@ class GlobalCore : public Module { this->SetAuthor("Anope"); - const BotInfo *Global = findbot(Config->Global); - if (Global == NULL) + Global = BotInfo::Find(Config->Global); + if (!Global) throw ModuleException("No bot named " + Config->Global); Implementation i[] = { I_OnRestart, I_OnShutdown, I_OnNewServer, I_OnPreHelp }; @@ -64,19 +64,19 @@ class GlobalCore : public Module void OnRestart() anope_override { if (Config->GlobalOnCycle) - global->SendGlobal(findbot(Config->Global), "", Config->GlobalOnCycleMessage); + GlobalService->SendGlobal(Global, "", Config->GlobalOnCycleMessage); } void OnShutdown() anope_override { if (Config->GlobalOnCycle) - global->SendGlobal(findbot(Config->Global), "", Config->GlobalOnCycleMessage); + GlobalService->SendGlobal(Global, "", Config->GlobalOnCycleMessage); } void OnNewServer(Server *s) anope_override { if (Config->GlobalOnCycle && !Config->GlobalOnCycleUP.empty()) - s->Notice(findbot(Config->Global), Config->GlobalOnCycleUP); + s->Notice(Global, Config->GlobalOnCycleUP); } EventReturn OnPreHelp(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override diff --git a/modules/pseudoclients/global.h b/modules/pseudoclients/global.h index 75d783399..46bccef6d 100644 --- a/modules/pseudoclients/global.h +++ b/modules/pseudoclients/global.h @@ -14,7 +14,8 @@ class GlobalService : public Service virtual void SendGlobal(const BotInfo *sender, const Anope::string &source, const Anope::string &message) = 0; }; -static service_reference<GlobalService> global("GlobalService", "Global"); +static ServiceReference<GlobalService> GlobalService("GlobalService", "Global"); +static Reference<BotInfo> Global; #endif // GLOBAL_H diff --git a/modules/pseudoclients/hostserv.cpp b/modules/pseudoclients/hostserv.cpp index d0d078a79..47c4250c0 100644 --- a/modules/pseudoclients/hostserv.cpp +++ b/modules/pseudoclients/hostserv.cpp @@ -20,11 +20,11 @@ class HostServCore : public Module { this->SetAuthor("Anope"); - if (!ircdproto || !ircdproto->CanSetVHost) + if (!IRCD || !IRCD->CanSetVHost) throw ModuleException("Your IRCd does not support vhosts"); - const BotInfo *HostServ = findbot(Config->HostServ); - if (HostServ == NULL) + HostServ = BotInfo::Find(Config->HostServ); + if (!HostServ) throw ModuleException("No bot named " + Config->HostServ); Implementation i[] = { I_OnNickIdentify, I_OnNickUpdate, I_OnPreHelp }; @@ -33,29 +33,28 @@ class HostServCore : public Module void OnNickIdentify(User *u) anope_override { - const NickAlias *na = findnick(u->nick); + const NickAlias *na = NickAlias::Find(u->nick); if (!na || !na->HasVhost()) - na = findnick(u->Account()->display); - if (!ircdproto->CanSetVHost || !na || !na->HasVhost()) + na = NickAlias::Find(u->Account()->display); + if (!IRCD->CanSetVHost || !na || !na->HasVhost()) return; if (u->vhost.empty() || !u->vhost.equals_cs(na->GetVhostHost()) || (!na->GetVhostIdent().empty() && !u->GetVIdent().equals_cs(na->GetVhostIdent()))) { - ircdproto->SendVhost(u, na->GetVhostIdent(), na->GetVhostHost()); + IRCD->SendVhost(u, na->GetVhostIdent(), na->GetVhostHost()); u->vhost = na->GetVhostHost(); u->UpdateHost(); - if (ircdproto->CanSetVIdent && !na->GetVhostIdent().empty()) + if (IRCD->CanSetVIdent && !na->GetVhostIdent().empty()) u->SetVIdent(na->GetVhostIdent()); - const BotInfo *bi = findbot(Config->HostServ); - if (bi) + if (HostServ) { if (!na->GetVhostIdent().empty()) - u->SendMessage(bi, _("Your vhost of \002%s\002@\002%s\002 is now activated."), na->GetVhostIdent().c_str(), na->GetVhostHost().c_str()); + u->SendMessage(HostServ, _("Your vhost of \002%s\002@\002%s\002 is now activated."), na->GetVhostIdent().c_str(), na->GetVhostHost().c_str()); else - u->SendMessage(bi, _("Your vhost of \002%s\002 is now activated."), na->GetVhostHost().c_str()); + u->SendMessage(HostServ, _("Your vhost of \002%s\002 is now activated."), na->GetVhostHost().c_str()); } } } diff --git a/modules/pseudoclients/hostserv.h b/modules/pseudoclients/hostserv.h new file mode 100644 index 000000000..039e711c3 --- /dev/null +++ b/modules/pseudoclients/hostserv.h @@ -0,0 +1,6 @@ +#ifndef HOSTSERV_H +#define HOSTSERV_H + +static Reference<BotInfo> HostServ; + +#endif // HOSTSERV_H diff --git a/modules/pseudoclients/memoserv.cpp b/modules/pseudoclients/memoserv.cpp index 9cfca1af3..ee9c127f9 100644 --- a/modules/pseudoclients/memoserv.cpp +++ b/modules/pseudoclients/memoserv.cpp @@ -16,8 +16,8 @@ static bool SendMemoMail(NickCore *nc, MemoInfo *mi, Memo *m) { - Anope::string subject = translate(nc, Config->MailMemoSubject.c_str()); - Anope::string message = translate(nc, Config->MailMemoMessage.c_str()); + Anope::string subject = Language::Translate(nc, Config->MailMemoSubject.c_str()); + Anope::string message = Language::Translate(nc, Config->MailMemoMessage.c_str()); subject = subject.replace_all_cs("%n", nc->display); subject = subject.replace_all_cs("%s", m->sender); @@ -29,7 +29,7 @@ static bool SendMemoMail(NickCore *nc, MemoInfo *mi, Memo *m) message = message.replace_all_cs("%d", mi->GetIndex(m)); message = message.replace_all_cs("%t", m->text); - return Mail(nc, subject, message); + return Mail::Send(nc, subject, message); } class MyMemoServService : public MemoServService @@ -42,14 +42,14 @@ class MyMemoServService : public MemoServService if (!target.empty() && target[0] == '#') { ischan = true; - ChannelInfo *ci = cs_findchan(target); + ChannelInfo *ci = ChannelInfo::Find(target); if (ci != NULL) return &ci->memos; } else { ischan = false; - NickAlias *na = findnick(target); + NickAlias *na = NickAlias::Find(target); if (na != NULL) return &na->nc->memos; } @@ -65,7 +65,7 @@ class MyMemoServService : public MemoServService if (mi == NULL) return MEMO_INVALID_TARGET; - User *sender = finduser(source); + User *sender = User::Find(source); if (sender != NULL && !sender->HasPriv("memoserv/no-limit") && !force) { if (Config->MSSendDelay > 0 && sender->lastmemosend + Config->MSSendDelay > Anope::CurTime) @@ -93,7 +93,7 @@ class MyMemoServService : public MemoServService if (ischan) { - ChannelInfo *ci = cs_findchan(target); + ChannelInfo *ci = ChannelInfo::Find(target); if (ci->c) { @@ -104,25 +104,25 @@ class MyMemoServService : public MemoServService if (ci->AccessFor(cu->user).HasPriv("MEMO")) { if (cu->user->Account() && cu->user->Account()->HasFlag(NI_MEMO_RECEIVE)) - cu->user->SendMessage(findbot(Config->MemoServ), MEMO_NEW_X_MEMO_ARRIVED, ci->name.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), ci->name.c_str(), mi->memos->size()); + cu->user->SendMessage(MemoServ, MEMO_NEW_X_MEMO_ARRIVED, ci->name.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), ci->name.c_str(), mi->memos->size()); } } } } else { - NickCore *nc = findnick(target)->nc; + NickCore *nc = NickAlias::Find(target)->nc; if (nc->HasFlag(NI_MEMO_RECEIVE)) { - for (std::list<serialize_obj<NickAlias> >::const_iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end;) + for (std::list<Serialize::Reference<NickAlias> >::const_iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end;) { const NickAlias *na = *it++; if (!na) continue; - User *user = finduser(na->nick); + User *user = User::Find(na->nick); if (user && user->IsIdentified()) - user->SendMessage(findbot(Config->MemoServ), MEMO_NEW_MEMO_ARRIVED, source.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), mi->memos->size()); + user->SendMessage(MemoServ, MEMO_NEW_MEMO_ARRIVED, source.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), mi->memos->size()); } } @@ -139,20 +139,19 @@ class MyMemoServService : public MemoServService const NickCore *nc = u->Account(); if (!nc) return; - const BotInfo *ms = findbot(Config->MemoServ); unsigned i = 0, end = nc->memos.memos->size(), newcnt = 0; for (; i < end; ++i) if (nc->memos.GetMemo(i)->HasFlag(MF_UNREAD)) ++newcnt; if (newcnt > 0) - u->SendMessage(ms, newcnt == 1 ? _("You have 1 new memo.") : _("You have %d new memos."), newcnt); + u->SendMessage(MemoServ, newcnt == 1 ? _("You have 1 new memo.") : _("You have %d new memos."), newcnt); if (nc->memos.memomax > 0 && nc->memos.memos->size() >= static_cast<unsigned>(nc->memos.memomax)) { if (nc->memos.memos->size() > static_cast<unsigned>(nc->memos.memomax)) - u->SendMessage(ms, _("You are over your maximum number of memos (%d). You will be unable to receive any new memos until you delete some of your current ones."), nc->memos.memomax); + u->SendMessage(MemoServ, _("You are over your maximum number of memos (%d). You will be unable to receive any new memos until you delete some of your current ones."), nc->memos.memomax); else - u->SendMessage(ms, _("You have reached your maximum number of memos (%d). You will be unable to receive any new memos until you delete some of your current ones."), nc->memos.memomax); + u->SendMessage(MemoServ, _("You have reached your maximum number of memos (%d). You will be unable to receive any new memos until you delete some of your current ones."), nc->memos.memomax); } } }; @@ -166,7 +165,8 @@ class MemoServCore : public Module { this->SetAuthor("Anope"); - if (!findbot(Config->MemoServ)) + MemoServ = BotInfo::Find(Config->MemoServ); + if (!MemoServ) throw ModuleException("No bot named " + Config->MemoServ); Implementation i[] = { I_OnNickIdentify, I_OnJoinChannel, I_OnUserAway, I_OnNickUpdate, I_OnPreHelp, I_OnPostHelp }; @@ -183,9 +183,9 @@ class MemoServCore : public Module if (c->ci && c->ci->AccessFor(u).HasPriv("MEMO") && c->ci->memos.memos->size() > 0) { if (c->ci->memos.memos->size() == 1) - u->SendMessage(findbot(Config->MemoServ), _("There is \002%d\002 memo on channel %s."), c->ci->memos.memos->size(), c->ci->name.c_str()); + u->SendMessage(MemoServ, _("There is \002%d\002 memo on channel %s."), c->ci->memos.memos->size(), c->ci->name.c_str()); else - u->SendMessage(findbot(Config->MemoServ), _("There are \002%d\002 memos on channel %s."), c->ci->memos.memos->size(), c->ci->name.c_str()); + u->SendMessage(MemoServ, _("There are \002%d\002 memos on channel %s."), c->ci->memos.memos->size(), c->ci->name.c_str()); } } diff --git a/modules/pseudoclients/memoserv.h b/modules/pseudoclients/memoserv.h index aae7d26b5..25d453ab0 100644 --- a/modules/pseudoclients/memoserv.h +++ b/modules/pseudoclients/memoserv.h @@ -35,7 +35,8 @@ class MemoServService : public Service virtual void Check(User *u) = 0; }; -static service_reference<MemoServService> memoserv("MemoServService", "MemoServ"); +static ServiceReference<MemoServService> MemoServService("MemoServService", "MemoServ"); +static Reference<BotInfo> MemoServ; #endif // MEMOSERV_H diff --git a/modules/pseudoclients/nickserv.cpp b/modules/pseudoclients/nickserv.cpp index 637003682..95044f610 100644 --- a/modules/pseudoclients/nickserv.cpp +++ b/modules/pseudoclients/nickserv.cpp @@ -15,23 +15,20 @@ #include "nickserv.h" class NickServCollide; -class NickServRelease; typedef std::map<Anope::string, NickServCollide *> nickservcollides_map; -typedef std::map<Anope::string, NickServRelease *> nickservreleases_map; static nickservcollides_map NickServCollides; -static nickservreleases_map NickServReleases; /** Timer for colliding nicks to force people off of nicknames */ class NickServCollide : public Timer { - dynamic_reference<User> u; + Reference<User> u; Anope::string nick; public: - /** Default constructor + /** Constructor * @param nick The nick we're colliding * @param delay How long to delay before kicking the user off the nick */ @@ -45,8 +42,6 @@ class NickServCollide : public Timer NickServCollides.insert(std::make_pair(nick, this)); } - /** Default destructor - */ virtual ~NickServCollide() { NickServCollides.erase(this->nick); @@ -60,7 +55,7 @@ class NickServCollide : public Timer if (!u) return; /* If they identified or don't exist anymore, don't kill them. */ - NickAlias *na = findnick(u->nick); + NickAlias *na = NickAlias::Find(u->nick); if (!na || u->Account() == na->nc || u->timestamp > this->GetSetTime()) return; @@ -75,10 +70,9 @@ class MyNickServService : public NickServService void Validate(User *u) anope_override { - NickAlias *na = findnick(u->nick); + NickAlias *na = NickAlias::Find(u->nick); if (!na) return; - const BotInfo *NickServ = findbot(Config->NickServ); if (na->nc->HasFlag(NI_SUSPENDED)) { @@ -124,12 +118,12 @@ class MyNickServService : public NickServService } else if (na->nc->HasFlag(NI_KILL_QUICK)) { - u->SendMessage(NickServ, _("If you do not change within %s, I will change your nick."), duration(Config->NSKillQuick, u->Account()).c_str()); + u->SendMessage(NickServ, _("If you do not change within %s, I will change your nick."), Anope::Duration(Config->NSKillQuick, u->Account()).c_str()); new NickServCollide(u, Config->NSKillQuick); } else { - u->SendMessage(NickServ, _("If you do not change within %s, I will change your nick."), duration(Config->NSKill, u->Account()).c_str()); + u->SendMessage(NickServ, _("If you do not change within %s, I will change your nick."), Anope::Duration(Config->NSKill, u->Account()).c_str()); new NickServCollide(u, Config->NSKill); } } @@ -144,7 +138,7 @@ class ExpireCallback : public CallBack void Tick(time_t) anope_override { - if (noexpire || readonly) + if (Anope::NoExpire || Anope::ReadOnly) return; for (nickalias_map::const_iterator it = NickAliasList->begin(), it_end = NickAliasList->end(); it != it_end; ) @@ -152,7 +146,7 @@ class ExpireCallback : public CallBack NickAlias *na = it->second; ++it; - User *u = finduser(na->nick); + User *u = User::Find(na->nick); if (u && (na->nc->HasFlag(NI_SECURE) ? u->IsIdentified(true) : u->IsRecognized())) na->last_seen = Anope::CurTime; @@ -175,7 +169,7 @@ class ExpireCallback : public CallBack extra = "suspended "; Log(LOG_NORMAL, "expire") << "Expiring " << extra << "nickname " << na->nick << " (group: " << na->nc->display << ") (e-mail: " << (na->nc->email.empty() ? "none" : na->nc->email) << ")"; FOREACH_MOD(I_OnNickExpire, OnNickExpire(na)); - na->destroy(); + na->Destroy(); } } } @@ -191,7 +185,8 @@ class NickServCore : public Module { this->SetAuthor("Anope"); - if (!findbot(Config->NickServ)) + NickServ = BotInfo::Find(Config->NickServ); + if (!NickServ) throw ModuleException("No bot named " + Config->NickServ); Implementation i[] = { I_OnDelNick, I_OnDelCore, I_OnChangeCoreDisplay, I_OnNickIdentify, I_OnNickGroup, @@ -201,45 +196,41 @@ class NickServCore : public Module void OnDelNick(NickAlias *na) anope_override { - User *u = finduser(na->nick); + User *u = User::Find(na->nick); if (u && u->Account() == na->nc) { - ircdproto->SendLogout(u); - u->RemoveMode(findbot(Config->NickServ), UMODE_REGISTERED); + IRCD->SendLogout(u); + u->RemoveMode(NickServ, UMODE_REGISTERED); u->Logout(); } } void OnDelCore(NickCore *nc) anope_override { - Log(findbot(Config->NickServ), "nick") << "deleting nickname group " << nc->display; + Log(NickServ, "nick") << "deleting nickname group " << nc->display; - /* Clean up this nick core from any users online using it - * (ones that /nick but remain unidentified) - */ - for (std::list<User *>::iterator it = nc->Users.begin(); it != nc->Users.end();) + /* Clean up this nick core from any users online */ + for (std::list<User *>::iterator it = nc->users.begin(); it != nc->users.end();) { User *user = *it++; - ircdproto->SendLogout(user); - user->RemoveMode(findbot(Config->NickServ), UMODE_REGISTERED); + IRCD->SendLogout(user); + user->RemoveMode(NickServ, UMODE_REGISTERED); user->Logout(); FOREACH_MOD(I_OnNickLogout, OnNickLogout(user)); } - nc->Users.clear(); + nc->users.clear(); } void OnChangeCoreDisplay(NickCore *nc, const Anope::string &newdisplay) anope_override { - Log(LOG_NORMAL, "nick", findbot(Config->NickServ)) << "Changing " << nc->display << " nickname group display to " << newdisplay; + Log(LOG_NORMAL, "nick", NickServ) << "Changing " << nc->display << " nickname group display to " << newdisplay; } void OnNickIdentify(User *u) anope_override { - const BotInfo *NickServ = findbot(Config->NickServ); - if (!Config->NoNicknameOwnership) { - const NickAlias *this_na = findnick(u->nick); + const NickAlias *this_na = NickAlias::Find(u->nick); if (this_na && this_na->nc == u->Account() && u->Account()->HasFlag(NI_UNCONFIRMED) == false) u->SetMode(NickServ, UMODE_REGISTERED); } @@ -250,7 +241,7 @@ class NickServCore : public Module ChannelContainer *cc = *it; Channel *c = cc->chan; if (c) - chan_set_correct_modes(u, c, 1, true); + c->SetCorrectModes(u, true, true); } if (!Config->NSModesOnID.empty()) @@ -269,17 +260,17 @@ class NickServCore : public Module if (u->Account()->HasFlag(NI_UNCONFIRMED)) { u->SendMessage(NickServ, _("Your email address is not confirmed. To confirm it, follow the instructions that were emailed to you when you registered.")); - const NickAlias *this_na = findnick(u->Account()->display); + const NickAlias *this_na = NickAlias::Find(u->Account()->display); time_t time_registered = Anope::CurTime - this_na->time_registered; if (Config->NSUnconfirmedExpire > time_registered) - u->SendMessage(NickServ, _("Your account will expire, if not confirmed, in %s"), duration(Config->NSUnconfirmedExpire - time_registered).c_str()); + u->SendMessage(NickServ, _("Your account will expire, if not confirmed, in %s"), Anope::Duration(Config->NSUnconfirmedExpire - time_registered).c_str()); } } void OnNickGroup(User *u, NickAlias *target) anope_override { if (target->nc->HasFlag(NI_UNCONFIRMED) == false) - u->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + u->SetMode(NickServ, UMODE_REGISTERED); } void OnNickUpdate(User *u) anope_override @@ -289,14 +280,13 @@ class NickServCore : public Module ChannelContainer *cc = *it; Channel *c = cc->chan; if (c) - chan_set_correct_modes(u, c, 1, false); + c->SetCorrectModes(u, true, true); } } void OnUserNickChange(User *u, const Anope::string &oldnick) anope_override { - const NickAlias *na = findnick(u->nick); - const BotInfo *NickServ = findbot(Config->NickServ); + const NickAlias *na = NickAlias::Find(u->nick); /* If the new nick isnt registerd or its registerd and not yours */ if (!na || na->nc != u->Account()) { @@ -308,7 +298,7 @@ class NickServCore : public Module else { /* Reset +r and re-send account (even though it really should be set at this point) */ - ircdproto->SendLogin(u); + IRCD->SendLogin(u); if (!Config->NoNicknameOwnership && na->nc == u->Account() && na->nc->HasFlag(NI_UNCONFIRMED) == false) u->SetMode(NickServ, UMODE_REGISTERED); Log(NickServ) << u->GetMask() << " automatically identified for group " << u->Account()->display; @@ -318,7 +308,7 @@ class NickServCore : public Module void OnUserModeSet(User *u, UserModeName Name) anope_override { if (Name == UMODE_REGISTERED && !u->IsIdentified()) - u->RemoveMode(findbot(Config->NickServ), Name); + u->RemoveMode(NickServ, Name); } EventReturn OnPreHelp(CommandSource &source, const std::vector<Anope::string> ¶ms) anope_override @@ -357,10 +347,10 @@ class NickServCore : public Module "nickname(s)."), Config->NickServ.c_str()); } - void OnUserConnect(dynamic_reference<User> &u, bool &exempt) anope_override + void OnUserConnect(Reference<User> &u, bool &exempt) anope_override { - if (!Config->NoNicknameOwnership && !Config->NSUnregisteredNotice.empty() && u && !findnick(u->nick)) - u->SendMessage(findbot(Config->NickServ), Config->NSUnregisteredNotice); + if (!Config->NoNicknameOwnership && !Config->NSUnregisteredNotice.empty() && u && !NickAlias::Find(u->nick)) + u->SendMessage(NickServ, Config->NSUnregisteredNotice); } }; diff --git a/modules/pseudoclients/nickserv.h b/modules/pseudoclients/nickserv.h index 750b77784..52934fe96 100644 --- a/modules/pseudoclients/nickserv.h +++ b/modules/pseudoclients/nickserv.h @@ -9,7 +9,8 @@ class NickServService : public Service virtual void Validate(User *u) = 0; }; -static service_reference<NickServService> nickserv("NickServService", "NickServ"); +static ServiceReference<NickServService> NickServService("NickServService", "NickServ"); +static Reference<BotInfo> NickServ; #endif // NICKSERV_H diff --git a/modules/pseudoclients/operserv.cpp b/modules/pseudoclients/operserv.cpp index cc051d685..8ee8c211b 100644 --- a/modules/pseudoclients/operserv.cpp +++ b/modules/pseudoclients/operserv.cpp @@ -25,28 +25,28 @@ class SGLineManager : public XLineManager void OnExpire(const XLine *x) anope_override { - Log(findbot(Config->OperServ), "expire/akill") << "AKILL on \2" << x->Mask << "\2 has expired"; + Log(OperServ, "expire/akill") << "AKILL on \2" << x->mask << "\2 has expired"; } void Send(User *u, XLine *x) anope_override { - ircdproto->SendAkill(u, x); + IRCD->SendAkill(u, x); } void SendDel(XLine *x) anope_override { try { - if (!ircdproto->CanSZLine) + if (!IRCD->CanSZLine) throw SocketException("SZLine is not supported"); else if (x->GetUser() != "*") throw SocketException("Can not ZLine a username"); sockaddrs(x->GetHost()); - ircdproto->SendSZLineDel(x); + IRCD->SendSZLineDel(x); } catch (const SocketException &) { - ircdproto->SendAkillDel(x); + IRCD->SendAkillDel(x); } } @@ -101,30 +101,30 @@ class SQLineManager : public XLineManager void OnExpire(const XLine *x) anope_override { - Log(findbot(Config->OperServ), "expire/sqline") << "SQLINE on \2" << x->Mask << "\2 has expired"; + Log(OperServ, "expire/sqline") << "SQLINE on \2" << x->mask << "\2 has expired"; } void Send(User *u, XLine *x) anope_override { - ircdproto->SendSQLine(u, x); + IRCD->SendSQLine(u, x); } void SendDel(XLine *x) anope_override { - ircdproto->SendSQLineDel(x); + IRCD->SendSQLineDel(x); } bool Check(User *u, const XLine *x) anope_override { if (x->regex) return x->regex->Matches(u->nick); - return Anope::Match(u->nick, x->Mask); + return Anope::Match(u->nick, x->mask); } bool CheckChannel(Channel *c) { for (std::vector<XLine *>::const_iterator it = this->GetList().begin(), it_end = this->GetList().end(); it != it_end; ++it) - if (Anope::Match(c->name, (*it)->Mask, false, true)) + if (Anope::Match(c->name, (*it)->mask, false, true)) return true; return false; } @@ -142,24 +142,24 @@ class SNLineManager : public XLineManager void OnExpire(const XLine *x) anope_override { - Log(findbot(Config->OperServ), "expire/snline") << "SNLINE on \2" << x->Mask << "\2 has expired"; + Log(OperServ, "expire/snline") << "SNLINE on \2" << x->mask << "\2 has expired"; } void Send(User *u, XLine *x) anope_override { - ircdproto->SendSGLine(u, x); + IRCD->SendSGLine(u, x); } void SendDel(XLine *x) anope_override { - ircdproto->SendSGLineDel(x); + IRCD->SendSGLineDel(x); } bool Check(User *u, const XLine *x) anope_override { if (x->regex) return x->regex->Matches(u->realname); - return Anope::Match(u->realname, x->Mask, false, true); + return Anope::Match(u->realname, x->mask, false, true); } }; @@ -175,7 +175,8 @@ class OperServCore : public Module { this->SetAuthor("Anope"); - if (!findbot(Config->OperServ)) + OperServ = BotInfo::Find(Config->OperServ); + if (!OperServ) throw ModuleException("No bot named " + Config->OperServ); Implementation i[] = { I_OnBotPrivmsg, I_OnServerQuit, I_OnUserModeSet, I_OnUserModeUnset, I_OnUserConnect, I_OnUserNickChange, I_OnPreHelp }; @@ -203,7 +204,7 @@ class OperServCore : public Module if (Config->OSOpersOnly && !u->HasMode(UMODE_OPER) && bi->nick == Config->OperServ) { u->SendMessage(bi, ACCESS_DENIED); - Log(findbot(Config->OperServ), "bados") << "Denied access to " << Config->OperServ << " from " << u->GetMask() << " (non-oper)"; + Log(OperServ, "bados") << "Denied access to " << Config->OperServ << " from " << u->GetMask() << " (non-oper)"; return EVENT_STOP; } @@ -213,22 +214,22 @@ class OperServCore : public Module void OnServerQuit(Server *server) anope_override { if (server->HasFlag(SERVER_JUPED)) - Log(server, "squit", findbot(Config->OperServ)) << "Received SQUIT for juped server " << server->GetName(); + Log(server, "squit", OperServ) << "Received SQUIT for juped server " << server->GetName(); } void OnUserModeSet(User *u, UserModeName Name) anope_override { if (Name == UMODE_OPER) - Log(u, "oper", findbot(Config->OperServ)) << "is now an IRC operator."; + Log(u, "oper", OperServ) << "is now an IRC operator."; } void OnUserModeUnset(User *u, UserModeName Name) anope_override { if (Name == UMODE_OPER) - Log(u, "oper", findbot(Config->OperServ)) << "is no longer an IRC operator"; + Log(u, "oper", OperServ) << "is no longer an IRC operator"; } - void OnUserConnect(dynamic_reference<User> &u, bool &exempt) anope_override + void OnUserConnect(Reference<User> &u, bool &exempt) anope_override { if (u && !exempt) XLineManager::CheckAll(u); @@ -236,7 +237,7 @@ class OperServCore : public Module void OnUserNickChange(User *u, const Anope::string &oldnick) anope_override { - if (ircdproto->CanSQLine && !u->HasMode(UMODE_OPER)) + if (IRCD->CanSQLine && !u->HasMode(UMODE_OPER)) this->sqlines.CheckAllXLines(u); } diff --git a/modules/pseudoclients/operserv.h b/modules/pseudoclients/operserv.h new file mode 100644 index 000000000..dd9dafc76 --- /dev/null +++ b/modules/pseudoclients/operserv.h @@ -0,0 +1,6 @@ +#ifndef OPERSERV_H +#define OPERSERV_H + +static Reference<BotInfo> OperServ; + +#endif // OPERSERV_H diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index f1f383397..b9d58f367 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -119,7 +119,6 @@ add_to_cpack_ignored_files("${SERVICES_BINARY}$" TRUE) configure_file(${Anope_SOURCE_DIR}/include/sysconf.h.cmake ${Anope_BINARY_DIR}/include/sysconf.h) # Go into the following directories and run their CMakeLists.txt as well -add_subdirectory(bin) add_subdirectory(tools) # Set Anope to be installed to the bin directory diff --git a/src/access.cpp b/src/access.cpp index 6b22ba871..863e0d41d 100644 --- a/src/access.cpp +++ b/src/access.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "service.h" @@ -24,27 +25,27 @@ bool Privilege::operator==(const Privilege &other) const return this->name == other.name; } -std::vector<Privilege> PrivilegeManager::privs; +std::vector<Privilege> PrivilegeManager::Privileges; void PrivilegeManager::AddPrivilege(Privilege p) { unsigned i; - for (i = 0; i < privs.size(); ++i) + for (i = 0; i < Privileges.size(); ++i) { - Privilege &priv = privs[i]; + Privilege &priv = Privileges[i]; if (priv.rank > p.rank) break; } - privs.insert(privs.begin() + i, p); + Privileges.insert(Privileges.begin() + i, p); } void PrivilegeManager::RemovePrivilege(Privilege &p) { - std::vector<Privilege>::iterator it = std::find(privs.begin(), privs.end(), p); - if (it != privs.end()) - privs.erase(it); + std::vector<Privilege>::iterator it = std::find(Privileges.begin(), Privileges.end(), p); + if (it != Privileges.end()) + Privileges.erase(it); for (registered_channel_map::const_iterator cit = RegisteredChannelList->begin(), cit_end = RegisteredChannelList->end(); cit != cit_end; ++cit) { @@ -55,39 +56,39 @@ void PrivilegeManager::RemovePrivilege(Privilege &p) Privilege *PrivilegeManager::FindPrivilege(const Anope::string &name) { - for (unsigned i = privs.size(); i > 0; --i) - if (privs[i - 1].name.equals_ci(name)) - return &privs[i - 1]; + for (unsigned i = Privileges.size(); i > 0; --i) + if (Privileges[i - 1].name.equals_ci(name)) + return &Privileges[i - 1]; return NULL; } std::vector<Privilege> &PrivilegeManager::GetPrivileges() { - return privs; + return Privileges; } void PrivilegeManager::ClearPrivileges() { - privs.clear(); + Privileges.clear(); } AccessProvider::AccessProvider(Module *o, const Anope::string &n) : Service(o, "AccessProvider", n) { - providers.push_back(this); + Providers.push_back(this); } AccessProvider::~AccessProvider() { - std::list<AccessProvider *>::iterator it = std::find(providers.begin(), providers.end(), this); - if (it != providers.end()) - providers.erase(it); + std::list<AccessProvider *>::iterator it = std::find(Providers.begin(), Providers.end(), this); + if (it != Providers.end()) + Providers.erase(it); } -std::list<AccessProvider *> AccessProvider::providers; +std::list<AccessProvider *> AccessProvider::Providers; const std::list<AccessProvider *>& AccessProvider::GetProviders() { - return providers; + return Providers; } ChanAccess::ChanAccess(AccessProvider *p) : Serializable("ChanAccess"), provider(p) @@ -98,7 +99,7 @@ ChanAccess::~ChanAccess() { } -Serialize::Data ChanAccess::serialize() const +Serialize::Data ChanAccess::Serialize() const { Serialize::Data data; @@ -106,17 +107,17 @@ Serialize::Data ChanAccess::serialize() const data["ci"] << this->ci->name; data["mask"] << this->mask; data["creator"] << this->creator; - data["last_seen"].setType(Serialize::DT_INT) << this->last_seen; - data["created"].setType(Serialize::DT_INT) << this->created; - data["data"] << this->Serialize(); + data["last_seen"].SetType(Serialize::DT_INT) << this->last_seen; + data["created"].SetType(Serialize::DT_INT) << this->created; + data["data"] << this->AccessSerialize(); return data; } -Serializable* ChanAccess::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* ChanAccess::Unserialize(Serializable *obj, Serialize::Data &data) { - service_reference<AccessProvider> aprovider("AccessProvider", data["provider"].astr()); - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ServiceReference<AccessProvider> aprovider("AccessProvider", data["provider"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (!aprovider || !ci) return NULL; @@ -130,7 +131,7 @@ Serializable* ChanAccess::unserialize(Serializable *obj, Serialize::Data &data) data["creator"] >> access->creator; data["last_seen"] >> access->last_seen; data["created"] >> access->created; - access->Unserialize(data["data"].astr()); + access->AccessUnserialize(data["data"].astr()); if (!obj) ci->AddAccess(access); @@ -145,7 +146,7 @@ bool ChanAccess::Matches(const User *u, const NickCore *nc) const else if (u && Anope::Match(u->GetDisplayedMask(), this->mask)) return true; else if (nc) - for (std::list<serialize_obj<NickAlias> >::const_iterator it = nc->aliases.begin(); it != nc->aliases.end();) + for (std::list<Serialize::Reference<NickAlias> >::const_iterator it = nc->aliases.begin(); it != nc->aliases.end();) { const NickAlias *na = *it++; if (na && Anope::Match(na->nick, this->mask)) @@ -234,16 +235,16 @@ AccessGroup::AccessGroup() : std::vector<ChanAccess *>() { this->ci = NULL; this->nc = NULL; - this->SuperAdmin = this->Founder = false; + this->super_admin = this->founder = false; } bool AccessGroup::HasPriv(const Anope::string &name) const { - if (this->SuperAdmin) + if (this->super_admin) return true; else if (ci->GetLevel(name) == ACCESS_INVALID) return false; - else if (this->Founder) + else if (this->founder) return true; EventReturn MOD_RESULT; FOREACH_RESULT(I_OnGroupCheckPriv, OnGroupCheckPriv(this, name)); @@ -271,13 +272,13 @@ const ChanAccess *AccessGroup::Highest() const bool AccessGroup::operator>(const AccessGroup &other) const { - if (this->SuperAdmin) + if (this->super_admin) return true; - else if (other.SuperAdmin) + else if (other.super_admin) return false; - else if (this->Founder && !other.Founder) + else if (this->founder && !other.founder) return true; - else if (!this->Founder && other.Founder) + else if (!this->founder && other.founder) return false; const std::vector<Privilege> &privs = PrivilegeManager::GetPrivileges(); for (unsigned i = privs.size(); i > 0; --i) @@ -298,13 +299,13 @@ bool AccessGroup::operator>(const AccessGroup &other) const bool AccessGroup::operator<(const AccessGroup &other) const { - if (other.SuperAdmin) + if (other.super_admin) return true; - else if (this->SuperAdmin) + else if (this->super_admin) return false; - else if (other.Founder && !this->Founder) + else if (other.founder && !this->founder) return true; - else if (this->Founder && !other.Founder) + else if (this->founder && !other.founder) return false; const std::vector<Privilege> &privs = PrivilegeManager::GetPrivileges(); for (unsigned i = privs.size(); i > 0; --i) @@ -325,13 +326,13 @@ bool AccessGroup::operator<(const AccessGroup &other) const bool AccessGroup::operator>=(const AccessGroup &other) const { - if (this->SuperAdmin) + if (this->super_admin) return true; - else if (other.SuperAdmin) + else if (other.super_admin) return false; - else if (this->Founder) + else if (this->founder) return true; - else if (other.Founder) + else if (other.founder) return false; const std::vector<Privilege> &privs = PrivilegeManager::GetPrivileges(); for (unsigned i = privs.size(); i > 0; --i) @@ -352,13 +353,13 @@ bool AccessGroup::operator>=(const AccessGroup &other) const bool AccessGroup::operator<=(const AccessGroup &other) const { - if (other.SuperAdmin) + if (other.super_admin) return true; - else if (this->SuperAdmin) + else if (this->super_admin) return false; - else if (other.Founder) + else if (other.founder) return true; - else if (this->Founder) + else if (this->founder) return false; const std::vector<Privilege> &privs = PrivilegeManager::GetPrivileges(); for (unsigned i = privs.size(); i > 0; --i) diff --git a/src/account.cpp b/src/account.cpp new file mode 100644 index 000000000..b7dd5b51b --- /dev/null +++ b/src/account.cpp @@ -0,0 +1,80 @@ +/* + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + +#include "services.h" +#include "account.h" +#include "modules.h" +#include "users.h" +#include "protocol.h" +#include "regchannel.h" + +std::set<IdentifyRequest *> IdentifyRequest::Requests; + +IdentifyRequest::IdentifyRequest(Module *o, const Anope::string &acc, const Anope::string &pass) : owner(o), account(acc), password(pass), dispatched(false), success(false) +{ + Requests.insert(this); +} + +IdentifyRequest::~IdentifyRequest() +{ + Requests.erase(this); +} + +void IdentifyRequest::Hold(Module *m) +{ + holds.insert(m); +} + +void IdentifyRequest::Release(Module *m) +{ + holds.erase(m); + if (holds.empty() && dispatched) + { + if (!success) + this->OnFail(); + delete this; + } +} + +void IdentifyRequest::Success(Module *m) +{ + if (!success) + { + this->OnSuccess(); + success = true; + } +} + +void IdentifyRequest::Dispatch() +{ + if (holds.empty()) + { + if (!success) + this->OnFail(); + delete this; + } + else + dispatched = true; +} + +void IdentifyRequest::ModuleUnload(Module *m) +{ + for (std::set<IdentifyRequest *>::iterator it = Requests.begin(), it_end = Requests.end(); it != it_end;) + { + IdentifyRequest *ir = *it; + ++it; + + ir->Release(m); + if (ir->owner == m) + delete ir; + } +} diff --git a/src/actions.cpp b/src/actions.cpp deleted file mode 100644 index 512a0fa52..000000000 --- a/src/actions.cpp +++ /dev/null @@ -1,70 +0,0 @@ -/* Various routines to perform simple actions. - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - -#include "services.h" -#include "users.h" -#include "config.h" -#include "regchannel.h" -#include "channels.h" -#include "extern.h" - -/*************************************************************************/ - -/** - * Note a bad password attempt for the given user. If they've used up - * their limit, toss them off. - * @param u the User to check - * @return true if the user was killed, otherwise false - */ -bool bad_password(User *u) -{ - if (!u || !Config->BadPassLimit) - return false; - - if (Config->BadPassTimeout > 0 && u->invalid_pw_time > 0 && u->invalid_pw_time < Anope::CurTime - Config->BadPassTimeout) - u->invalid_pw_count = 0; - ++u->invalid_pw_count; - u->invalid_pw_time = Anope::CurTime; - if (u->invalid_pw_count >= Config->BadPassLimit) - { - u->Kill(Config->ServerName, "Too many invalid passwords"); - return true; - } - - return false; -} - -/*************************************************************************/ - - -/** - * Unban the user from a channel - * @param ci channel info for the channel - * @param u The user to unban - * @param full True to match against the users real host and IP - * @return void - */ -void common_unban(const ChannelInfo *ci, User *u, bool full) -{ - if (!u || !ci || !ci->c || !ci->c->HasMode(CMODE_BAN)) - return; - - std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> bans = ci->c->GetModeList(CMODE_BAN); - for (; bans.first != bans.second;) - { - Entry ban(CMODE_BAN, bans.first->second); - ++bans.first; - if (ban.Matches(u, full)) - ci->c->RemoveMode(NULL, CMODE_BAN, ban.GetMask()); - } -} - -/*************************************************************************/ diff --git a/src/base.cpp b/src/base.cpp index af2b38fde..5b8d828b6 100644 --- a/src/base.cpp +++ b/src/base.cpp @@ -1,20 +1,18 @@ -#include "services.h" -#include "modules.h" -#include "oper.h" -#include "account.h" -#include "regchannel.h" -#include "access.h" -#include "bots.h" +/* + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + */ -std::map<Anope::string, std::map<Anope::string, Service *> > Service::services; +#include "services.h" +#include "anope.h" +#include "service.h" -void RegisterTypes() -{ - static SerializeType nc("NickCore", NickCore::unserialize), na("NickAlias", NickAlias::unserialize), bi("BotInfo", BotInfo::unserialize), - ci("ChannelInfo", ChannelInfo::unserialize), access("ChanAccess", ChanAccess::unserialize), logsetting("LogSetting", LogSetting::unserialize), - modelock("ModeLock", ModeLock::unserialize), akick("AutoKick", AutoKick::unserialize), badword("BadWord", BadWord::unserialize), - memo("Memo", Memo::unserialize), xline("XLine", XLine::unserialize); -} +std::map<Anope::string, std::map<Anope::string, Service *> > Service::Services; +std::map<Anope::string, std::map<Anope::string, Anope::string> > Service::Aliases; Base::Base() { @@ -22,19 +20,19 @@ Base::Base() Base::~Base() { - for (std::set<dynamic_reference_base *>::iterator it = this->References.begin(), it_end = this->References.end(); it != it_end; ++it) + for (std::set<ReferenceBase *>::iterator it = this->references.begin(), it_end = this->references.end(); it != it_end; ++it) { (*it)->Invalidate(); } } -void Base::AddReference(dynamic_reference_base *r) +void Base::AddReference(ReferenceBase *r) { - this->References.insert(r); + this->references.insert(r); } -void Base::DelReference(dynamic_reference_base *r) +void Base::DelReference(ReferenceBase *r) { - this->References.erase(r); + this->references.erase(r); } diff --git a/src/base64.cpp b/src/base64.cpp index df4189547..ae026d8ef 100644 --- a/src/base64.cpp +++ b/src/base64.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" diff --git a/src/bin/CMakeLists.txt b/src/bin/CMakeLists.txt deleted file mode 100644 index d1cdb5d06..000000000 --- a/src/bin/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -# If not on Windows, generate anoperc and install it along with mydbgen -if(NOT WIN32) - configure_file(${Anope_SOURCE_DIR}/src/bin/anoperc.in ${Anope_BINARY_DIR}/src/bin/anoperc) - install (PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/anoperc - DESTINATION ${BIN_DIR} - ) - -endif(NOT WIN32) diff --git a/src/bots.cpp b/src/bots.cpp index 7bb5ace5d..52753148f 100644 --- a/src/bots.cpp +++ b/src/bots.cpp @@ -1,8 +1,10 @@ /* + * * Copyright (C) 2008-2011 Robin Burchell <w00t@inspircd.org> * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #include "services.h" @@ -10,17 +12,27 @@ #include "bots.h" #include "servers.h" #include "protocol.h" -#include "oper.h" +#include "xline.h" #include "regchannel.h" #include "channels.h" #include "config.h" #include "language.h" -#include "extern.h" #include "serialize.h" -serialize_checker<botinfo_map> BotListByNick("BotInfo"), BotListByUID("BotInfo"); +Serialize::Checker<botinfo_map> BotListByNick("BotInfo"), BotListByUID("BotInfo"); + +static const Anope::string BotFlagString[] = { "BEGIN", "CORE", "PRIVATE", "CONF", "" }; +template<> const Anope::string* Flags<BotFlag>::flags_strings = BotFlagString; + +static const Anope::string BotServFlagStrings[] = { + "BEGIN", "DONTKICKOPS", "DONTKICKVOICES", "FANTASY", "GREET", "NOBOT", + "KICK_BOLDs", "KICK_COLORS", "KICK_REVERSES", "KICK_UNDERLINES", "KICK_BADWORDS", "KICK_CAPS", + "KICK_FLOOD", "KICK_REPEAT", "KICK_ITALICS", "KICK_AMSGS", "MSG_PRIVMSG", "MSG_NOTICE", + "MSG_NOTICEOPS", "" +}; +template<> const Anope::string* Flags<BotServFlag>::flags_strings = BotServFlagStrings; -BotInfo::BotInfo(const Anope::string &nnick, const Anope::string &nuser, const Anope::string &nhost, const Anope::string &nreal, const Anope::string &bmodes) : User(nnick, nuser, nhost, "", "", Me, nreal, Anope::CurTime, "", ts6_uid_retrieve()), Flags<BotFlag, BI_END>(BotFlagString), Serializable("BotInfo"), botmodes(bmodes) +BotInfo::BotInfo(const Anope::string &nnick, const Anope::string &nuser, const Anope::string &nhost, const Anope::string &nreal, const Anope::string &bmodes) : User(nnick, nuser, nhost, "", "", Me, nreal, Anope::CurTime, "", Servers::TS6_UID_Retrieve()), Serializable("BotInfo"), botmodes(bmodes) { this->lastmsg = this->created = Anope::CurTime; this->introduced = false; @@ -32,13 +44,13 @@ BotInfo::BotInfo(const Anope::string &nnick, const Anope::string &nuser, const A // If we're synchronised with the uplink already, send the bot. if (Me && Me->IsSynced()) { - Anope::string tmodes = !this->botmodes.empty() ? ("+" + this->botmodes) : (ircdproto ? ircdproto->DefaultPseudoclientModes : ""); + Anope::string tmodes = !this->botmodes.empty() ? ("+" + this->botmodes) : (IRCD ? IRCD->DefaultPseudoclientModes : ""); if (!tmodes.empty()) this->SetModesInternal(tmodes.c_str()); XLine x(this->nick, "Reserved for services"); - ircdproto->SendSQLine(NULL, &x); - ircdproto->SendClientIntroduction(this); + IRCD->SendSQLine(NULL, &x); + IRCD->SendClientIntroduction(this); this->introduced = true; } } @@ -48,10 +60,10 @@ BotInfo::~BotInfo() // If we're synchronised with the uplink already, send the bot. if (Me && Me->IsSynced()) { - ircdproto->SendQuit(this, ""); + IRCD->SendQuit(this, ""); this->introduced = false; XLine x(this->nick); - ircdproto->SendSQLineDel(&x); + IRCD->SendSQLineDel(&x); } for (registered_channel_map::const_iterator it = RegisteredChannelList->begin(), it_end = RegisteredChannelList->end(); it != it_end; ++it) @@ -70,11 +82,11 @@ BotInfo::~BotInfo() BotListByUID->erase(this->uid); } -Serialize::Data BotInfo::serialize() const +Serialize::Data BotInfo::Serialize() const { Serialize::Data data; - data["nick"].setMax(64) << this->nick; + data["nick"].SetMax(64)/*XXX*/ << this->nick; data["user"] << this->ident; data["host"] << this->host; data["realname"] << this->realname; @@ -84,12 +96,12 @@ Serialize::Data BotInfo::serialize() const return data; } -Serializable* BotInfo::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* BotInfo::Unserialize(Serializable *obj, Serialize::Data &data) { BotInfo *bi; if (obj) bi = anope_dynamic_static_cast<BotInfo *>(obj); - else if (!(bi = findbot(data["nick"].astr()))) + else if (!(bi = BotInfo::Find(data["nick"].astr()))) bi = new BotInfo(data["nick"].astr(), data["user"].astr(), data["host"].astr(), data["realname"].astr()); data["created"] >> bi->created; bi->FromString(data["flags"].astr()); @@ -100,7 +112,7 @@ void BotInfo::GenerateUID() { if (!this->uid.empty()) throw CoreException("Bot already has a uid?"); - this->uid = ts6_uid_retrieve(); + this->uid = Servers::TS6_UID_Retrieve(); (*BotListByUID)[this->uid] = this; UserListByUID[this->uid] = this; } @@ -139,7 +151,7 @@ void BotInfo::Assign(User *u, ChannelInfo *ci) ci->bi = this; if (ci->c && ci->c->users.size() >= Config->BSMinUsers) - this->Join(ci->c, &Config->BotModeList); + this->Join(ci->c, &ModeManager::DefaultBotModes); } void BotInfo::UnAssign(User *u, ChannelInfo *ci) @@ -178,7 +190,7 @@ void BotInfo::Join(Channel *c, ChannelStatus *status) if (c->FindUser(this) != NULL) return; - if (Config && ircdproto && Config->BSSmartJoin) + if (Config && IRCD && Config->BSSmartJoin) { std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> bans = c->GetModeList(CMODE_BAN); @@ -197,21 +209,21 @@ void BotInfo::Join(Channel *c, ChannelStatus *status) /* Should we be invited? */ if (c->HasMode(CMODE_INVITE) || (limit && c->users.size() >= limit)) - ircdproto->SendNotice(this, "@" + c->name, "%s invited %s into the channel.", this->nick.c_str(), this->nick.c_str()); + IRCD->SendNotice(this, "@" + c->name, "%s invited %s into the channel.", this->nick.c_str(), this->nick.c_str()); ModeManager::ProcessModes(); } c->JoinUser(this); - if (ircdproto) - ircdproto->SendJoin(this, c, status); + if (IRCD) + IRCD->SendJoin(this, c, status); FOREACH_MOD(I_OnBotJoin, OnBotJoin(c, this)); } void BotInfo::Join(const Anope::string &chname, ChannelStatus *status) { - Channel *c = findchan(chname); + Channel *c = Channel::Find(chname); return this->Join(c ? c : new Channel(chname), status); } @@ -220,7 +232,7 @@ void BotInfo::Part(Channel *c, const Anope::string &reason) if (c->FindUser(this) == NULL) return; - ircdproto->SendPart(this, c, "%s", !reason.empty() ? reason.c_str() : ""); + IRCD->SendPart(this, c, "%s", !reason.empty() ? reason.c_str() : ""); c->DeleteUser(this); } @@ -233,11 +245,6 @@ void BotInfo::OnMessage(User *u, const Anope::string &message) RunCommand(source, message); } -/** Link a command name to a command in services - * @param cname The command name - * @param sname The service name - * @param permission Permission required to execute the command, if any - */ void BotInfo::SetCommand(const Anope::string &cname, const Anope::string &sname, const Anope::string &permission) { CommandInfo ci; @@ -246,10 +253,6 @@ void BotInfo::SetCommand(const Anope::string &cname, const Anope::string &sname, this->commands[cname] = ci; } -/** Get command info for a command - * @param cname The command name - * @return A struct containing service name and permission - */ CommandInfo *BotInfo::GetCommand(const Anope::string &cname) { CommandInfo::map::iterator it = this->commands.find(cname); @@ -258,3 +261,24 @@ CommandInfo *BotInfo::GetCommand(const Anope::string &cname) return NULL; } +BotInfo* BotInfo::Find(const Anope::string &nick, bool nick_only) +{ + BotInfo *bi = NULL; + if (!nick_only && isdigit(nick[0]) && IRCD->RequiresID) + { + botinfo_map::iterator it = BotListByUID->find(nick); + if (it != BotListByUID->end()) + bi = it->second; + } + else + { + botinfo_map::iterator it = BotListByNick->find(nick); + if (it != BotListByNick->end()) + bi = it->second; + } + + if (bi) + bi->QueueUpdate(); + return bi; +} + diff --git a/src/botserv.cpp b/src/botserv.cpp deleted file mode 100644 index 04949b427..000000000 --- a/src/botserv.cpp +++ /dev/null @@ -1,116 +0,0 @@ -/* BotServ functions - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - -/*************************************************************************/ - -#include "services.h" -#include "anope.h" -#include "protocol.h" -#include "bots.h" -#include "regchannel.h" -#include "language.h" -#include "extern.h" -#include "access.h" -#include "channels.h" -#include "account.h" - -BotInfo* findbot(const Anope::string &nick) -{ - BotInfo *bi = NULL; - if (isdigit(nick[0]) && ircdproto->RequiresID) - { - botinfo_map::iterator it = BotListByUID->find(nick); - if (it != BotListByUID->end()) - bi = it->second; - } - else - { - botinfo_map::iterator it = BotListByNick->find(nick); - if (it != BotListByNick->end()) - bi = it->second; - } - - if (bi) - bi->QueueUpdate(); - return bi; -} - - -/*************************************************************************/ - -/* Makes a simple ban and kicks the target - * @param requester The user requesting the kickban - * @param ci The channel - * @param u The user being kicked - * @param reason The reason - */ -void bot_raw_ban(User *requester, ChannelInfo *ci, User *u, const Anope::string &reason) -{ - if (!u || !ci) - return; - - if (ModeManager::FindUserModeByName(UMODE_PROTECTED) && u->IsProtected() && requester != u) - { - ircdproto->SendPrivmsg(ci->bi, ci->name, "%s", translate(requester, ACCESS_DENIED)); - return; - } - - AccessGroup u_access = ci->AccessFor(u), req_access = ci->AccessFor(requester); - if (ci->HasFlag(CI_PEACE) && u != requester && u_access >= req_access) - return; - - if (matches_list(ci->c, u, CMODE_EXCEPT)) - { - ircdproto->SendPrivmsg(ci->bi, ci->name, "%s", translate(requester, _("User matches channel except."))); - return; - } - - Anope::string mask; - get_idealban(ci, u, mask); - - ci->c->SetMode(NULL, CMODE_BAN, mask); - - /* Check if we need to do a signkick or not -GD */ - if (ci->HasFlag(CI_SIGNKICK) || (ci->HasFlag(CI_SIGNKICK_LEVEL) && !req_access.HasPriv("SIGNKICK"))) - ci->c->Kick(ci->bi, u, "%s (%s)", !reason.empty() ? reason.c_str() : ci->bi->nick.c_str(), requester->nick.c_str()); - else - ci->c->Kick(ci->bi, u, "%s", !reason.empty() ? reason.c_str() : ci->bi->nick.c_str()); -} - -/*************************************************************************/ - -/* Makes a kick with a "dynamic" reason ;) - * @param requester The user requesting the kick - * @param ci The channel - * @param u The user being kicked - * @param reason The reason for the kick - */ -void bot_raw_kick(User *requester, ChannelInfo *ci, User *u, const Anope::string &reason) -{ - if (!u || !ci || !ci->c || !ci->c->FindUser(u)) - return; - - if (ModeManager::FindUserModeByName(UMODE_PROTECTED) && u->IsProtected() && requester != u) - { - ircdproto->SendPrivmsg(ci->bi, ci->name, "%s", translate(requester, ACCESS_DENIED)); - return; - } - - AccessGroup u_access = ci->AccessFor(u), req_access = ci->AccessFor(requester); - if (ci->HasFlag(CI_PEACE) && requester != u && u_access >= req_access) - return; - - if (ci->HasFlag(CI_SIGNKICK) || (ci->HasFlag(CI_SIGNKICK_LEVEL) && !req_access.HasPriv("SIGNKICK"))) - ci->c->Kick(ci->bi, u, "%s (%s)", !reason.empty() ? reason.c_str() : ci->bi->nick.c_str(), requester->nick.c_str()); - else - ci->c->Kick(ci->bi, u, "%s", !reason.empty() ? reason.c_str() : ci->bi->nick.c_str()); -} - diff --git a/src/channels.cpp b/src/channels.cpp index 501dd7146..41755b9c8 100644 --- a/src/channels.cpp +++ b/src/channels.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -21,16 +22,15 @@ #include "users.h" #include "config.h" #include "access.h" -#include "extern.h" #include "sockets.h" +#include "chanserv.h" channel_map ChannelList; -/** Default constructor - * @param name The channel name - * @param ts The time the channel was created - */ -Channel::Channel(const Anope::string &nname, time_t ts) : Flags<ChannelFlag, 3>(ChannelFlagString) +static const Anope::string ChannelFlagString[] = { "CH_INABIT", "CH_PERSIST", "CH_SYNCING", "" }; +template<> const Anope::string* Flags<ChannelFlag>::flags_strings = ChannelFlagString; + +Channel::Channel(const Anope::string &nname, time_t ts) { if (nname.empty()) throw CoreException("A channel without a name ?"); @@ -46,7 +46,7 @@ Channel::Channel(const Anope::string &nname, time_t ts) : Flags<ChannelFlag, 3>( this->server_modetime = this->chanserv_modetime = 0; this->server_modecount = this->chanserv_modecount = this->bouncy_modes = this->topic_ts = this->topic_time = 0; - this->ci = cs_findchan(this->name); + this->ci = ChannelInfo::Find(this->name); if (this->ci) this->ci->c = this; @@ -55,8 +55,6 @@ Channel::Channel(const Anope::string &nname, time_t ts) : Flags<ChannelFlag, 3>( FOREACH_MOD(I_OnChannelCreate, OnChannelCreate(this)); } -/** Default destructor - */ Channel::~Channel() { FOREACH_MOD(I_OnChannelDelete, OnChannelDelete(this)); @@ -79,16 +77,16 @@ void Channel::Reset() { UserContainer *uc = *it; - ChannelStatus flags = *uc->Status; - uc->Status->ClearFlags(); + ChannelStatus flags = *uc->status; + uc->status->ClearFlags(); - if (findbot(uc->user->nick)) + if (BotInfo::Find(uc->user->nick)) { for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (flags.HasFlag(cm->Name)) + if (flags.HasFlag(cm->name)) this->SetMode(NULL, cm, uc->user->GetUID(), false); } } @@ -97,7 +95,7 @@ void Channel::Reset() this->CheckModes(); for (CUserList::const_iterator it = this->users.begin(), it_end = this->users.end(); it != it_end; ++it) - chan_set_correct_modes((*it)->user, this, 1, false); + this->SetCorrectModes((*it)->user, true, false); if (this->ci && Me && Me->IsSynced()) this->ci->RestoreTopic(); @@ -151,32 +149,32 @@ void Channel::CheckModes() if (!cm) continue; - if (cm->Type == MODE_REGULAR) + if (cm->type == MODE_REGULAR) { - if (!this->HasMode(cm->Name) && ml->set) + if (!this->HasMode(cm->name) && ml->set) this->SetMode(NULL, cm); - else if (this->HasMode(cm->Name) && !ml->set) + else if (this->HasMode(cm->name) && !ml->set) this->RemoveMode(NULL, cm); } - else if (cm->Type == MODE_PARAM) + else if (cm->type == MODE_PARAM) { /* If the channel doesnt have the mode, or it does and it isn't set correctly */ if (ml->set) { Anope::string param; - this->GetParam(cm->Name, param); + this->GetParam(cm->name, param); - if (!this->HasMode(cm->Name) || (!param.empty() && !ml->param.empty() && !param.equals_cs(ml->param))) + if (!this->HasMode(cm->name) || (!param.empty() && !ml->param.empty() && !param.equals_cs(ml->param))) this->SetMode(NULL, cm, ml->param); } else { - if (this->HasMode(cm->Name)) + if (this->HasMode(cm->name)) this->RemoveMode(NULL, cm); } } - else if (cm->Type == MODE_LIST) + else if (cm->type == MODE_LIST) { if (ml->set) this->SetMode(NULL, cm, ml->param); @@ -186,36 +184,32 @@ void Channel::CheckModes() } } -void Channel::JoinUser(User *user) +UserContainer* Channel::JoinUser(User *user) { Log(user, this, "join"); - ChannelStatus *Status = new ChannelStatus(); + ChannelStatus *status = new ChannelStatus(); ChannelContainer *cc = new ChannelContainer(this); - cc->Status = Status; + cc->status = status; user->chans.push_back(cc); UserContainer *uc = new UserContainer(user); - uc->Status = Status; + uc->status = status; this->users.push_back(uc); if (this->ci && this->ci->HasFlag(CI_PERSIST) && this->creation_time > this->ci->time_registered) { Log(LOG_DEBUG) << "Changing TS of " << this->name << " from " << this->creation_time << " to " << this->ci->time_registered; this->creation_time = this->ci->time_registered; - ircdproto->SendChannel(this); + IRCD->SendChannel(this); this->Reset(); } + + return uc; } -/** Remove a user internally from the channel - * @param u The user - */ void Channel::DeleteUser(User *user) { - if (this->ci) - update_cs_lastseen(user, this->ci); - Log(user, this, "leaves"); FOREACH_MOD(I_OnLeaveChannel, OnLeaveChannel(user, this)); @@ -227,7 +221,7 @@ void Channel::DeleteUser(User *user) return; } - delete (*cit)->Status; + delete (*cit)->status; delete *cit; this->users.erase(cit); @@ -259,10 +253,6 @@ void Channel::DeleteUser(User *user) delete this; } -/** Check if the user is on the channel - * @param u The user - * @return A user container if found, else NULL - */ UserContainer *Channel::FindUser(const User *u) const { for (CUserList::const_iterator it = this->users.begin(), it_end = this->users.end(); it != it_end; ++it) @@ -271,14 +261,9 @@ UserContainer *Channel::FindUser(const User *u) const return NULL; } -/** Check if a user has a status on a channel - * @param u The user - * @param cms The status mode, or NULL to represent no status - * @return true or false - */ bool Channel::HasUserStatus(const User *u, ChannelModeStatus *cms) const { - if (!u || (cms && cms->Type != MODE_STATUS)) + if (!u || (cms && cms->type != MODE_STATUS)) throw CoreException("Channel::HasUserStatus got bad mode"); /* Usually its more efficient to search the users channels than the channels users */ @@ -286,31 +271,19 @@ bool Channel::HasUserStatus(const User *u, ChannelModeStatus *cms) const if (cc) { if (cms) - return cc->Status->HasFlag(cms->Name); + return cc->status->HasFlag(cms->name); else - return !cc->Status->FlagCount(); + return !cc->status->FlagCount(); } return false; } -/** Check if a user has a status on a channel - * Use the overloaded function for ChannelModeStatus* to check for no status - * @param u The user - * @param Name The Mode name, eg CMODE_OP, CMODE_VOICE - * @return true or false - */ bool Channel::HasUserStatus(const User *u, ChannelModeName Name) const { return HasUserStatus(u, anope_dynamic_static_cast<ChannelModeStatus *>(ModeManager::FindChannelModeByName(Name))); } -/** - * See if a channel has a mode - * @param Name The mode name - * @param param The optional mode param - * @return The number of modes set - */ size_t Channel::HasMode(ChannelModeName Name, const Anope::string ¶m) { if (param.empty()) @@ -322,80 +295,70 @@ size_t Channel::HasMode(ChannelModeName Name, const Anope::string ¶m) return 0; } -/** Get a list of modes on a channel - * @param Name A mode name to get the list of - * @return a pair of iterators for the beginning and end of the list - */ -std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> Channel::GetModeList(ChannelModeName Name) +std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> Channel::GetModeList(ChannelModeName mname) { - Channel::ModeList::iterator it = this->modes.find(Name), it_end = it; + Channel::ModeList::iterator it = this->modes.find(mname), it_end = it; if (it != this->modes.end()) - it_end = this->modes.upper_bound(Name); + it_end = this->modes.upper_bound(mname); return std::make_pair(it, it_end); } -/** Set a mode internally on a channel, this is not sent out to the IRCd - * @param setter The user who is setting the mode - * @param cm The mode - * @param param The param - * @param EnforeMLock true if mlocks should be enforced, false to override mlock - */ -void Channel::SetModeInternal(MessageSource &setter, ChannelMode *cm, const Anope::string ¶m, bool EnforceMLock) +void Channel::SetModeInternal(MessageSource &setter, ChannelMode *cm, const Anope::string ¶m, bool enforce_mlock) { if (!cm) return; EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnChannelModeSet, OnChannelModeSet(this, setter, cm->Name, param)); + FOREACH_RESULT(I_OnChannelModeSet, OnChannelModeSet(this, setter, cm->name, param)); /* Setting v/h/o/a/q etc */ - if (cm->Type == MODE_STATUS) + if (cm->type == MODE_STATUS) { if (param.empty()) { - Log() << "Channel::SetModeInternal() mode " << cm->ModeChar << " with no parameter for channel " << this->name; + Log() << "Channel::SetModeInternal() mode " << cm->mchar << " with no parameter for channel " << this->name; return; } - User *u = finduser(param); + User *u = User::Find(param); if (!u) { - Log() << "MODE " << this->name << " +" << cm->ModeChar << " for nonexistant user " << param; + Log() << "MODE " << this->name << " +" << cm->mchar << " for nonexistant user " << param; return; } - Log(LOG_DEBUG) << "Setting +" << cm->ModeChar << " on " << this->name << " for " << u->nick; + Log(LOG_DEBUG) << "Setting +" << cm->mchar << " on " << this->name << " for " << u->nick; /* Set the status on the user */ ChannelContainer *cc = u->FindChannel(this); if (cc) - cc->Status->SetFlag(cm->Name); + cc->status->SetFlag(cm->name); /* Enforce secureops, etc */ - if (EnforceMLock) - chan_set_correct_modes(u, this, 0, false); + if (enforce_mlock) + this->SetCorrectModes(u, false, false); return; } - if (cm->Type != MODE_LIST) - this->modes.erase(cm->Name); - this->modes.insert(std::make_pair(cm->Name, param)); + if (cm->type != MODE_LIST) + this->modes.erase(cm->name); + this->modes.insert(std::make_pair(cm->name, param)); - if (param.empty() && cm->Type != MODE_REGULAR) + if (param.empty() && cm->type != MODE_REGULAR) { - Log() << "Channel::SetModeInternal() mode " << cm->ModeChar << " for " << this->name << " with a paramater, but its not a param mode"; + Log() << "Channel::SetModeInternal() mode " << cm->mchar << " for " << this->name << " with a paramater, but its not a param mode"; return; } - if (cm->Type == MODE_LIST) + if (cm->type == MODE_LIST) { ChannelModeList *cml = anope_dynamic_static_cast<ChannelModeList *>(cm); cml->OnAdd(this, param); } /* Channel mode +P or so was set, mark this channel as persistent */ - if (cm->Name == CMODE_PERM) + if (cm->name == CMODE_PERM) { this->SetFlag(CH_PERSIST); if (this->ci) @@ -403,68 +366,62 @@ void Channel::SetModeInternal(MessageSource &setter, ChannelMode *cm, const Anop } /* Check if we should enforce mlock */ - if (!EnforceMLock || MOD_RESULT == EVENT_STOP) + if (!enforce_mlock || MOD_RESULT == EVENT_STOP) return; this->CheckModes(); } -/** Remove a mode internally on a channel, this is not sent out to the IRCd - * @param setter The user who is unsetting the mode - * @param cm The mode - * @param param The param - * @param EnforceMLock true if mlocks should be enforced, false to override mlock - */ -void Channel::RemoveModeInternal(MessageSource &setter, ChannelMode *cm, const Anope::string ¶m, bool EnforceMLock) +void Channel::RemoveModeInternal(MessageSource &setter, ChannelMode *cm, const Anope::string ¶m, bool enforce_mlock) { if (!cm) return; EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnChannelModeUnset, OnChannelModeUnset(this, setter, cm->Name, param)); + FOREACH_RESULT(I_OnChannelModeUnset, OnChannelModeUnset(this, setter, cm->name, param)); /* Setting v/h/o/a/q etc */ - if (cm->Type == MODE_STATUS) + if (cm->type == MODE_STATUS) { if (param.empty()) { - Log() << "Channel::RemoveModeInternal() mode " << cm->ModeChar << " with no parameter for channel " << this->name; + Log() << "Channel::RemoveModeInternal() mode " << cm->mchar << " with no parameter for channel " << this->name; return; } - BotInfo *bi = findbot(param); - User *u = bi ? bi : finduser(param); + BotInfo *bi = BotInfo::Find(param); + User *u = bi ? bi : User::Find(param); if (!u) { - Log() << "Channel::RemoveModeInternal() MODE " << this->name << "-" << cm->ModeChar << " for nonexistant user " << param; + Log() << "Channel::RemoveModeInternal() MODE " << this->name << "-" << cm->mchar << " for nonexistant user " << param; return; } - Log(LOG_DEBUG) << "Setting -" << cm->ModeChar << " on " << this->name << " for " << u->nick; + Log(LOG_DEBUG) << "Setting -" << cm->mchar << " on " << this->name << " for " << u->nick; /* Remove the status on the user */ ChannelContainer *cc = u->FindChannel(this); if (cc) - cc->Status->UnsetFlag(cm->Name); + cc->status->UnsetFlag(cm->name); - if (EnforceMLock) + if (enforce_mlock) { /* Reset modes on bots if we're supposed to */ if (this->ci && this->ci->bi && this->ci->bi == bi) { - if (Config->BotModeList.HasFlag(cm->Name)) + if (ModeManager::DefaultBotModes.HasFlag(cm->name)) this->SetMode(bi, cm, bi->GetUID()); } - chan_set_correct_modes(u, this, 0, false); + this->SetCorrectModes(u, false, false); } return; } - if (cm->Type == MODE_LIST && !param.empty()) + if (cm->type == MODE_LIST && !param.empty()) { - std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> its = this->GetModeList(cm->Name); + std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> its = this->GetModeList(cm->name); for (; its.first != its.second; ++its.first) if (Anope::Match(param, its.first->second)) { @@ -473,15 +430,15 @@ void Channel::RemoveModeInternal(MessageSource &setter, ChannelMode *cm, const A } } else - this->modes.erase(cm->Name); + this->modes.erase(cm->name); - if (cm->Type == MODE_LIST) + if (cm->type == MODE_LIST) { ChannelModeList *cml = anope_dynamic_static_cast<ChannelModeList *>(cm); cml->OnDel(this, param); } - if (cm->Name == CMODE_PERM) + if (cm->name == CMODE_PERM) { this->UnsetFlag(CH_PERSIST); @@ -497,123 +454,92 @@ void Channel::RemoveModeInternal(MessageSource &setter, ChannelMode *cm, const A /* Check for mlock */ - if (!EnforceMLock || MOD_RESULT == EVENT_STOP) + if (!enforce_mlock || MOD_RESULT == EVENT_STOP) return; this->CheckModes(); } -/** Set a mode on a channel - * @param bi The client setting the modes - * @param cm The mode - * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock - */ -void Channel::SetMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m, bool EnforceMLock) +void Channel::SetMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m, bool enforce_mlock) { if (!cm) return; /* Don't set modes already set */ - if (cm->Type == MODE_REGULAR && HasMode(cm->Name)) + if (cm->type == MODE_REGULAR && HasMode(cm->name)) return; - else if (cm->Type == MODE_PARAM) + else if (cm->type == MODE_PARAM) { ChannelModeParam *cmp = anope_dynamic_static_cast<ChannelModeParam *>(cm); if (!cmp->IsValid(param)) return; Anope::string cparam; - if (GetParam(cm->Name, cparam) && cparam.equals_cs(param)) + if (GetParam(cm->name, cparam) && cparam.equals_cs(param)) return; } - else if (cm->Type == MODE_STATUS) + else if (cm->type == MODE_STATUS) { - User *u = finduser(param); + User *u = User::Find(param); if (!u || HasUserStatus(u, anope_dynamic_static_cast<ChannelModeStatus *>(cm))) return; } - else if (cm->Type == MODE_LIST) + else if (cm->type == MODE_LIST) { ChannelModeList *cml = anope_dynamic_static_cast<ChannelModeList *>(cm); - if (this->HasMode(cm->Name, param) || !cml->IsValid(param)) + if (this->HasMode(cm->name, param) || !cml->IsValid(param)) return; } ModeManager::StackerAdd(bi, this, cm, true, param); MessageSource ms(bi); - SetModeInternal(ms, cm, param, EnforceMLock); + SetModeInternal(ms, cm, param, enforce_mlock); } -/** - * Set a mode on a channel - * @param bi The client setting the modes - * @param Name The mode name - * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock - */ -void Channel::SetMode(BotInfo *bi, ChannelModeName Name, const Anope::string ¶m, bool EnforceMLock) +void Channel::SetMode(BotInfo *bi, ChannelModeName Name, const Anope::string ¶m, bool enforce_mlock) { - SetMode(bi, ModeManager::FindChannelModeByName(Name), param, EnforceMLock); + SetMode(bi, ModeManager::FindChannelModeByName(Name), param, enforce_mlock); } -/** Remove a mode from a channel - * @param bi The client setting the modes - * @param cm The mode - * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock - */ -void Channel::RemoveMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m, bool EnforceMLock) +void Channel::RemoveMode(BotInfo *bi, ChannelMode *cm, const Anope::string ¶m, bool enforce_mlock) { if (!cm) return; /* Don't unset modes that arent set */ - if ((cm->Type == MODE_REGULAR || cm->Type == MODE_PARAM) && !HasMode(cm->Name)) + if ((cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && !HasMode(cm->name)) return; /* Don't unset status that aren't set */ - else if (cm->Type == MODE_STATUS) + else if (cm->type == MODE_STATUS) { - User *u = finduser(param); + User *u = User::Find(param); if (!u || !HasUserStatus(u, anope_dynamic_static_cast<ChannelModeStatus *>(cm))) return; } - else if (cm->Type == MODE_LIST) + else if (cm->type == MODE_LIST) { - if (!this->HasMode(cm->Name, param)) + if (!this->HasMode(cm->name, param)) return; } /* Get the param to send, if we need it */ Anope::string realparam = param; - if (cm->Type == MODE_PARAM) + if (cm->type == MODE_PARAM) { realparam.clear(); ChannelModeParam *cmp = anope_dynamic_static_cast<ChannelModeParam *>(cm); - if (!cmp->MinusNoArg) - this->GetParam(cmp->Name, realparam); + if (!cmp->minus_no_arg) + this->GetParam(cmp->name, realparam); } ModeManager::StackerAdd(bi, this, cm, false, realparam); MessageSource ms(bi); - RemoveModeInternal(ms, cm, realparam, EnforceMLock); + RemoveModeInternal(ms, cm, realparam, enforce_mlock); } -/** - * Remove a mode from a channel - * @param bi The client setting the modes - * @param Name The mode name - * @param param Optional param arg for the mode - * @param EnforceMLock true if mlocks should be enforced, false to override mlock - */ -void Channel::RemoveMode(BotInfo *bi, ChannelModeName Name, const Anope::string ¶m, bool EnforceMLock) +void Channel::RemoveMode(BotInfo *bi, ChannelModeName Name, const Anope::string ¶m, bool enforce_mlock) { - RemoveMode(bi, ModeManager::FindChannelModeByName(Name), param, EnforceMLock); + RemoveMode(bi, ModeManager::FindChannelModeByName(Name), param, enforce_mlock); } -/** Get a param from the channel - * @param Name The mode - * @param Target a string to put the param into - * @return true on success - */ bool Channel::GetParam(ChannelModeName Name, Anope::string &Target) const { std::multimap<ChannelModeName, Anope::string>::const_iterator it = this->modes.find(Name); @@ -629,14 +555,7 @@ bool Channel::GetParam(ChannelModeName Name, Anope::string &Target) const return false; } -/*************************************************************************/ - -/** Set a string of modes on the channel - * @param bi The client setting the modes - * @param EnforceMLock Should mlock be enforced on this mode change - * @param cmodes The modes to set - */ -void Channel::SetModes(BotInfo *bi, bool EnforceMLock, const char *cmodes, ...) +void Channel::SetModes(BotInfo *bi, bool enforce_mlock, const char *cmodes, ...) { char buf[BUFSIZE] = ""; va_list args; @@ -670,38 +589,38 @@ void Channel::SetModes(BotInfo *bi, bool EnforceMLock, const char *cmodes, ...) if (add) { - if (cm->Type != MODE_REGULAR && sep.GetToken(sbuf)) + if (cm->type != MODE_REGULAR && sep.GetToken(sbuf)) { - if (cm->Type == MODE_STATUS) + if (cm->type == MODE_STATUS) { - User *targ = finduser(sbuf); + User *targ = User::Find(sbuf); if (targ != NULL) sbuf = targ->GetUID(); } - this->SetMode(bi, cm, sbuf, EnforceMLock); + this->SetMode(bi, cm, sbuf, enforce_mlock); } else - this->SetMode(bi, cm, "", EnforceMLock); + this->SetMode(bi, cm, "", enforce_mlock); } else if (!add) { - if (cm->Type != MODE_REGULAR && sep.GetToken(sbuf)) + if (cm->type != MODE_REGULAR && sep.GetToken(sbuf)) { - if (cm->Type == MODE_STATUS) + if (cm->type == MODE_STATUS) { - User *targ = finduser(sbuf); + User *targ = User::Find(sbuf); if (targ != NULL) sbuf = targ->GetUID(); } - this->RemoveMode(bi, cm, sbuf, EnforceMLock); + this->RemoveMode(bi, cm, sbuf, enforce_mlock); } else - this->RemoveMode(bi, cm, "", EnforceMLock); + this->RemoveMode(bi, cm, "", enforce_mlock); } } } -void Channel::SetModesInternal(MessageSource &source, const Anope::string &mode, time_t ts, bool EnforceMLock) +void Channel::SetModesInternal(MessageSource &source, const Anope::string &mode, time_t ts, bool enforce_mlock) { if (source.GetServer()) { @@ -727,7 +646,7 @@ void Channel::SetModesInternal(MessageSource &source, const Anope::string &mode, User *setter = source.GetUser(); /* Removing channel modes *may* delete this channel */ - dynamic_reference<Channel> this_reference(this); + Reference<Channel> this_reference(this); spacesepstream sep_modes(mode); Anope::string m; @@ -760,24 +679,24 @@ void Channel::SetModesInternal(MessageSource &source, const Anope::string &mode, Log(LOG_DEBUG) << "Channel::SetModeInternal: Unknown mode char " << m[i]; continue; } - modestring += cm->ModeChar; + modestring += cm->mchar; } - if (cm->Type == MODE_REGULAR) + if (cm->type == MODE_REGULAR) { if (add) - this->SetModeInternal(source, cm, "", EnforceMLock); + this->SetModeInternal(source, cm, "", enforce_mlock); else - this->RemoveModeInternal(source, cm, "", EnforceMLock); + this->RemoveModeInternal(source, cm, "", enforce_mlock); continue; } - else if (cm->Type == MODE_PARAM) + else if (cm->type == MODE_PARAM) { ChannelModeParam *cmp = anope_dynamic_static_cast<ChannelModeParam *>(cm); - if (!add && cmp->MinusNoArg) + if (!add && cmp->minus_no_arg) { - this->RemoveModeInternal(source, cm, "", EnforceMLock); + this->RemoveModeInternal(source, cm, "", enforce_mlock); continue; } } @@ -785,15 +704,15 @@ void Channel::SetModesInternal(MessageSource &source, const Anope::string &mode, if (sep_modes.GetToken(token)) { User *u = NULL; - if (cm->Type == MODE_STATUS && (u = finduser(token))) + if (cm->type == MODE_STATUS && (u = User::Find(token))) paramstring += " " + u->nick; else paramstring += " " + token; if (add) - this->SetModeInternal(source, cm, token, EnforceMLock); + this->SetModeInternal(source, cm, token, enforce_mlock); else - this->RemoveModeInternal(source, cm, token, EnforceMLock); + this->RemoveModeInternal(source, cm, token, enforce_mlock); } else Log() << "warning: Channel::SetModesInternal() recieved more modes requiring params than params, modes: " << mode; @@ -808,15 +727,27 @@ void Channel::SetModesInternal(MessageSource &source, const Anope::string &mode, Log(LOG_DEBUG) << source.GetName() << " is setting " << this->name << " to " << modestring << paramstring; } -/** Kick a user from a channel internally - * @param source The sender of the kick - * @param nick The nick being kicked - * @param reason The reason for the kick - */ +bool Channel::MatchesList(User *u, ChannelModeName mode) +{ + if (!this->HasMode(mode)) + return false; + + + std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> m = this->GetModeList(mode); + for (; m.first != m.second; ++m.first) + { + Entry e(mode, m.first->second); + if (e.Matches(u)) + return true; + } + + return false; +} + void Channel::KickInternal(MessageSource &source, const Anope::string &nick, const Anope::string &reason) { User *sender = source.GetUser(); - User *target = finduser(nick); + User *target = User::Find(nick); if (!target) { Log() << "Channel::KickInternal got a nonexistent user " << nick << " on " << this->name << ": " << reason; @@ -825,7 +756,7 @@ void Channel::KickInternal(MessageSource &source, const Anope::string &nick, con BotInfo *bi = NULL; if (target->server == Me) - bi = findbot(nick); + bi = BotInfo::Find(nick); if (sender) Log(sender, this, "kick") << "kicked " << target->nick << " (" << reason << ")"; @@ -847,17 +778,11 @@ void Channel::KickInternal(MessageSource &source, const Anope::string &nick, con /* Bots get rejoined */ if (bi) { - bi->Join(this, &Config->BotModeList); + bi->Join(this, &ModeManager::DefaultBotModes); this->UnsetFlag(CH_INHABIT); } } -/** Kick a user from the channel - * @param bi The sender, can be NULL for the service bot for this channel - * @param u The user being kicked - * @param reason The reason for the kick - * @return true if the kick was scucessful, false if a module blocked the kick - */ bool Channel::Kick(BotInfo *bi, User *u, const char *reason, ...) { va_list args; @@ -881,7 +806,7 @@ bool Channel::Kick(BotInfo *bi, User *u, const char *reason, ...) FOREACH_RESULT(I_OnBotKick, OnBotKick(bi, this, u, buf)); if (MOD_RESULT == EVENT_STOP) return false; - ircdproto->SendKick(bi, this, u, "%s", buf); + IRCD->SendKick(bi, this, u, "%s", buf); MessageSource ms(bi); this->KickInternal(ms, u->nick, buf); return true; @@ -894,16 +819,16 @@ Anope::string Channel::GetModes(bool complete, bool plus) for (std::multimap<ChannelModeName, Anope::string>::const_iterator it = this->modes.begin(), it_end = this->modes.end(); it != it_end; ++it) { ChannelMode *cm = ModeManager::FindChannelModeByName(it->first); - if (!cm || cm->Type == MODE_LIST) + if (!cm || cm->type == MODE_LIST) continue; - res += cm->ModeChar; + res += cm->mchar; if (complete && !it->second.empty()) { ChannelModeParam *cmp = anope_dynamic_static_cast<ChannelModeParam *>(cm); - if (plus || !cmp->MinusNoArg) + if (plus || !cmp->minus_no_arg) params += " " + it->second; } } @@ -913,7 +838,7 @@ Anope::string Channel::GetModes(bool complete, bool plus) void Channel::ChangeTopicInternal(const Anope::string &user, const Anope::string &newtopic, time_t ts) { - User *u = finduser(user); + User *u = User::Find(user); this->topic = newtopic; this->topic_setter = u ? u->nick : user; @@ -930,13 +855,13 @@ void Channel::ChangeTopicInternal(const Anope::string &user, const Anope::string void Channel::ChangeTopic(const Anope::string &user, const Anope::string &newtopic, time_t ts) { - User *u = finduser(user); + User *u = User::Find(user); this->topic = newtopic; this->topic_setter = u ? u->nick : user; this->topic_ts = ts; - ircdproto->SendTopic(this->ci->WhoSends(), this); + IRCD->SendTopic(this->ci->WhoSends(), this); /* Now that the topic is set update the time set. This is *after* we set it so the protocol modules are able to tell the old last set time */ this->topic_time = Anope::CurTime; @@ -947,97 +872,55 @@ void Channel::ChangeTopic(const Anope::string &user, const Anope::string &newtop this->ci->CheckTopic(); } -/** A timer used to keep the BotServ bot/ChanServ in the channel - * after kicking the last user in a channel - */ -class CoreExport ChanServTimer : public Timer +void Channel::Hold() { - private: - dynamic_reference<Channel> c; - - public: - /** Default constructor - * @param chan The channel - */ - ChanServTimer(Channel *chan) : Timer(Config->CSInhabit), c(chan) - { - BotInfo *bi = findbot(Config->ChanServ); - if (!bi || !c) - return; - c->SetFlag(CH_INHABIT); - if (!c->ci || !c->ci->bi) - bi->Join(c); - else if (!c->FindUser(c->ci->bi)) - c->ci->bi->Join(c); - } - - /** Called when the delay is up - * @param The current time + /** A timer used to keep the BotServ bot/ChanServ in the channel + * after kicking the last user in a channel */ - void Tick(time_t) + class ChanServTimer : public Timer { - if (!c) - return; + private: + Reference<Channel> c; - c->UnsetFlag(CH_INHABIT); - - if (!c->ci || !c->ci->bi) + public: + /** Constructor + * @param chan The channel + */ + ChanServTimer(Channel *chan) : Timer(Config->CSInhabit), c(chan) { - BotInfo *bi = findbot(Config->ChanServ); - if (bi) - bi->Part(c); + if (!ChanServ || !c) + return; + c->SetFlag(CH_INHABIT); + if (!c->ci || !c->ci->bi) + ChanServ->Join(c); + else if (!c->FindUser(c->ci->bi)) + c->ci->bi->Join(c); } - else if (c->users.size() == 1 || c->users.size() < Config->BSMinUsers) - c->ci->bi->Part(c); - } -}; -void Channel::Hold() -{ - new ChanServTimer(this); -} - -/*************************************************************************/ - -Channel *findchan(const Anope::string &chan) -{ - channel_map::const_iterator it = ChannelList.find(chan); - - if (it != ChannelList.end()) - return it->second; - return NULL; -} - -/*************************************************************************/ - -/* Is the given nick on the given channel? - This function supports links. */ + /** Called when the delay is up + * @param The current time + */ + void Tick(time_t) anope_override + { + if (!c) + return; -User *nc_on_chan(Channel *c, const NickCore *nc) -{ - if (!c || !nc) - return NULL; + c->UnsetFlag(CH_INHABIT); - for (CUserList::iterator it = c->users.begin(), it_end = c->users.end(); it != it_end; ++it) - { - UserContainer *uc = *it; + if (!c->ci || !c->ci->bi) + { + if (ChanServ) + ChanServ->Part(c); + } + else if (c->users.size() == 1 || c->users.size() < Config->BSMinUsers) + c->ci->bi->Part(c); + } + }; - if (uc->user->Account() == nc) - return uc->user; - } - return NULL; + new ChanServTimer(this); } -/** - * Set the correct modes, or remove the ones granted without permission, - * for the specified user on ths specified channel. This doesn't give - * modes to ignored users, but does remove them if needed. - * @param user The user to give/remove modes to/from - * @param c The channel to give/remove modes on - * @param give_modes Set to 1 to give modes, 0 to not give modes - * @return void - **/ -void chan_set_correct_modes(const User *user, Channel *c, int give_modes, bool check_noop) +void Channel::SetCorrectModes(User *user, bool give_modes, bool check_noop) { ChannelMode *owner = ModeManager::FindChannelModeByName(CMODE_OWNER), *admin = ModeManager::FindChannelModeByName(CMODE_PROTECT), @@ -1045,46 +928,44 @@ void chan_set_correct_modes(const User *user, Channel *c, int give_modes, bool c *halfop = ModeManager::FindChannelModeByName(CMODE_HALFOP), *voice = ModeManager::FindChannelModeByName(CMODE_VOICE); - if (user == NULL || c == NULL) + if (user == NULL) return; - ChannelInfo *ci = c->ci; - - if (ci == NULL) + if (!this->ci) return; - Log(LOG_DEBUG) << "Setting correct user modes for " << user->nick << " on " << c->name << " (" << (give_modes ? "" : "not ") << "giving modes)"; + Log(LOG_DEBUG) << "Setting correct user modes for " << user->nick << " on " << this->name << " (" << (give_modes ? "" : "not ") << "giving modes)"; AccessGroup u_access = ci->AccessFor(user); if (give_modes && (!user->Account() || user->Account()->HasFlag(NI_AUTOOP)) && (!check_noop || !ci->HasFlag(CI_NOAUTOOP))) { if (owner && u_access.HasPriv("AUTOOWNER")) - c->SetMode(NULL, CMODE_OWNER, user->GetUID()); + this->SetMode(NULL, CMODE_OWNER, user->GetUID()); else if (admin && u_access.HasPriv("AUTOPROTECT")) - c->SetMode(NULL, CMODE_PROTECT, user->GetUID()); + this->SetMode(NULL, CMODE_PROTECT, user->GetUID()); if (op && u_access.HasPriv("AUTOOP")) - c->SetMode(NULL, CMODE_OP, user->GetUID()); + this->SetMode(NULL, CMODE_OP, user->GetUID()); else if (halfop && u_access.HasPriv("AUTOHALFOP")) - c->SetMode(NULL, CMODE_HALFOP, user->GetUID()); + this->SetMode(NULL, CMODE_HALFOP, user->GetUID()); else if (voice && u_access.HasPriv("AUTOVOICE")) - c->SetMode(NULL, CMODE_VOICE, user->GetUID()); + this->SetMode(NULL, CMODE_VOICE, user->GetUID()); } /* If this channel has secureops or the channel is syncing and they are not ulined, check to remove modes */ - if ((ci->HasFlag(CI_SECUREOPS) || (c->HasFlag(CH_SYNCING) && user->server->IsSynced())) && !user->server->IsULined()) + if ((ci->HasFlag(CI_SECUREOPS) || (this->HasFlag(CH_SYNCING) && user->server->IsSynced())) && !user->server->IsULined()) { if (owner && !u_access.HasPriv("AUTOOWNER") && !u_access.HasPriv("OWNERME")) - c->RemoveMode(NULL, CMODE_OWNER, user->GetUID()); + this->RemoveMode(NULL, CMODE_OWNER, user->GetUID()); if (admin && !u_access.HasPriv("AUTOPROTECT") && !u_access.HasPriv("PROTECTME")) - c->RemoveMode(NULL, CMODE_PROTECT, user->GetUID()); + this->RemoveMode(NULL, CMODE_PROTECT, user->GetUID()); - if (op && c->HasUserStatus(user, CMODE_OP) && !u_access.HasPriv("AUTOOP") && !u_access.HasPriv("OPDEOPME")) - c->RemoveMode(NULL, CMODE_OP, user->GetUID()); + if (op && this->HasUserStatus(user, CMODE_OP) && !u_access.HasPriv("AUTOOP") && !u_access.HasPriv("OPDEOPME")) + this->RemoveMode(NULL, CMODE_OP, user->GetUID()); if (halfop && !u_access.HasPriv("AUTOHALFOP") && !u_access.HasPriv("HALFOPME")) - c->RemoveMode(NULL, CMODE_HALFOP, user->GetUID()); + this->RemoveMode(NULL, CMODE_HALFOP, user->GetUID()); } // Check mlock @@ -1092,171 +973,43 @@ void chan_set_correct_modes(const User *user, Channel *c, int give_modes, bool c { const ModeLock *ml = it->second; ChannelMode *cm = ModeManager::FindChannelModeByName(ml->name); - if (!cm || cm->Type != MODE_STATUS) + if (!cm || cm->type != MODE_STATUS) continue; if (Anope::Match(user->nick, ml->param) || Anope::Match(user->GetDisplayedMask(), ml->param)) { - if ((ml->set && !c->HasUserStatus(user, ml->name)) || (!ml->set && c->HasUserStatus(user, ml->name))) + if (ml->set != this->HasUserStatus(user, ml->name)) { if (ml->set) - c->SetMode(NULL, cm, user->GetUID(), false); + this->SetMode(NULL, cm, user->GetUID(), false); else if (!ml->set) - c->RemoveMode(NULL, cm, user->GetUID(), false); + this->RemoveMode(NULL, cm, user->GetUID(), false); } } } } -/*************************************************************************/ - -static const Anope::string EntryFlagString[] = { "ENTRYTYPE_NONE", "ENTRYTYPE_CIDR", "ENTRYTYPE_NICK_WILD", "ENTRYTYPE_NICK", "ENTRYTYPE_USER_WILD", "ENTRYTYPE_USER", "ENTRYTYPE_HOST_WILD", "ENTRYTYPE_HOST", "" }; - -/** Constructor - * @param mode What mode this host is for - can be CMODE_BEGIN for unknown/no mode - * @param _host A full nick!ident@host/cidr mask - */ -Entry::Entry(ChannelModeName mode, const Anope::string &_host) : Flags<EntryType>(EntryFlagString), modename(mode) +void Channel::Unban(const User *u, bool full) { - this->SetFlag(ENTRYTYPE_NONE); - this->cidr_len = 0; - this->mask = _host; - - Anope::string _nick, _user, _realhost; - size_t at = _host.find('@'); - if (at != Anope::string::npos) - { - _realhost = _host.substr(at + 1); - Anope::string _nickident = _host.substr(0, at); - - size_t ex = _nickident.find('!'); - if (ex != Anope::string::npos) - { - _user = _nickident.substr(ex + 1); - _nick = _nickident.substr(0, ex); - } - else - _user = _nickident; - } - else - _realhost = _host; - - if (!_nick.empty() && !str_is_pure_wildcard(_nick)) - { - this->nick = _nick; - if (str_is_wildcard(_nick)) - this->SetFlag(ENTRYTYPE_NICK_WILD); - else - this->SetFlag(ENTRYTYPE_NICK); - } + if (!this->HasMode(CMODE_BAN)) + return; - if (!_user.empty() && !str_is_pure_wildcard(_user)) + std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> bans = this->GetModeList(CMODE_BAN); + for (; bans.first != bans.second;) { - this->user = _user; - if (str_is_wildcard(_user)) - this->SetFlag(ENTRYTYPE_USER_WILD); - else - this->SetFlag(ENTRYTYPE_USER); - } - - if (!_realhost.empty() && !str_is_pure_wildcard(_realhost)) - { - size_t sl = _realhost.find_last_of('/'); - if (sl != Anope::string::npos) - { - try - { - sockaddrs addr(_realhost.substr(0, sl)); - /* If we got here, _realhost is a valid IP */ - - Anope::string cidr_range = _realhost.substr(sl + 1); - if (cidr_range.is_pos_number_only()) - { - _realhost = _realhost.substr(0, sl); - this->cidr_len = convertTo<unsigned int>(cidr_range); - this->SetFlag(ENTRYTYPE_CIDR); - Log(LOG_DEBUG) << "Ban " << _realhost << " has cidr " << static_cast<unsigned int>(this->cidr_len); - } - } - catch (const SocketException &) { } - } - - this->host = _realhost; - - if (!this->HasFlag(ENTRYTYPE_CIDR)) - { - if (str_is_wildcard(_realhost)) - this->SetFlag(ENTRYTYPE_HOST_WILD); - else - this->SetFlag(ENTRYTYPE_HOST); - } + Entry ban(CMODE_BAN, bans.first->second); + ++bans.first; + if (ban.Matches(u, full)) + this->RemoveMode(NULL, CMODE_BAN, ban.GetMask()); } } -/** Get the banned mask for this entry - * @return The mask - */ -const Anope::string Entry::GetMask() +Channel* Channel::Find(const Anope::string &name) { - return this->mask; -} - -/** Check if this entry matches a user - * @param u The user - * @param full True to match against a users real host and IP - * @return true on match - */ -bool Entry::Matches(const User *u, bool full) const -{ - bool ret = true; - - if (this->HasFlag(ENTRYTYPE_CIDR)) - { - try - { - if (full) - { - cidr cidr_mask(this->host, this->cidr_len); - sockaddrs addr(u->ip); - if (!cidr_mask.match(addr)) - ret = false; - } - /* If we're not matching fully and their displayed host isnt their IP */ - else if (u->ip != u->GetDisplayedHost()) - ret = false; - } - catch (const SocketException &) - { - ret = false; - } - } - if (this->HasFlag(ENTRYTYPE_NICK) && !this->nick.equals_ci(u->nick)) - ret = false; - if (this->HasFlag(ENTRYTYPE_USER) && !this->user.equals_ci(u->GetVIdent()) && (!full || - !this->user.equals_ci(u->GetIdent()))) - ret = false; - if (this->HasFlag(ENTRYTYPE_HOST) && !this->host.equals_ci(u->GetDisplayedHost()) && (!full || - (!this->host.equals_ci(u->host) && !this->host.equals_ci(u->chost) && !this->host.equals_ci(u->vhost) && - !this->host.equals_ci(u->ip)))) - ret = false; - if (this->HasFlag(ENTRYTYPE_NICK_WILD) && !Anope::Match(u->nick, this->nick)) - ret = false; - if (this->HasFlag(ENTRYTYPE_USER_WILD) && !Anope::Match(u->GetVIdent(), this->user) && (!full || - !Anope::Match(u->GetIdent(), this->user))) - ret = false; - if (this->HasFlag(ENTRYTYPE_HOST_WILD) && !Anope::Match(u->GetDisplayedHost(), this->host) && (!full || - (!Anope::Match(u->host, this->host) && !Anope::Match(u->chost, this->host) && - !Anope::Match(u->vhost, this->host) && !Anope::Match(u->ip, this->host)))) - ret = false; - - ChannelMode *cm = ModeManager::FindChannelModeByName(this->modename); - if (cm != NULL && cm->Type == MODE_LIST) - { - ChannelModeList *cml = anope_dynamic_static_cast<ChannelModeList *>(cm); - if (cml->Matches(u, this)) - ret = true; - } + channel_map::const_iterator it = ChannelList.find(name); - return ret; + if (it != ChannelList.end()) + return it->second; + return NULL; } diff --git a/src/chanserv.cpp b/src/chanserv.cpp deleted file mode 100644 index 4456ce37c..000000000 --- a/src/chanserv.cpp +++ /dev/null @@ -1,105 +0,0 @@ -/* ChanServ functions. - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - -/*************************************************************************/ - -#include "services.h" -#include "anope.h" -#include "regchannel.h" -#include "users.h" -#include "channels.h" -#include "access.h" -#include "account.h" - -ChannelInfo* cs_findchan(const Anope::string &chan) -{ - registered_channel_map::const_iterator it = RegisteredChannelList->find(chan); - if (it != RegisteredChannelList->end()) - { - it->second->QueueUpdate(); - return it->second; - } - - return NULL; -} - -/*************************************************************************/ - -/** Is the user the real founder? - * @param user The user - * @param ci The channel - * @return true or false - */ -bool IsFounder(const User *user, const ChannelInfo *ci) -{ - if (!user || !ci) - return false; - - if (user->SuperAdmin) - return true; - - if (user->Account() && user->Account() == ci->GetFounder()) - return true; - - return false; -} - -/*************************************************************************/ - -void update_cs_lastseen(User *user, ChannelInfo *ci) -{ - if (!ci || !user) - return; - - AccessGroup u_access = ci->AccessFor(user); - for (unsigned i = u_access.size(); i > 0; --i) - u_access[i - 1]->last_seen = Anope::CurTime; -} - -/*************************************************************************/ - -/* Returns the best ban possible for a user depending of the bantype - value. */ - -int get_idealban(const ChannelInfo *ci, User *u, Anope::string &ret) -{ - Anope::string mask; - - if (!ci || !u) - return 0; - - Anope::string vident = u->GetIdent(); - - switch (ci->bantype) - { - case 0: - ret = "*!" + vident + "@" + u->GetDisplayedHost(); - return 1; - case 1: - if (vident[0] == '~') - ret = "*!*" + vident + "@" + u->GetDisplayedHost(); - else - ret = "*!" + vident + "@" + u->GetDisplayedHost(); - - return 1; - case 2: - ret = "*!*@" + u->GetDisplayedHost(); - return 1; - case 3: - mask = create_mask(u); - ret = "*!" + mask; - return 1; - - default: - return 0; - } -} - diff --git a/src/command.cpp b/src/command.cpp index 6ae9275ca..92991e38b 100644 --- a/src/command.cpp +++ b/src/command.cpp @@ -1,13 +1,14 @@ /* + * * Copyright (C) 2008-2011 Robin Burchell <w00t@inspircd.org> * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #include "services.h" #include "commands.h" -#include "extern.h" #include "users.h" #include "language.h" #include "config.h" @@ -17,6 +18,9 @@ #include "regchannel.h" #include "channels.h" +static const Anope::string CommandFlagString[] = { "CFLAG_ALLOW_UNREGISTERED", "CFLAG_STRIP_CHANNEL", "" }; +template<> const Anope::string* Flags<CommandFlag>::flags_strings = CommandFlagString; + CommandSource::CommandSource(const Anope::string &n, User *user, NickCore *core, CommandReply *r, BotInfo *bi) : nick(n), u(user), nc(core), reply(r), c(NULL), service(bi) { @@ -97,7 +101,7 @@ void CommandSource::Reply(const char *message, ...) va_list args; char buf[4096]; // Messages can be really big. - const char *translated_message = translate(this->nc, message); + const char *translated_message = Language::Translate(this->nc, message); va_start(args, message); vsnprintf(buf, sizeof(buf), translated_message, args); @@ -109,7 +113,7 @@ void CommandSource::Reply(const char *message, ...) void CommandSource::Reply(const Anope::string &message) { - const char *translated_message = translate(this->nc, message.c_str()); + const char *translated_message = Language::Translate(this->nc, message.c_str()); sepstream sep(translated_message, '\n'); Anope::string tok; @@ -117,7 +121,7 @@ void CommandSource::Reply(const Anope::string &message) this->reply->SendMessage(this->service, tok); } -Command::Command(Module *o, const Anope::string &sname, size_t min_params, size_t max_params) : Service(o, "Command", sname), Flags<CommandFlag>(CommandFlagStrings), MaxParams(max_params), MinParams(min_params), module(owner) +Command::Command(Module *o, const Anope::string &sname, size_t minparams, size_t maxparams) : Service(o, "Command", sname), max_params(maxparams), min_params(minparams), module(owner) { } @@ -163,7 +167,7 @@ const Anope::string &Command::GetDesc() const void Command::OnServHelp(CommandSource &source) { - source.Reply(" %-14s %s", source.command.c_str(), translate(source.nc, (this->GetDesc().c_str()))); + source.Reply(" %-14s %s", source.command.c_str(), Language::Translate(source.nc, this->GetDesc().c_str())); } bool Command::OnHelp(CommandSource &source, const Anope::string &subcommand) { return false; } @@ -176,7 +180,8 @@ void Command::OnSyntaxError(CommandSource &source, const Anope::string &subcomma void RunCommand(CommandSource &source, const Anope::string &message) { - std::vector<Anope::string> params = BuildStringVector(message); + std::vector<Anope::string> params; + spacesepstream(message).GetTokens(params); bool has_help = source.service->commands.find("HELP") != source.service->commands.end(); CommandInfo::map::const_iterator it = source.service->commands.end(); @@ -202,7 +207,7 @@ void RunCommand(CommandSource &source, const Anope::string &message) } const CommandInfo &info = it->second; - service_reference<Command> c("Command", info.name); + ServiceReference<Command> c("Command", info.name); if (!c) { if (has_help) @@ -225,10 +230,10 @@ void RunCommand(CommandSource &source, const Anope::string &message) for (unsigned i = 0, j = params.size() - (count - 1); i < j; ++i) params.erase(params.begin()); - while (c->MaxParams > 0 && params.size() > c->MaxParams) + while (c->max_params > 0 && params.size() > c->max_params) { - params[c->MaxParams - 1] += " " + params[c->MaxParams]; - params.erase(params.begin() + c->MaxParams); + params[c->max_params - 1] += " " + params[c->max_params]; + params.erase(params.begin() + c->max_params); } source.command = it->first; @@ -239,7 +244,7 @@ void RunCommand(CommandSource &source, const Anope::string &message) if (MOD_RESULT == EVENT_STOP) return; - if (params.size() < c->MinParams) + if (params.size() < c->min_params) { c->OnSyntaxError(source, !params.empty() ? params[params.size() - 1] : ""); return; @@ -255,8 +260,8 @@ void RunCommand(CommandSource &source, const Anope::string &message) } bool had_u = source.GetUser(), had_nc = source.nc; - dynamic_reference<User> user_reference(source.GetUser()); - dynamic_reference<NickCore> nc_reference(source.nc); + Reference<User> user_reference(source.GetUser()); + Reference<NickCore> nc_reference(source.nc); c->Execute(source, params); if (had_u == user_reference && had_nc == nc_reference) { diff --git a/src/config.cpp b/src/config.cpp index be12c3479..48126cf7d 100644 --- a/src/config.cpp +++ b/src/config.cpp @@ -7,11 +7,11 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" #include "config.h" -#include "extern.h" #include "bots.h" #include "access.h" #include "opertype.h" @@ -28,7 +28,7 @@ /*************************************************************************/ -ConfigurationFile services_conf("services.conf", false); // Services configuration file name +ConfigurationFile ServicesConf("services.conf", false); // Services configuration file name ServerConfig *Config = NULL; static Anope::string UlineServers; @@ -38,7 +38,7 @@ static Anope::string NSDefaults; /*************************************************************************/ -ServerConfig::ServerConfig() : config_data(), NSDefFlags(NickCoreFlagStrings), CSDefFlags(ChannelInfoFlagStrings), BSDefFlags(BotServFlagStrings) +ServerConfig::ServerConfig() { this->Read(); @@ -173,7 +173,7 @@ ServerConfig::ServerConfig() : config_data(), NSDefFlags(NickCoreFlagStrings), C if (this->Seed == 0) Log() << "Configuration option options:seed should be set. It's for YOUR safety! Remember that!"; - SetDefaultMLock(this); + ModeManager::UpdateDefaultMLock(this); if (IsFile(this->NameServer)) { @@ -208,8 +208,8 @@ ServerConfig::ServerConfig() : config_data(), NSDefFlags(NickCoreFlagStrings), C this->NameServer = "127.0.0.1"; } } - delete DNSEngine; - DNSEngine = new DNSManager(this->NameServer, this->DNSIP, this->DNSPort); + delete DNS::Engine; + DNS::Engine = new DNS::Manager(this->NameServer, this->DNSIP, this->DNSPort); if (this->CaseMap == "ascii") Anope::casemap = std::locale(std::locale(), new Anope::ascii_ctype<char>()); @@ -363,27 +363,27 @@ void ServerConfig::ValidateHostname(const Anope::string &p, const Anope::string } } -bool ValidateNotEmpty(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateNotEmpty(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (data.GetValue().empty()) throw ConfigException("The value for <" + tag + ":" + value + "> cannot be empty!"); return true; } -bool ValidateNotZero(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateNotZero(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data) { - if (!data.GetInteger() && dotime(data.GetValue()) <= 0) + if (!data.GetInteger() && Anope::DoTime(data.GetValue()) <= 0) throw ConfigException("The value for <" + tag + ":" + value + "> must be non-zero!"); return true; } -bool ValidateEmailReg(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateEmailReg(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (!config->NSRegistration.equals_ci("none") && !config->NSRegistration.equals_ci("disable")) { if (value.equals_ci("unconfirmedexpire")) { - if (!data.GetInteger() && dotime(data.GetValue()) <= 0) + if (!data.GetInteger() && Anope::DoTime(data.GetValue()) <= 0) throw ConfigException("The value for <" + tag + ":" + value + "> must be non-zero when e-mail or admin registration is enabled!"); } else @@ -395,7 +395,7 @@ bool ValidateEmailReg(ServerConfig *config, const Anope::string &tag, const Anop return true; } -bool ValidatePort(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidatePort(ServerConfig *, const Anope::string &tag, const Anope::string &value, ValueItem &data) { int port = data.GetInteger(); if (!port) @@ -405,7 +405,7 @@ bool ValidatePort(ServerConfig *, const Anope::string &tag, const Anope::string return true; } -bool ValidateBantype(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &data) +static bool ValidateBantype(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &data) { int bantype = data.GetInteger(); if (bantype < 0 || bantype > 3) @@ -413,7 +413,7 @@ bool ValidateBantype(ServerConfig *, const Anope::string &, const Anope::string return true; } -bool ValidateNickServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateNickServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (!config->NickServ.empty()) { @@ -434,7 +434,7 @@ bool ValidateNickServ(ServerConfig *config, const Anope::string &tag, const Anop return true; } -bool ValidateChanServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateChanServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (!config->ChanServ.empty()) { @@ -448,31 +448,13 @@ bool ValidateChanServ(ServerConfig *config, const Anope::string &tag, const Anop return true; } -bool ValidateMemoServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) -{ - if (!config->MemoServ.empty()) - { - if (value.equals_ci("description")) - { - if (data.GetValue().empty()) - throw ConfigException("The value for <" + tag + ":" + value + "> cannot be empty when MemoServ is enabled!"); - } - } - return true; -} - -bool ValidateBotServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateBotServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (!config->BotServ.empty()) { - if (value.equals_ci("description")) + if (value.equals_ci("badwordsmax") || value.equals_ci("keepdata")) { - if (data.GetValue().empty()) - throw ConfigException("The value for <" + tag + ":" + value + "> cannot be empty when BotServ is enabled!"); - } - else if (value.equals_ci("badwordsmax") || value.equals_ci("keepdata")) - { - if (!data.GetInteger() && dotime(data.GetValue()) <= 0) + if (!data.GetInteger() && Anope::DoTime(data.GetValue()) <= 0) throw ConfigException("The value for <" + tag + ":" + value + "> must be non-zero when BotServ is enabled!"); } else if (value.equals_ci("minusers")) @@ -484,36 +466,24 @@ bool ValidateBotServ(ServerConfig *config, const Anope::string &tag, const Anope return true; } -bool ValidateHostServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) -{ - if (!config->HostServ.empty()) - { - if (value.equals_ci("description") && data.GetValue().empty()) - throw ConfigException("The value for <" + tag + ":" + value + "> cannot be empty when HostServ is enabled!"); - } - return true; -} - -bool ValidateLimitSessions(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateLimitSessions(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (config->LimitSessions) { if (value.equals_ci("maxsessionlimit") || value.equals_ci("exceptionexpiry")) { - if (!data.GetInteger() && dotime(data.GetValue()) <= 0) + if (!data.GetInteger() && Anope::DoTime(data.GetValue()) <= 0) throw ConfigException("The value for <" + tag + ":" + value + "> must be non-zero when session limiting is enabled!"); } } return true; } -bool ValidateOperServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateOperServ(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (!config->OperServ.empty()) { - if (value.equals_ci("description") && data.GetValue().empty()) - throw ConfigException("The value for <" + tag + ":" + value + "> cannot be empty when OperServ is enabled!"); - else if (value.equals_ci("autokillexpiry") || value.equals_ci("chankillexpiry") || value.equals_ci("snlineexpiry") || value.equals_ci("sqlineexpiry")) + if (value.equals_ci("autokillexpiry") || value.equals_ci("chankillexpiry") || value.equals_ci("snlineexpiry") || value.equals_ci("sqlineexpiry")) return ValidateNotZero(config, tag, value, data); else if (value.equals_ci("maxsessionlimit") || value.equals_ci("exceptionexpiry")) return ValidateLimitSessions(config, tag, value, data); @@ -521,17 +491,7 @@ bool ValidateOperServ(ServerConfig *config, const Anope::string &tag, const Anop return true; } -bool ValidateGlobal(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) -{ - if (!config->Global.empty()) - { - if (value.equals_ci("description") && data.GetValue().empty()) - throw ConfigException("The value for <" + tag + ":" + value + "> cannot be empty when Global is enabled!"); - } - return true; -} - -bool ValidateNickLen(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &data) +static bool ValidateNickLen(ServerConfig *, const Anope::string &, const Anope::string &, ValueItem &data) { int nicklen = data.GetInteger(); if (!nicklen) @@ -548,7 +508,7 @@ bool ValidateNickLen(ServerConfig *, const Anope::string &, const Anope::string return true; } -bool ValidateMail(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateMail(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (config->UseMail) { @@ -561,7 +521,7 @@ bool ValidateMail(ServerConfig *config, const Anope::string &tag, const Anope::s return true; } -bool ValidateGlobalOnCycle(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) +static bool ValidateGlobalOnCycle(ServerConfig *config, const Anope::string &tag, const Anope::string &value, ValueItem &data) { if (config->GlobalOnCycle) { @@ -574,7 +534,7 @@ bool ValidateGlobalOnCycle(ServerConfig *config, const Anope::string &tag, const return true; } -bool InitUplinks(ServerConfig *config, const Anope::string &) +static bool InitUplinks(ServerConfig *config, const Anope::string &) { if (!config->Uplinks.empty()) { @@ -722,7 +682,7 @@ static bool DoOper(ServerConfig *config, const Anope::string &, const Anope::str o->config = true; o->password = password; o->certfp = certfp; - o->hosts = BuildStringVector(host); + spacesepstream(host).GetTokens(o->hosts); o->vhost = vhost; config->Opers.push_back(o); @@ -735,7 +695,7 @@ static bool DoneOpers(ServerConfig *config, const Anope::string &) { Oper *o = config->Opers[i]; - const NickAlias *na = findnick(o->name); + const NickAlias *na = NickAlias::Find(o->name); if (!na) // Nonexistant nick continue; @@ -796,7 +756,7 @@ static bool DoneInclude(ServerConfig *config, const Anope::string &) /*************************************************************************/ -bool InitModules(ServerConfig *, const Anope::string &) +static bool InitModules(ServerConfig *, const Anope::string &) { return true; } @@ -826,7 +786,7 @@ static bool DoneModules(ServerConfig *config, const Anope::string &) return true; } -bool InitLogs(ServerConfig *config, const Anope::string &) +static bool InitLogs(ServerConfig *config, const Anope::string &) { config->LogInfos.clear(); return true; @@ -853,15 +813,15 @@ static bool DoLogs(ServerConfig *config, const Anope::string &, const Anope::str bool ldebug = values[11].GetBool(); LogInfo *l = new LogInfo(logage, rawio, ldebug); - l->Targets = BuildStringList(targets); - l->Sources = BuildStringList(source); - l->Admin = BuildStringList(admin); - l->Override = BuildStringList(override); - l->Commands = BuildStringList(commands); - l->Servers = BuildStringList(servers); - l->Channels = BuildStringList(channels); - l->Users = BuildStringList(users); - l->Normal = BuildStringList(normal); + spacesepstream(targets).GetTokens(l->targets); + spacesepstream(source).GetTokens(l->sources); + spacesepstream(admin).GetTokens(l->admin); + spacesepstream(override).GetTokens(l->override); + spacesepstream(commands).GetTokens(l->commands); + spacesepstream(servers).GetTokens(l->servers); + spacesepstream(channels).GetTokens(l->channels); + spacesepstream(users).GetTokens(l->users); + spacesepstream(normal).GetTokens(l->normal); config->LogInfos.push_back(l); @@ -909,7 +869,7 @@ static bool DoCommands(ServerConfig *config, const Anope::string &, const Anope: if (!ValidateNotEmpty(config, "command", "command", vi)) throw ConfigException("One or more values in your configuration file failed to validate. Please see your log for more information."); - BotInfo *bi = findbot(service); + BotInfo *bi = BotInfo::Find(service); if (bi == NULL) throw ConfigException("Command " + name + " exists for nonexistant service " + service); @@ -992,7 +952,7 @@ static bool DoServices(ServerConfig *config, const Anope::string &, const Anope: throw ConfigException("One or more values in your configuration file failed to validate. Please see your log for more information."); services.insert(nick); - BotInfo* bi = findbot(nick); + BotInfo* bi = BotInfo::Find(nick); if (!bi) bi = new BotInfo(nick, user, host, gecos, modes); bi->SetFlag(BI_CONF); @@ -1014,7 +974,7 @@ static bool DoServices(ServerConfig *config, const Anope::string &, const Anope: chname = token.substr(ch); } bi->Join(chname); - Channel *c = findchan(chname); + Channel *c = Channel::Find(chname); if (!c) continue; // Can't happen @@ -1022,7 +982,7 @@ static bool DoServices(ServerConfig *config, const Anope::string &, const Anope: for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (cm && cm->Type == MODE_STATUS) + if (cm && cm->type == MODE_STATUS) c->RemoveMode(bi, cm, bi->nick); } /* Set the new modes */ @@ -1031,7 +991,7 @@ static bool DoServices(ServerConfig *config, const Anope::string &, const Anope: ChannelMode *cm = ModeManager::FindChannelModeByChar(want_modes[j]); if (cm == NULL) cm = ModeManager::FindChannelModeByChar(ModeManager::GetStatusChar(want_modes[j])); - if (cm && cm->Type == MODE_STATUS) + if (cm && cm->type == MODE_STATUS) c->SetMode(bi, cm, bi->GetUID()); } } @@ -1053,7 +1013,7 @@ static bool DoServices(ServerConfig *config, const Anope::string &, const Anope: if (found) continue; - Channel *c = findchan(chname); + Channel *c = Channel::Find(chname); if (c) bi->Part(c); } @@ -1069,7 +1029,7 @@ static bool DoneServices(ServerConfig *config, const Anope::string &) ++it; if (bi->HasFlag(BI_CONF) && services.count(bi->nick) == 0) - bi->destroy(); + bi->Destroy(); } services.clear(); return true; @@ -1123,7 +1083,7 @@ bool ConfigurationFile::IsOpen() const bool ConfigurationFile::Open() { this->Close(); - this->fp = (this->executable ? popen(this->name.c_str(), "r") : fopen((conf_dir + "/" + this->name).c_str(), "r")); + this->fp = (this->executable ? popen(this->name.c_str(), "r") : fopen((Anope::ConfigDir + "/" + this->name).c_str(), "r")); return this->fp != NULL; } @@ -1464,7 +1424,7 @@ void ServerConfig::Read() // These tags MUST occur and must ONLY occur once in the config file static const Anope::string Once[] = {"serverinfo", "networkinfo", "options", ""}; - this->LoadConf(services_conf); + this->LoadConf(ServicesConf); ConfigItems configitems(this); @@ -1550,9 +1510,9 @@ void ServerConfig::Read() if (has_value) { #ifdef _WIN32 - long time = static_cast<long>(dotime(item)); + long time = static_cast<long>(Anope::DoTime(item)); #else - time_t time = dotime(item); + time_t time = Anope::DoTime(item); #endif vl.push_back(ValueItem(time)); } @@ -1648,7 +1608,7 @@ void ServerConfig::Read() } case DT_TIME: { - time_t time = dotime(vi.GetValue()); + time_t time = Anope::DoTime(vi.GetValue()); ValueContainerTime *vci = anope_dynamic_static_cast<ValueContainerTime *>(configitems.Values[Index].val); vci->Set(&time, sizeof(time_t)); break; @@ -1665,10 +1625,10 @@ void ServerConfig::Read() } } - Log(LOG_DEBUG) << "End config " << services_conf.GetName(); + Log(LOG_DEBUG) << "End config " << ServicesConf.GetName(); for (int Index = 0; !Once[Index].empty(); ++Index) CheckOnce(Once[Index]); - Log() << "Done reading configuration file " << services_conf.GetName(); + Log() << "Done reading configuration file " << ServicesConf.GetName(); } void ServerConfig::LoadConf(ConfigurationFile &file) diff --git a/src/configreader.cpp b/src/configreader.cpp index 0bbdb0e49..ddcacfd26 100644 --- a/src/configreader.cpp +++ b/src/configreader.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ /* Taken from: diff --git a/src/dns.cpp b/src/dns.cpp index 29c3134f7..d295aabf0 100644 --- a/src/dns.cpp +++ b/src/dns.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -21,11 +22,13 @@ #include <netdb.h> #endif -DNSManager *DNSEngine = NULL; +using namespace DNS; + +Manager *DNS::Engine = NULL; Question::Question() { - this->type = DNS_QUERY_NONE; + this->type = QUERY_NONE; this->qclass = 0; } @@ -45,22 +48,22 @@ ResourceRecord::ResourceRecord(const Question &q) : Question(q) this->created = Anope::CurTime; } -DNSQuery::DNSQuery() +Query::Query() { - this->error = DNS_ERROR_NONE; + this->error = ERROR_NONE; } -DNSQuery::DNSQuery(const Question &q) +Query::Query(const Question &q) { this->questions.push_back(q); - this->error = DNS_ERROR_NONE; + this->error = ERROR_NONE; } -DNSRequest::DNSRequest(const Anope::string &addr, QueryType qt, bool cache, Module *c) : Timer(Config->DNSTimeout), Question(addr, qt), use_cache(cache), id(0), creator(c) +Request::Request(const Anope::string &addr, QueryType qt, bool cache, Module *c) : Timer(Config->DNSTimeout), Question(addr, qt), use_cache(cache), id(0), creator(c) { - if (!DNSEngine || !DNSEngine->udpsock) - throw SocketException("No DNSEngine"); - if (DNSEngine->udpsock->GetPackets().size() == 65535) + if (!DNS::Engine || !DNS::Engine->udpsock) + throw SocketException("No DNS::Engine"); + if (DNS::Engine->udpsock->GetPackets().size() == 65535) throw SocketException("DNS queue full"); do @@ -68,51 +71,51 @@ DNSRequest::DNSRequest(const Anope::string &addr, QueryType qt, bool cache, Modu static unsigned short cur_id = rand(); this->id = cur_id++; } - while (DNSEngine->requests.count(this->id)); + while (DNS::Engine->requests.count(this->id)); - DNSEngine->requests[this->id] = this; + DNS::Engine->requests[this->id] = this; } -DNSRequest::~DNSRequest() +Request::~Request() { - DNSEngine->requests.erase(this->id); + DNS::Engine->requests.erase(this->id); } -void DNSRequest::Process() +void Request::Process() { Log(LOG_DEBUG_2) << "Resolver: Processing request to lookup " << this->name << ", of type " << this->type; - if (!DNSEngine || !DNSEngine->udpsock) - throw SocketException("DNSEngine has not been initialized"); + if (!DNS::Engine || !DNS::Engine->udpsock) + throw SocketException("DNS::Engine has not been initialized"); - if (this->use_cache && DNSEngine->CheckCache(this)) + if (this->use_cache && DNS::Engine->CheckCache(this)) { Log(LOG_DEBUG_2) << "Resolver: Using cached result"; delete this; return; } - DNSPacket *p = new DNSPacket(&DNSEngine->addrs); - p->flags = DNS_QUERYFLAGS_RD; + Packet *p = new Packet(&DNS::Engine->addrs); + p->flags = QUERYFLAGS_RD; p->id = this->id; p->questions.push_back(*this); - DNSEngine->udpsock->Reply(p); + DNS::Engine->udpsock->Reply(p); } -void DNSRequest::OnError(const DNSQuery *r) +void Request::OnError(const Query *r) { } -void DNSRequest::Tick(time_t) +void Request::Tick(time_t) { Log(LOG_DEBUG_2) << "Resolver: timeout for query " << this->name; - DNSQuery rr(*this); - rr.error = DNS_ERROR_TIMEOUT; + Query rr(*this); + rr.error = ERROR_TIMEOUT; this->OnError(&rr); } -void DNSPacket::PackName(unsigned char *output, unsigned short output_size, unsigned short &pos, const Anope::string &name) +void Packet::PackName(unsigned char *output, unsigned short output_size, unsigned short &pos, const Anope::string &name) { if (name.length() + 2 > output_size) throw SocketException("Unable to pack name"); @@ -132,7 +135,7 @@ void DNSPacket::PackName(unsigned char *output, unsigned short output_size, unsi output[pos++] = 0; } -Anope::string DNSPacket::UnpackName(const unsigned char *input, unsigned short input_size, unsigned short &pos) +Anope::string Packet::UnpackName(const unsigned char *input, unsigned short input_size, unsigned short &pos) { Anope::string name; unsigned short pos_ptr = pos, lowest_ptr = input_size; @@ -145,9 +148,9 @@ Anope::string DNSPacket::UnpackName(const unsigned char *input, unsigned short i { unsigned short offset = input[pos_ptr]; - if (offset & DNS_POINTER) + if (offset & POINTER) { - if ((offset & DNS_POINTER) != DNS_POINTER) + if ((offset & POINTER) != POINTER) throw SocketException("Unable to unpack name - bogus compression header"); if (pos_ptr + 1 >= input_size) throw SocketException("Unable to unpack name - bogus compression header"); @@ -159,7 +162,7 @@ Anope::string DNSPacket::UnpackName(const unsigned char *input, unsigned short i compressed = true; } - pos_ptr = (offset & DNS_LABEL) << 8 | input[pos_ptr + 1]; + pos_ptr = (offset & LABEL) << 8 | input[pos_ptr + 1]; /* Pointers can only go back */ if (pos_ptr >= lowest_ptr) @@ -190,7 +193,7 @@ Anope::string DNSPacket::UnpackName(const unsigned char *input, unsigned short i return name; } -Question DNSPacket::UnpackQuestion(const unsigned char *input, unsigned short input_size, unsigned short &pos) +Question Packet::UnpackQuestion(const unsigned char *input, unsigned short input_size, unsigned short &pos) { Question question; @@ -208,7 +211,7 @@ Question DNSPacket::UnpackQuestion(const unsigned char *input, unsigned short in return question; } -ResourceRecord DNSPacket::UnpackResourceRecord(const unsigned char *input, unsigned short input_size, unsigned short &pos) +ResourceRecord Packet::UnpackResourceRecord(const unsigned char *input, unsigned short input_size, unsigned short &pos) { ResourceRecord record = static_cast<ResourceRecord>(this->UnpackQuestion(input, input_size, pos)); @@ -223,7 +226,7 @@ ResourceRecord DNSPacket::UnpackResourceRecord(const unsigned char *input, unsig switch (record.type) { - case DNS_QUERY_A: + case QUERY_A: { if (pos + 4 > input_size) throw SocketException("Unable to unpack resource record"); @@ -238,7 +241,7 @@ ResourceRecord DNSPacket::UnpackResourceRecord(const unsigned char *input, unsig record.rdata = addrs.addr(); break; } - case DNS_QUERY_AAAA: + case QUERY_AAAA: { if (pos + 16 > input_size) throw SocketException("Unable to unpack resource record"); @@ -254,8 +257,8 @@ ResourceRecord DNSPacket::UnpackResourceRecord(const unsigned char *input, unsig record.rdata = addrs.addr(); break; } - case DNS_QUERY_CNAME: - case DNS_QUERY_PTR: + case QUERY_CNAME: + case QUERY_PTR: { record.rdata = this->UnpackName(input, input_size, pos); break; @@ -269,15 +272,15 @@ ResourceRecord DNSPacket::UnpackResourceRecord(const unsigned char *input, unsig return record; } -DNSPacket::DNSPacket(sockaddrs *a) : DNSQuery(), id(0), flags(0) +Packet::Packet(sockaddrs *a) : Query(), id(0), flags(0) { if (a) addr = *a; } -void DNSPacket::Fill(const unsigned char *input, const unsigned short len) +void Packet::Fill(const unsigned char *input, const unsigned short len) { - if (len < DNSPacket::HEADER_LENGTH) + if (len < Packet::HEADER_LENGTH) throw SocketException("Unable to fill packet"); unsigned short packet_pos = 0; @@ -315,9 +318,9 @@ void DNSPacket::Fill(const unsigned char *input, const unsigned short len) this->additional.push_back(this->UnpackResourceRecord(input, len, packet_pos)); } -unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size) +unsigned short Packet::Pack(unsigned char *output, unsigned short output_size) { - if (output_size < DNSPacket::HEADER_LENGTH) + if (output_size < Packet::HEADER_LENGTH) throw SocketException("Unable to pack packet"); unsigned short pos = 0; @@ -339,7 +342,7 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size { Question &q = this->questions[i]; - if (q.type == DNS_QUERY_PTR) + if (q.type == QUERY_PTR) { sockaddrs ip(q.name); @@ -411,7 +414,7 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size switch (rr.type) { - case DNS_QUERY_A: + case QUERY_A: { if (pos + 6 > output_size) throw SocketException("Unable to pack packet"); @@ -426,7 +429,7 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size pos += 4; break; } - case DNS_QUERY_AAAA: + case QUERY_AAAA: { if (pos + 18 > output_size) throw SocketException("Unable to pack packet"); @@ -441,9 +444,9 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size pos += 16; break; } - case DNS_QUERY_NS: - case DNS_QUERY_CNAME: - case DNS_QUERY_PTR: + case QUERY_NS: + case QUERY_CNAME: + case QUERY_PTR: { if (pos + 2 >= output_size) throw SocketException("Unable to pack packet"); @@ -457,7 +460,7 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size memcpy(&output[packet_pos_save], &s, 2); break; } - case DNS_QUERY_SOA: + case QUERY_SOA: { if (pos + 2 >= output_size) throw SocketException("Unable to pack packet"); @@ -471,7 +474,7 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size if (pos + 20 >= output_size) throw SocketException("Unable to pack SOA"); - l = htonl(DNSEngine->GetSerial()); + l = htonl(DNS::Engine->GetSerial()); memcpy(&output[pos], &l, 4); pos += 4; @@ -504,25 +507,25 @@ unsigned short DNSPacket::Pack(unsigned char *output, unsigned short output_size return pos; } -DNSManager::TCPSocket::Client::Client(TCPSocket *ls, int fd, const sockaddrs &addr) : Socket(fd, ls->IsIPv6()), ClientSocket(ls, addr), Timer(5), tcpsock(ls), packet(NULL), length(0) +Manager::TCPSocket::Client::Client(TCPSocket *l, int fd, const sockaddrs &addr) : Socket(fd, l->IsIPv6()), ClientSocket(l, addr), Timer(5), tcpsock(l), packet(NULL), length(0) { Log(LOG_DEBUG_2) << "Resolver: New client from " << addr.addr(); } -DNSManager::TCPSocket::Client::~Client() +Manager::TCPSocket::Client::~Client() { Log(LOG_DEBUG_2) << "Resolver: Exiting client from " << clientaddr.addr(); delete packet; } -void DNSManager::TCPSocket::Client::Reply(DNSPacket *p) +void Manager::TCPSocket::Client::Reply(Packet *p) { delete packet; packet = p; SocketEngine::Change(this, true, SF_WRITABLE); } -bool DNSManager::TCPSocket::Client::ProcessRead() +bool Manager::TCPSocket::Client::ProcessRead() { Log(LOG_DEBUG_2) << "Resolver: Reading from DNS TCP socket"; @@ -536,12 +539,12 @@ bool DNSManager::TCPSocket::Client::ProcessRead() if (length >= want_len - 2) { SocketEngine::Change(this, false, SF_READABLE); - return DNSEngine->HandlePacket(this, packet_buffer + 2, length - 2, NULL); + return DNS::Engine->HandlePacket(this, packet_buffer + 2, length - 2, NULL); } return true; } -bool DNSManager::TCPSocket::Client::ProcessWrite() +bool Manager::TCPSocket::Client::ProcessWrite() { Log(LOG_DEBUG_2) << "Resolver: Writing to DNS TCP socket"; @@ -568,32 +571,32 @@ bool DNSManager::TCPSocket::Client::ProcessWrite() return true; /* Do not return false here, bind is unhappy we close the connection so soon after sending */ } -DNSManager::TCPSocket::TCPSocket(const Anope::string &ip, int port) : Socket(-1, ip.find(':') != Anope::string::npos), ListenSocket(ip, port, ip.find(':') != Anope::string::npos) +Manager::TCPSocket::TCPSocket(const Anope::string &ip, int port) : Socket(-1, ip.find(':') != Anope::string::npos), ListenSocket(ip, port, ip.find(':') != Anope::string::npos) { } -ClientSocket *DNSManager::TCPSocket::OnAccept(int fd, const sockaddrs &addr) +ClientSocket *Manager::TCPSocket::OnAccept(int fd, const sockaddrs &addr) { return new Client(this, fd, addr); } -DNSManager::UDPSocket::UDPSocket(const Anope::string &ip, int port) : Socket(-1, ip.find(':') != Anope::string::npos, SOCK_DGRAM) +Manager::UDPSocket::UDPSocket(const Anope::string &ip, int port) : Socket(-1, ip.find(':') != Anope::string::npos, SOCK_DGRAM) { } -DNSManager::UDPSocket::~UDPSocket() +Manager::UDPSocket::~UDPSocket() { for (unsigned i = 0; i < packets.size(); ++i) delete packets[i]; } -void DNSManager::UDPSocket::Reply(DNSPacket *p) +void Manager::UDPSocket::Reply(Packet *p) { packets.push_back(p); SocketEngine::Change(this, true, SF_WRITABLE); } -bool DNSManager::UDPSocket::ProcessRead() +bool Manager::UDPSocket::ProcessRead() { Log(LOG_DEBUG_2) << "Resolver: Reading from DNS UDP socket"; @@ -601,14 +604,14 @@ bool DNSManager::UDPSocket::ProcessRead() sockaddrs from_server; socklen_t x = sizeof(from_server); int length = recvfrom(this->GetFD(), reinterpret_cast<char *>(&packet_buffer), sizeof(packet_buffer), 0, &from_server.sa, &x); - return DNSEngine->HandlePacket(this, packet_buffer, length, &from_server); + return DNS::Engine->HandlePacket(this, packet_buffer, length, &from_server); } -bool DNSManager::UDPSocket::ProcessWrite() +bool Manager::UDPSocket::ProcessWrite() { Log(LOG_DEBUG_2) << "Resolver: Writing to DNS UDP socket"; - DNSPacket *r = !packets.empty() ? packets.front() : NULL; + Packet *r = !packets.empty() ? packets.front() : NULL; if (r != NULL) { try @@ -630,7 +633,7 @@ bool DNSManager::UDPSocket::ProcessWrite() return true; } -DNSManager::DNSManager(const Anope::string &nameserver, const Anope::string &ip, int port) : Timer(300, Anope::CurTime, true), listen(false), serial(0), tcpsock(NULL), udpsock(NULL) +Manager::Manager(const Anope::string &nameserver, const Anope::string &ip, int port) : Timer(300, Anope::CurTime, true), listen(false), serial(0), tcpsock(NULL), udpsock(NULL) { this->addrs.pton(nameserver.find(':') != Anope::string::npos ? AF_INET6 : AF_INET, nameserver, port); @@ -640,7 +643,7 @@ DNSManager::DNSManager(const Anope::string &nameserver, const Anope::string &ip, } catch (const SocketException &ex) { - Log() << "Unable to create socket for DNSManager: " << ex.GetReason(); + Log() << "Unable to create socket for Manager: " << ex.GetReason(); } try @@ -652,23 +655,23 @@ DNSManager::DNSManager(const Anope::string &nameserver, const Anope::string &ip, catch (const SocketException &ex) { /* This error can be from normal operation as most people don't use services to handle DNS queries, so put it in debug log */ - Log(LOG_DEBUG) << "Unable to bind DNSManager to port " << port << ": " << ex.GetReason(); + Log(LOG_DEBUG) << "Unable to bind Manager to port " << port << ": " << ex.GetReason(); } this->UpdateSerial(); } -DNSManager::~DNSManager() +Manager::~Manager() { delete udpsock; delete tcpsock; - for (std::map<unsigned short, DNSRequest *>::iterator it = this->requests.begin(), it_end = this->requests.end(); it != it_end; ++it) + for (std::map<unsigned short, Request *>::iterator it = this->requests.begin(), it_end = this->requests.end(); it != it_end; ++it) { - DNSRequest *request = it->second; + Request *request = it->second; - DNSQuery rr(*request); - rr.error = DNS_ERROR_UNKNOWN; + Query rr(*request); + rr.error = ERROR_UNKNOWN; request->OnError(&rr); delete request; @@ -677,15 +680,15 @@ DNSManager::~DNSManager() this->cache.clear(); - DNSEngine = NULL; + DNS::Engine = NULL; } -bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_buffer, int length, sockaddrs *from) +bool Manager::HandlePacket(ReplySocket *s, const unsigned char *const packet_buffer, int length, sockaddrs *from) { - if (length < DNSPacket::HEADER_LENGTH) + if (length < Packet::HEADER_LENGTH) return true; - DNSPacket recv_packet(from); + Packet recv_packet(from); try { @@ -697,7 +700,7 @@ bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_ return true; } - if (!(recv_packet.flags & DNS_QUERYFLAGS_QR)) + if (!(recv_packet.flags & QUERYFLAGS_QR)) { if (!listen) return true; @@ -707,9 +710,9 @@ bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_ return true; } - DNSPacket *packet = new DNSPacket(recv_packet); - packet->flags |= DNS_QUERYFLAGS_QR; /* This is a reponse */ - packet->flags |= DNS_QUERYFLAGS_AA; /* And we are authoritative */ + Packet *packet = new Packet(recv_packet); + packet->flags |= QUERYFLAGS_QR; /* This is a reponse */ + packet->flags |= QUERYFLAGS_AA; /* And we are authoritative */ packet->answers.clear(); packet->authorities.clear(); @@ -719,14 +722,14 @@ bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_ { const Question& q = recv_packet.questions[i]; - if (q.type == DNS_QUERY_AXFR || q.type == DNS_QUERY_SOA) + if (q.type == QUERY_AXFR || q.type == QUERY_SOA) { - ResourceRecord rr(q.name, DNS_QUERY_SOA); + ResourceRecord rr(q.name, QUERY_SOA); packet->answers.push_back(rr); - if (q.type == DNS_QUERY_AXFR) + if (q.type == QUERY_AXFR) { - ResourceRecord rr2(q.name, DNS_QUERY_NS); + ResourceRecord rr2(q.name, QUERY_NS); rr2.rdata = Config->DNSSOANS; packet->answers.push_back(rr2); } @@ -740,9 +743,9 @@ bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_ { const Question& q = recv_packet.questions[i]; - if (q.type == DNS_QUERY_AXFR) + if (q.type == QUERY_AXFR) { - ResourceRecord rr(q.name, DNS_QUERY_SOA); + ResourceRecord rr(q.name, QUERY_SOA); packet->answers.push_back(rr); break; } @@ -763,45 +766,45 @@ bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_ return true; } - std::map<unsigned short, DNSRequest *>::iterator it = DNSEngine->requests.find(recv_packet.id); - if (it == DNSEngine->requests.end()) + std::map<unsigned short, Request *>::iterator it = DNS::Engine->requests.find(recv_packet.id); + if (it == DNS::Engine->requests.end()) { Log(LOG_DEBUG_2) << "Resolver: Received an answer for something we didn't request"; return true; } - DNSRequest *request = it->second; + Request *request = it->second; - if (recv_packet.flags & DNS_QUERYFLAGS_OPCODE) + if (recv_packet.flags & QUERYFLAGS_OPCODE) { Log(LOG_DEBUG_2) << "Resolver: Received a nonstandard query"; - recv_packet.error = DNS_ERROR_NONSTANDARD_QUERY; + recv_packet.error = ERROR_NONSTANDARD_QUERY; request->OnError(&recv_packet); } - else if (recv_packet.flags & DNS_QUERYFLAGS_RCODE) + else if (recv_packet.flags & QUERYFLAGS_RCODE) { - DNSError error = DNS_ERROR_UNKNOWN; + Error error = ERROR_UNKNOWN; - switch (recv_packet.flags & DNS_QUERYFLAGS_RCODE) + switch (recv_packet.flags & QUERYFLAGS_RCODE) { case 1: Log(LOG_DEBUG_2) << "Resolver: format error"; - error = DNS_ERROR_FORMAT_ERROR; + error = ERROR_FORMAT_ERROR; break; case 2: Log(LOG_DEBUG_2) << "Resolver: server error"; - error = DNS_ERROR_SERVER_FAILURE; + error = ERROR_SERVER_FAILURE; break; case 3: Log(LOG_DEBUG_2) << "Resolver: domain not found"; - error = DNS_ERROR_DOMAIN_NOT_FOUND; + error = ERROR_DOMAIN_NOT_FOUND; break; case 4: Log(LOG_DEBUG_2) << "Resolver: not implemented"; - error = DNS_ERROR_NOT_IMPLEMENTED; + error = ERROR_NOT_IMPLEMENTED; break; case 5: Log(LOG_DEBUG_2) << "Resolver: refused"; - error = DNS_ERROR_REFUSED; + error = ERROR_REFUSED; break; default: break; @@ -813,21 +816,21 @@ bool DNSManager::HandlePacket(ReplySocket *s, const unsigned char *const packet_ else if (recv_packet.answers.empty()) { Log(LOG_DEBUG_2) << "Resolver: No resource records returned"; - recv_packet.error = DNS_ERROR_NO_RECORDS; + recv_packet.error = ERROR_NO_RECORDS; request->OnError(&recv_packet); } else { Log(LOG_DEBUG_2) << "Resolver: Lookup complete for " << request->name; request->OnLookupComplete(&recv_packet); - DNSEngine->AddCache(recv_packet); + DNS::Engine->AddCache(recv_packet); } delete request; return true; } -void DNSManager::AddCache(DNSQuery &r) +void Manager::AddCache(Query &r) { for (unsigned i = 0; i < r.answers.size(); ++i) { @@ -837,12 +840,12 @@ void DNSManager::AddCache(DNSQuery &r) } } -bool DNSManager::CheckCache(DNSRequest *request) +bool Manager::CheckCache(Request *request) { cache_map::iterator it = this->cache.find(request->name); if (it != this->cache.end()) { - DNSQuery record(*request); + Query record(*request); for (cache_map::iterator it_end = this->cache.upper_bound(request->name); it != it_end; ++it) { @@ -862,7 +865,7 @@ bool DNSManager::CheckCache(DNSRequest *request) return false; } -void DNSManager::Tick(time_t now) +void Manager::Tick(time_t now) { Log(LOG_DEBUG_2) << "Resolver: Purging DNS cache"; @@ -877,18 +880,18 @@ void DNSManager::Tick(time_t now) } } -void DNSManager::Cleanup(Module *mod) +void Manager::Cleanup(Module *mod) { - for (std::map<unsigned short, DNSRequest *>::iterator it = this->requests.begin(), it_end = this->requests.end(); it != it_end;) + for (std::map<unsigned short, Request *>::iterator it = this->requests.begin(), it_end = this->requests.end(); it != it_end;) { unsigned short id = it->first; - DNSRequest *req = it->second; + Request *req = it->second; ++it; if (req->creator && req->creator == mod) { - DNSQuery rr(*req); - rr.error = DNS_ERROR_UNLOADED; + Query rr(*req); + rr.error = ERROR_UNLOADED; req->OnError(&rr); delete req; @@ -897,25 +900,25 @@ void DNSManager::Cleanup(Module *mod) } } -void DNSManager::UpdateSerial() +void Manager::UpdateSerial() { serial = Anope::CurTime; } -uint32_t DNSManager::GetSerial() const +uint32_t Manager::GetSerial() const { return serial; } -DNSQuery DNSManager::BlockingQuery(const Anope::string &mask, QueryType qt) +Query Manager::BlockingQuery(const Anope::string &mask, QueryType qt) { Question question(mask, qt); - DNSQuery result(question); + Query result(question); int type = AF_UNSPEC; - if (qt == DNS_QUERY_A) + if (qt == QUERY_A) type = AF_INET; - else if (qt == DNS_QUERY_AAAA) + else if (qt == QUERY_AAAA) type = AF_INET6; addrinfo hints; diff --git a/src/encrypt.cpp b/src/encrypt.cpp index 154f600bf..0227be2ef 100644 --- a/src/encrypt.cpp +++ b/src/encrypt.cpp @@ -1,4 +1,4 @@ -/* Include file for high-level encryption routines. +/* * * (C) 2003-2012 Anope Team * Contact us at team@anope.org @@ -7,11 +7,11 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" #include "modules.h" -#include "extern.h" /******************************************************************************/ @@ -19,7 +19,7 @@ * @param src The source string * @param dest The destination strnig */ -void enc_encrypt(const Anope::string &src, Anope::string &dest) +void Anope::Encrypt(const Anope::string &src, Anope::string &dest) { EventReturn MOD_RESULT; FOREACH_RESULT(I_OnEncrypt, OnEncrypt(src, dest)); @@ -30,12 +30,12 @@ void enc_encrypt(const Anope::string &src, Anope::string &dest) * @param desc The destination string * @return true on success */ -bool enc_decrypt(const Anope::string &src, Anope::string &dest) +bool Anope::Decrypt(const Anope::string &src, Anope::string &dest) { size_t pos = src.find(':'); if (pos == Anope::string::npos) { - Log() << "Error: enc_decrypt() called with invalid password string (" << src << ")"; + Log() << "Error: Anope::Decrypt() called with invalid password string (" << src << ")"; return false; } Anope::string hashm(src.begin(), src.begin() + pos); diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp index 7ce28df13..2875a52df 100644 --- a/src/hashcomp.cpp +++ b/src/hashcomp.cpp @@ -1,11 +1,10 @@ /* + * * Copyright (C) 2002-2011 InspIRCd Development Team * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. * - * These classes have been copied from InspIRCd and modified - * for use in Anope. */ #include "services.h" @@ -70,11 +69,6 @@ const char *ci::ci_char_traits::find(const char *s1, int n, char c) return n >= 0 ? s1 : NULL; } -/** Compare two Anope::strings as ci::strings and find which one is less - * @param s1 The first string - * @param s2 The second string - * @return true if s1 < s2, else false - */ bool ci::less::operator()(const Anope::string &s1, const Anope::string &s2) const { return s1.ci_str().compare(s2.ci_str()) < 0; @@ -111,6 +105,34 @@ bool sepstream::GetToken(Anope::string &token) return false; } +bool sepstream::GetToken(Anope::string &token, int num) +{ + int i; + for (i = 0; i < num + 1 && !this->GetToken(token); ++i); + return i == num + 1; +} + +int sepstream::NumTokens() +{ + int i; + Anope::string token; + for (i = 0; this->GetToken(token); ++i); + return i; +} + +bool sepstream::GetTokenRemainder(Anope::string &token, int num) +{ + if (this->GetToken(token, num)) + { + if (!this->StreamEnd()) + token += sep + this->GetRemaining(); + + return true; + } + + return false; +} + const Anope::string sepstream::GetRemaining() { return Anope::string(n, tokens.end()); diff --git a/src/init.cpp b/src/init.cpp index 94ac7feb2..e831351ec 100644 --- a/src/init.cpp +++ b/src/init.cpp @@ -7,64 +7,26 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" #include "config.h" -#include "extern.h" #include "users.h" #include "protocol.h" #include "bots.h" -#include "oper.h" +#include "xline.h" #include "signals.h" #include "socketengine.h" #include "servers.h" +#include "language.h" #ifndef _WIN32 #include <sys/wait.h> #include <sys/stat.h> #endif -Anope::string conf_dir = "conf", db_dir = "data", modules_dir = "lib", locale_dir = "locale", log_dir = "logs"; - -ServerConfig::Uplink *uplink_server; - -void introduce_user(const Anope::string &user) -{ - /* Watch out for infinite loops... */ - time_t now = Anope::CurTime; - static time_t lasttime = now - 4; - if (lasttime >= now - 3) - { - quitmsg = "introduce_user loop detected"; - quitting = true; - return; - } - lasttime = now; - - User *u = finduser(user); - if (u) - { - BotInfo *bi = findbot(u->nick); - if (bi) - { - XLine x(bi->nick, "Reserved for services"); - ircdproto->SendSQLine(NULL, &x); - } - - ircdproto->SendClientIntroduction(u); - - if (bi) - { - bi->introduced = true; - - for (UChannelList::const_iterator cit = bi->chans.begin(), cit_end = bi->chans.end(); cit != cit_end; ++cit) - ircdproto->SendJoin(bi, (*cit)->chan, &Config->BotModeList); - } - } -} - -/*************************************************************************/ +Anope::string Anope::ConfigDir = "conf", Anope::DataDir = "data", Anope::ModuleDir = "lib", Anope::LocaleDir = "locale", Anope::LogDir = "logs"; /* Vector of pairs of command line arguments and their params */ static std::vector<std::pair<Anope::string, Anope::string> > CommandLineArguments; @@ -96,24 +58,13 @@ static void ParseCommandLineArguments(int ac, char **av) } } -/** Check if an argument was given on startup - * @param name The argument name - * @param shortname A shorter name, eg --debug and -d - * @return true if name/shortname was found, false if not - */ -bool GetCommandLineArgument(const Anope::string &name, char shortname) -{ - Anope::string Unused; - return GetCommandLineArgument(name, shortname, Unused); -} - /** Check if an argument was given on startup and its parameter * @param name The argument name * @param shortname A shorter name, eg --debug and -d * @param param A string to put the param, if any, of the argument * @return true if name/shortname was found, false if not */ -bool GetCommandLineArgument(const Anope::string &name, char shortname, Anope::string ¶m) +static bool GetCommandLineArgument(const Anope::string &name, char shortname, Anope::string ¶m) { param.clear(); @@ -129,6 +80,17 @@ bool GetCommandLineArgument(const Anope::string &name, char shortname, Anope::st return false; } +/** Check if an argument was given on startup + * @param name The argument name + * @param shortname A shorter name, eg --debug and -d + * @return true if name/shortname was found, false if not + */ +static bool GetCommandLineArgument(const Anope::string &name, char shortname = 0) +{ + Anope::string Unused; + return GetCommandLineArgument(name, shortname, Unused); +} + /*************************************************************************/ /* Remove our PID file. Done at exit. */ @@ -156,7 +118,7 @@ static void write_pidfile() atexit(remove_pidfile); } else - throw FatalException("Can not write to PID file " + Config->PIDFilename); + throw CoreException("Can not write to PID file " + Config->PIDFilename); } /*************************************************************************/ @@ -170,7 +132,7 @@ class SignalReload : public Signal { Log() << "Received SIGHUP: Saving databases & rehashing configuration"; - save_databases(); + Anope::SaveDatabases(); ServerConfig *old_config = Config; try @@ -196,14 +158,13 @@ class SignalExit : public Signal { #ifndef _WIN32 Log() << "Received " << strsignal(this->signal) << " signal (" << this->signal << "), exiting."; - quitmsg = Anope::string("Services terminating via signal ") + strsignal(this->signal) + " (" + stringify(this->signal) + ")"; + Anope::QuitReason = Anope::string("Services terminating via signal ") + strsignal(this->signal) + " (" + stringify(this->signal) + ")"; #else Log() << "Received signal " << this->signal << ", exiting."; - quitmsg = Anope::string("Services terminating via signal ") + stringify(this->signal); + Anope::QuitReason = Anope::string("Services terminating via signal ") + stringify(this->signal); #endif - - quitting = true; - save_databases(); + Anope::SaveDatabases(); + Anope::Quitting = true; } }; @@ -215,12 +176,12 @@ class SignalNothing : public Signal void OnNotify() { } }; -bool AtTerm() +bool Anope::AtTerm() { return isatty(fileno(stdout)) && isatty(fileno(stdin)) && isatty(fileno(stderr)); } -void Fork() +void Anope::Fork() { #ifndef _WIN32 kill(getppid(), SIGUSR2); @@ -240,29 +201,28 @@ static void parent_signal_handler(int signal) { if (signal == SIGUSR2) { - quitting = true; - return_code = 0; + Anope::Quitting = true; } else if (signal == SIGCHLD) { - quitting = true; - return_code = -1; + Anope::ReturnValue = -1; + Anope::Quitting = true; int status = 0; wait(&status); if (WIFEXITED(status)) - return_code = WEXITSTATUS(status); + Anope::ReturnValue = WEXITSTATUS(status); } } #endif -void Init(int ac, char **av) +void Anope::Init(int ac, char **av) { /* Set file creation mask and group ID. */ #if defined(DEFUMASK) && HAVE_UMASK umask(DEFUMASK); #endif - RegisterTypes(); + Serialize::RegisterTypes(); /* Parse command line arguments */ ParseCommandLineArguments(ac, av); @@ -270,14 +230,14 @@ void Init(int ac, char **av) if (GetCommandLineArgument("version", 'v')) { Log(LOG_TERMINAL) << "Anope-" << Anope::Version() << " -- " << Anope::VersionBuildString(); - throw FatalException(); + throw CoreException(); } if (GetCommandLineArgument("help", 'h')) { Log(LOG_TERMINAL) << "Anope-" << Anope::Version() << " -- " << Anope::VersionBuildString(); Log(LOG_TERMINAL) << "Anope IRC Services (http://www.anope.org)"; - Log(LOG_TERMINAL) << "Usage ./" << services_bin << " [options] ..."; + Log(LOG_TERMINAL) << "Usage ./" << Anope::ServicesBin << " [options] ..."; Log(LOG_TERMINAL) << "-c, --config=filename.conf"; Log(LOG_TERMINAL) << " --confdir=conf file direcory"; Log(LOG_TERMINAL) << " --dbdir=database directory"; @@ -296,98 +256,98 @@ void Init(int ac, char **av) Log(LOG_TERMINAL) << ""; Log(LOG_TERMINAL) << "Further support is available from http://www.anope.org"; Log(LOG_TERMINAL) << "Or visit us on IRC at irc.anope.org #anope"; - throw FatalException(); + throw CoreException(); } if (GetCommandLineArgument("nofork", 'n')) - nofork = true; + Anope::NoFork = true; if (GetCommandLineArgument("support", 's')) { - nofork = nothird = true; - ++debug; + Anope::NoFork = Anope::NoThird = true; + ++Anope::Debug; } if (GetCommandLineArgument("readonly", 'r')) - readonly = true; + Anope::ReadOnly = true; if (GetCommandLineArgument("nothird")) - nothird = true; + Anope::NoThird = true; if (GetCommandLineArgument("noexpire", 'e')) - noexpire = true; + Anope::NoExpire = true; if (GetCommandLineArgument("protocoldebug")) - protocoldebug = true; + Anope::ProtocolDebug = true; - Anope::string Arg; - if (GetCommandLineArgument("debug", 'd', Arg)) + Anope::string arg; + if (GetCommandLineArgument("debug", 'd', arg)) { - if (!Arg.empty()) + if (!arg.empty()) { - int level = Arg.is_number_only() ? convertTo<int>(Arg) : -1; + int level = arg.is_number_only() ? convertTo<int>(arg) : -1; if (level > 0) - debug = level; + Anope::Debug = level; else - throw FatalException("Invalid option given to --debug"); + throw CoreException("Invalid option given to --debug"); } else - ++debug; + ++Anope::Debug; } - if (GetCommandLineArgument("config", 'c', Arg)) + if (GetCommandLineArgument("config", 'c', arg)) { - if (Arg.empty()) - throw FatalException("The --config option requires a file name"); - services_conf = ConfigurationFile(Arg, false); + if (arg.empty()) + throw CoreException("The --config option requires a file name"); + ServicesConf = ConfigurationFile(arg, false); } - if (GetCommandLineArgument("confdir", 0, Arg)) + if (GetCommandLineArgument("confdir", 0, arg)) { - if (Arg.empty()) - throw FatalException("The --confdir option requires a path"); - conf_dir = Arg; + if (arg.empty()) + throw CoreException("The --confdir option requires a path"); + Anope::ConfigDir = arg; } - if (GetCommandLineArgument("dbdir", 0, Arg)) + if (GetCommandLineArgument("dbdir", 0, arg)) { - if (Arg.empty()) - throw FatalException("The --dbdir option requires a path"); - db_dir = Arg; + if (arg.empty()) + throw CoreException("The --dbdir option requires a path"); + Anope::DataDir = arg; } - if (GetCommandLineArgument("localedir", 0, Arg)) + if (GetCommandLineArgument("localedir", 0, arg)) { - if (Arg.empty()) - throw FatalException("The --localedir option requires a path"); - locale_dir = Arg; + if (arg.empty()) + throw CoreException("The --localedir option requires a path"); + Anope::LocaleDir = arg; } - if (GetCommandLineArgument("modulesdir", 0, Arg)) + if (GetCommandLineArgument("modulesdir", 0, arg)) { - if (Arg.empty()) - throw FatalException("The --modulesdir option requires a path"); - modules_dir = Arg; + if (arg.empty()) + throw CoreException("The --modulesdir option requires a path"); + Anope::ModuleDir = arg; } - if (GetCommandLineArgument("logdir", 0, Arg)) + if (GetCommandLineArgument("logdir", 0, arg)) { - if (Arg.empty()) - throw FatalException("The --logdir option requires a path"); - log_dir = Arg; + if (arg.empty()) + throw CoreException("The --logdir option requires a path"); + Anope::LogDir = arg; } /* Chdir to Services data directory. */ - if (chdir(services_dir.c_str()) < 0) + if (chdir(Anope::ServicesDir.c_str()) < 0) { - throw FatalException("Unable to chdir to " + services_dir + ": " + Anope::LastError()); + throw CoreException("Unable to chdir to " + Anope::ServicesDir + ": " + Anope::LastError()); } Log(LOG_TERMINAL) << "Anope " << Anope::Version() << ", " << Anope::VersionBuildString(); #ifdef _WIN32 - Log(LOG_TERMINAL) << "Using configuration file " << conf_dir << "\\" << services_conf.GetName(); + Log(LOG_TERMINAL) << "Using configuration file " << Anope::ConfigDir << "\\" << ServicesConf.GetName(); #else - Log(LOG_TERMINAL) << "Using configuration file " << conf_dir << "/" << services_conf.GetName(); + Log(LOG_TERMINAL) << "Using configuration file " << Anope::ConfigDir << "/" << ServicesConf.GetName(); #endif /* Initialize the socket engine */ @@ -405,12 +365,12 @@ void Init(int ac, char **av) Log(LOG_TERMINAL) << "*** documentation. Read the documentation files found in the 'docs'"; Log(LOG_TERMINAL) << "*** folder. Visit our portal located at http://www.anope.org/. Join"; Log(LOG_TERMINAL) << "*** our support channel on /server irc.anope.org channel #anope."; - throw FatalException("Configuration file failed to validate"); + throw CoreException("Configuration file failed to validate"); } #ifdef _WIN32 if (!SupportedWindowsVersion()) - throw FatalException(GetWindowsVersion() + " is not a supported version of Windows"); + throw CoreException(GetWindowsVersion() + " is not a supported version of Windows"); #else /* If we're root, issue a warning now */ if (!getuid() && !getgid()) @@ -421,7 +381,7 @@ void Init(int ac, char **av) sleep(3); } - if (!nofork && AtTerm()) + if (!Anope::NoFork && Anope::AtTerm()) { /* Install these before fork() - it is possible for the child to * connect and kill() the parent before it is able to install the @@ -444,12 +404,12 @@ void Init(int ac, char **av) sigemptyset(&mask); sigsuspend(&mask); - exit(return_code); + exit(Anope::ReturnValue); } else if (i == -1) { Log() << "Error, unable to fork: " << Anope::LastError(); - nofork = true; + Anope::NoFork = true; } /* Child doesn't need these */ @@ -466,11 +426,11 @@ void Init(int ac, char **av) for (botinfo_map::const_iterator it = BotListByNick->begin(), it_end = BotListByNick->end(); it != it_end; ++it) { it->second->server = Me; - ++Me->Users; + ++Me->users; } /* Announce ourselves to the logfile. */ - Log() << "Anope " << Anope::Version() << " starting up" << (debug || readonly ? " (options:" : "") << (debug ? " debug" : "") << (readonly ? " readonly" : "") << (debug || readonly ? ")" : ""); + Log() << "Anope " << Anope::Version() << " starting up" << (Anope::Debug || Anope::ReadOnly ? " (options:" : "") << (Anope::Debug ? " debug" : "") << (Anope::ReadOnly ? " readonly" : "") << (Anope::Debug || Anope::ReadOnly ? ")" : ""); new SignalReload(SIGHUP); new SignalExit(SIGTERM); @@ -478,8 +438,7 @@ void Init(int ac, char **av) new SignalNothing(SIGPIPE); /* Initialize multi-language support */ - Log(LOG_DEBUG) << "Loading Languages..."; - InitLanguages(); + Language::InitLanguages(); /* Initialize random number generator */ srand(Config->Seed); @@ -491,9 +450,9 @@ void Init(int ac, char **av) Module *protocol = ModuleManager::FindFirstOf(PROTOCOL); if (protocol == NULL) - throw FatalException("You must load a protocol module!"); + throw CoreException("You must load a protocol module!"); else if (ModuleManager::FindFirstOf(ENCRYPTION) == NULL) - throw FatalException("You must load at least one encryption module"); + throw CoreException("You must load at least one encryption module"); Log() << "Using IRCd protocol " << protocol->name; diff --git a/src/language.cpp b/src/language.cpp index c62a950aa..1e1f9e704 100644 --- a/src/language.cpp +++ b/src/language.cpp @@ -7,65 +7,71 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" #include "modules.h" #include "commands.h" #include "config.h" -#include "extern.h" +#include "language.h" #if GETTEXT_FOUND # include <libintl.h> #endif -std::vector<Anope::string> languages; -std::vector<Anope::string> domains; +std::vector<Anope::string> Language::Languages; +std::vector<Anope::string> Language::Domains; -void InitLanguages() +void Language::InitLanguages() { #if GETTEXT_FOUND - languages.clear(); + Log(LOG_DEBUG) << "Initializing Languages..."; + + Languages.clear(); spacesepstream sep(Config->Languages); Anope::string language; while (sep.GetToken(language)) { - if (!IsFile(locale_dir + "/" + language + "/LC_MESSAGES/anope.mo")) + if (!IsFile(Anope::LocaleDir + "/" + language + "/LC_MESSAGES/anope.mo")) { Log() << "Error loading language " << language << ", file does not exist!"; } else { Log(LOG_DEBUG) << "Found language file " << language; - languages.push_back(language); + Languages.push_back(language); } } - if (!bindtextdomain("anope", locale_dir.c_str())) + if (!bindtextdomain("anope", Anope::LocaleDir.c_str())) Log() << "Error calling bindtextdomain, " << Anope::LastError(); else - Log(LOG_DEBUG) << "Successfully bound anope to " << locale_dir; + Log(LOG_DEBUG) << "Successfully bound anope to " << Anope::LocaleDir; setlocale(LC_ALL, ""); #else - Log() << "Can not load languages, gettext is not installed"; + Log() << "Unable to initialize languages, gettext is not installed"; #endif } -const char *translate(const char *string) +const char *Language::Translate(const char *string) { - return anope_gettext(Config->NSDefLanguage.c_str(), string); + return Translate(Config->NSDefLanguage.c_str(), string); } -const char *translate(User *u, const char *string) +const char *Language::Translate(User *u, const char *string) { - return translate(u ? u->Account() : NULL, string); + if (u && u->Account()) + return Translate(u->Account(), string); + else + return Translate(string); } -const char *translate(const NickCore *nc, const char *string) +const char *Language::Translate(const NickCore *nc, const char *string) { - return anope_gettext(nc ? nc->language.c_str() : Config->NSDefLanguage.c_str(), string); + return Translate(nc ? nc->language.c_str() : Config->NSDefLanguage.c_str(), string); } #if GETTEXT_FOUND @@ -73,7 +79,7 @@ const char *translate(const NickCore *nc, const char *string) /* Used by gettext to make it always dynamically load language strings (so we can drop them in while Anope is running) */ extern "C" int _nl_msg_cat_cntr; -const char *anope_gettext(const char *lang, const char *string) +const char *Language::Translate(const char *lang, const char *string) { if (!string || !*string || !lang || !*lang) return string ? string : ""; @@ -95,8 +101,8 @@ const char *anope_gettext(const char *lang, const char *string) setlocale(LC_ALL, "en_US"); #endif const char *translated_string = dgettext("anope", string); - for (unsigned i = 0; translated_string == string && i < domains.size(); ++i) - translated_string = dgettext(domains[i].c_str(), string); + for (unsigned i = 0; translated_string == string && i < Domains.size(); ++i) + translated_string = dgettext(Domains[i].c_str(), string); #ifdef _WIN32 SetThreadLocale(MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), SORT_DEFAULT)); #else @@ -108,7 +114,7 @@ const char *anope_gettext(const char *lang, const char *string) return translated_string; } #else -const char *anope_gettext(const char *lang, const char *string) +const char *Language::Translate(const char *lang, const char *string) { return string != NULL ? string : ""; } diff --git a/src/logger.cpp b/src/logger.cpp index a76430435..f6058ab42 100644 --- a/src/logger.cpp +++ b/src/logger.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -15,12 +16,14 @@ #include "channels.h" #include "users.h" #include "logger.h" -#include "extern.h" #include "config.h" #include "bots.h" #include "servers.h" #include "uplink.h" #include "protocol.h" +#include "global.h" +#include "operserv.h" +#include "chanserv.h" #ifndef _WIN32 #include <sys/time.h> @@ -33,9 +36,10 @@ static Anope::string GetTimeStamp() time_t t; if (time(&t) < 0) - throw CoreException("time() failed"); + t = Anope::CurTime; + tm tm = *localtime(&t); - if (debug) + if (Anope::Debug) { char *s; struct timeval tv; @@ -59,7 +63,7 @@ static inline Anope::string CreateLogName(const Anope::string &file, time_t t = strftime(timestamp, sizeof(timestamp), "%Y%m%d", tm); - return log_dir + "/" + file + "." + timestamp; + return Anope::LogDir + "/" + file + "." + timestamp; } LogFile::LogFile(const Anope::string &name) : filename(name), stream(name.c_str(), std::ios_base::out | std::ios_base::app) @@ -71,15 +75,15 @@ Anope::string LogFile::GetName() const return this->filename; } -Log::Log(LogType type, const Anope::string &category, const BotInfo *b) : bi(b), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), Type(type), Category(category) +Log::Log(LogType t, const Anope::string &cat, const BotInfo *b) : bi(b), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), type(t), category(cat) { if (!bi && Config) - bi = findbot(Config->Global); + bi = Global; if (bi) - this->Sources.push_back(bi->nick); + this->sources.push_back(bi->nick); } -Log::Log(LogType type, CommandSource &source, Command *_c, const ChannelInfo *_ci) : nick(source.GetNick()), u(source.GetUser()), nc(source.nc), c(_c), chan(NULL), ci(_ci), s(NULL), m(NULL), Type(type) +Log::Log(LogType t, CommandSource &source, Command *_c, const ChannelInfo *_ci) : nick(source.GetNick()), u(source.GetUser()), nc(source.nc), c(_c), chan(NULL), ci(_ci), s(NULL), m(NULL), type(t) { if (!c) throw CoreException("Invalid pointers passed to Log::Log"); @@ -90,81 +94,80 @@ Log::Log(LogType type, CommandSource &source, Command *_c, const ChannelInfo *_c size_t sl = c->name.find('/'); this->bi = NULL; if (sl != Anope::string::npos) - this->bi = findbot(c->name.substr(0, sl)); + this->bi = BotInfo::Find(c->name.substr(0, sl)); if (this->bi == NULL && Config) - this->bi = findbot(Config->Global); - this->Category = c->name; + this->bi = Global; + this->category = c->name; if (this->bi) - this->Sources.push_back(this->bi->nick); + this->sources.push_back(this->bi->nick); if (u) - this->Sources.push_back(u->nick); - this->Sources.push_back(c->name); + this->sources.push_back(u->nick); + this->sources.push_back(c->name); if (ci) - this->Sources.push_back(ci->name); + this->sources.push_back(ci->name); } -Log::Log(const User *_u, Channel *ch, const Anope::string &category) : bi(NULL), u(_u), nc(NULL), c(NULL), chan(ch), ci(chan ? *chan->ci : NULL), s(NULL), m(NULL), Type(LOG_CHANNEL) +Log::Log(const User *_u, Channel *ch, const Anope::string &cat) : bi(NULL), u(_u), nc(NULL), c(NULL), chan(ch), ci(chan ? *chan->ci : NULL), s(NULL), m(NULL), type(LOG_CHANNEL), category(cat) { if (!chan) throw CoreException("Invalid pointers passed to Log::Log"); if (Config) - this->bi = findbot(Config->ChanServ); - this->Category = category; + this->bi = ChanServ; if (this->bi) - this->Sources.push_back(this->bi->nick); + this->sources.push_back(this->bi->nick); if (u) - this->Sources.push_back(u->nick); - this->Sources.push_back(chan->name); + this->sources.push_back(u->nick); + this->sources.push_back(chan->name); } -Log::Log(const User *_u, const Anope::string &category, const BotInfo *_bi) : bi(_bi), u(_u), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), m(NULL), Type(LOG_USER), Category(category) +Log::Log(const User *_u, const Anope::string &cat, const BotInfo *_bi) : bi(_bi), u(_u), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), m(NULL), type(LOG_USER), category(cat) { if (!u) throw CoreException("Invalid pointers passed to Log::Log"); if (!this->bi && Config) - this->bi = findbot(Config->Global); + this->bi = Global; if (this->bi) - this->Sources.push_back(this->bi->nick); - this->Sources.push_back(u->nick); + this->sources.push_back(this->bi->nick); + this->sources.push_back(u->nick); } -Log::Log(Server *serv, const Anope::string &category, const BotInfo *_bi) : bi(_bi), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(serv), m(NULL), Type(LOG_SERVER), Category(category) +Log::Log(Server *serv, const Anope::string &cat, const BotInfo *_bi) : bi(_bi), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(serv), m(NULL), type(LOG_SERVER), category(cat) { if (!s) throw CoreException("Invalid pointer passed to Log::Log"); if (!this->bi && Config) - this->bi = findbot(Config->OperServ); + this->bi = OperServ; if (!this->bi && Config) - this->bi = findbot(Config->Global); + this->bi = Global; if (this->bi) - this->Sources.push_back(this->bi->nick); - this->Sources.push_back(s->GetName()); + this->sources.push_back(this->bi->nick); + this->sources.push_back(s->GetName()); } -Log::Log(const BotInfo *b, const Anope::string &category) : bi(b), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), m(NULL), Type(LOG_NORMAL), Category(category) +Log::Log(const BotInfo *b, const Anope::string &cat) : bi(b), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), m(NULL), type(LOG_NORMAL), category(cat) { if (!this->bi && Config) - this->bi = findbot(Config->Global); + this->bi = Global; if (this->bi) - this->Sources.push_back(bi->nick); + this->sources.push_back(bi->nick); } -Log::Log(Module *mod, const Anope::string &category) : bi(NULL), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), m(mod), Type(LOG_MODULE), Category(category) +Log::Log(Module *mod, const Anope::string &cat) : bi(NULL), u(NULL), nc(NULL), c(NULL), chan(NULL), ci(NULL), s(NULL), m(mod), type(LOG_MODULE), category(cat) { if (m) - this->Sources.push_back(m->name); + this->sources.push_back(m->name); } Log::~Log() { - if (nofork && debug && this->Type >= LOG_NORMAL && this->Type <= LOG_DEBUG + debug - 1) + if (Anope::NoFork && Anope::Debug && this->type >= LOG_NORMAL && this->type <= LOG_DEBUG + Anope::Debug - 1) std::cout << GetTimeStamp() << " Debug: " << this->BuildPrefix() << this->buf.str() << std::endl; - else if (nofork && this->Type <= LOG_TERMINAL) + else if (Anope::NoFork && this->type <= LOG_TERMINAL) std::cout << GetTimeStamp() << " " << this->BuildPrefix() << this->buf.str() << std::endl; - else if (this->Type == LOG_TERMINAL) + else if (this->type == LOG_TERMINAL) std::cout << this->BuildPrefix() << this->buf.str() << std::endl; for (unsigned i = 0; Config && i < Config->LogInfos.size(); ++i) { @@ -178,7 +181,7 @@ Anope::string Log::BuildPrefix() const { Anope::string buffer; - switch (this->Type) + switch (this->type) { case LOG_ADMIN: { @@ -233,9 +236,9 @@ Anope::string Log::BuildPrefix() const break; buffer += "CHANNEL: "; if (this->u) - buffer += this->u->GetMask() + " " + this->Category + " " + this->chan->name + " "; + buffer += this->u->GetMask() + " " + this->category + " " + this->chan->name + " "; else - buffer += this->Category + " " + this->chan->name + " "; + buffer += this->category + " " + this->chan->name + " "; break; } case LOG_USER: @@ -263,13 +266,13 @@ Anope::string Log::BuildPrefix() const return buffer; } -LogInfo::LogInfo(int logage, bool rawio, bool ldebug) : LogAge(logage), RawIO(rawio), Debug(ldebug) +LogInfo::LogInfo(int la, bool rio, bool ldebug) : log_age(la), raw_io(rio), debug(ldebug) { } LogInfo::~LogInfo() { - for (std::map<Anope::string, LogFile *>::iterator it = this->Logfiles.begin(), it_end = this->Logfiles.end(); it != it_end; ++it) + for (std::map<Anope::string, LogFile *>::iterator it = this->logfiles.begin(), it_end = this->logfiles.end(); it != it_end; ++it) { LogFile *f = it->second; @@ -277,7 +280,7 @@ LogInfo::~LogInfo() f->stream.close(); delete f; } - this->Logfiles.clear(); + this->logfiles.clear(); } void LogInfo::AddType(std::list<Anope::string> &list, const Anope::string &type) @@ -300,29 +303,29 @@ bool LogInfo::HasType(LogType ltype, const Anope::string &type) const switch (ltype) { case LOG_ADMIN: - list = &this->Admin; + list = &this->admin; break; case LOG_OVERRIDE: - list = &this->Override; + list = &this->override; break; case LOG_COMMAND: - list = &this->Commands; + list = &this->commands; break; case LOG_SERVER: - list = &this->Servers; + list = &this->servers; break; case LOG_CHANNEL: - list = &this->Channels; + list = &this->channels; break; case LOG_USER: - list = &this->Users; + list = &this->users; break; case LOG_TERMINAL: return true; case LOG_RAWIO: - return debug ? true : this->RawIO; + return debug ? true : this->raw_io; case LOG_DEBUG: - return debug ? true : this->Debug; + return debug ? true : this->debug; case LOG_DEBUG_2: case LOG_DEBUG_3: case LOG_DEBUG_4: @@ -330,7 +333,7 @@ bool LogInfo::HasType(LogType ltype, const Anope::string &type) const case LOG_MODULE: case LOG_NORMAL: default: - list = &this->Normal; + list = &this->normal; break; } @@ -361,15 +364,15 @@ void LogInfo::ProcessMessage(const Log *l) if (!l) throw CoreException("Bad values passed to LogInfo::ProcessMessages"); - else if (!this->HasType(l->Type, l->Category)) + else if (!this->HasType(l->type, l->category)) return; - if (!this->Sources.empty()) + if (!this->sources.empty()) { bool log = false; - for (std::list<Anope::string>::const_iterator it = this->Sources.begin(), it_end = this->Sources.end(); it != it_end; ++it) + for (std::list<Anope::string>::const_iterator it = this->sources.begin(), it_end = this->sources.end(); it != it_end; ++it) { - if (std::find(l->Sources.begin(), l->Sources.end(), *it) != l->Sources.end()) + if (std::find(l->sources.begin(), l->sources.end(), *it) != l->sources.end()) { log = true; break; @@ -379,45 +382,45 @@ void LogInfo::ProcessMessage(const Log *l) return; } - for (std::list<Anope::string>::iterator it = this->Targets.begin(), it_end = this->Targets.end(); it != it_end; ++it) + for (std::list<Anope::string>::iterator it = this->targets.begin(), it_end = this->targets.end(); it != it_end; ++it) { const Anope::string &target = *it; Anope::string buffer = l->BuildPrefix() + l->buf.str(); if (target[0] == '#') { - if (UplinkSock && l->Type <= LOG_NORMAL && Me && Me->IsSynced()) + if (UplinkSock && l->type <= LOG_NORMAL && Me && Me->IsSynced()) { - Channel *c = findchan(target); + Channel *c = Channel::Find(target); if (!c || !l->bi) continue; - ircdproto->SendPrivmsg(l->bi, c->name, "%s", buffer.c_str()); + IRCD->SendPrivmsg(l->bi, c->name, "%s", buffer.c_str()); } } else if (target == "globops") { - if (UplinkSock && l->bi && l->Type <= LOG_NORMAL && Me && Me->IsSynced()) + if (UplinkSock && l->bi && l->type <= LOG_NORMAL && Me && Me->IsSynced()) { - ircdproto->SendGlobops(l->bi, "%s", buffer.c_str()); + IRCD->SendGlobops(l->bi, "%s", buffer.c_str()); } } else { LogFile *log = NULL; - std::map<Anope::string, LogFile *>::iterator lit = this->Logfiles.find(target); - if (lit != this->Logfiles.end()) + std::map<Anope::string, LogFile *>::iterator lit = this->logfiles.find(target); + if (lit != this->logfiles.end()) { log = lit->second; if (log && log->GetName() != CreateLogName(target)) { delete log; - this->Logfiles.erase(lit); + this->logfiles.erase(lit); log = new LogFile(CreateLogName(target)); - this->Logfiles[target] = log; + this->logfiles[target] = log; - if (this->LogAge) + if (this->log_age) { - Anope::string oldlog = CreateLogName(target, Anope::CurTime - 86400 * this->LogAge); + Anope::string oldlog = CreateLogName(target, Anope::CurTime - 86400 * this->log_age); if (IsFile(oldlog)) { unlink(oldlog.c_str()); @@ -433,11 +436,11 @@ void LogInfo::ProcessMessage(const Log *l) Log() << "Unable to open logfile " << log->GetName(); } delete log; - this->Logfiles.erase(lit); + this->logfiles.erase(lit); log = NULL; } } - else if (lit == this->Logfiles.end()) + else if (lit == this->logfiles.end()) { log = new LogFile(CreateLogName(target)); @@ -452,7 +455,7 @@ void LogInfo::ProcessMessage(const Log *l) log = NULL; } else - this->Logfiles[target] = log; + this->logfiles[target] = log; } if (log) diff --git a/src/mail.cpp b/src/mail.cpp index 152d525f5..030922f5c 100644 --- a/src/mail.cpp +++ b/src/mail.cpp @@ -7,28 +7,28 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ - #include "services.h" #include "mail.h" #include "config.h" -MailThread::MailThread(const Anope::string &smpath, const Anope::string &sf, const Anope::string &mailto, const Anope::string &addr, const Anope::string &subject, const Anope::string &message) : Thread(), SendMailPath(smpath), SendFrom(sf), MailTo(mailto), Addr(addr), Subject(subject), Message(message), DontQuoteAddresses(Config->DontQuoteAddresses), Success(false) +Mail::Message::Message(const Anope::string &sf, const Anope::string &mailto, const Anope::string &a, const Anope::string &s, const Anope::string &m) : Thread(), sendmail_path(Config->SendMailPath), send_from(sf), mail_to(mailto), addr(a), subject(s), message(m), dont_quote_addresses(Config->DontQuoteAddresses), success(false) { } -MailThread::~MailThread() +Mail::Message::~Message() { - if (Success) - Log(LOG_NORMAL, "mail") << "Successfully delivered mail for " << MailTo << " (" << Addr << ")"; + if (success) + Log(LOG_NORMAL, "mail") << "Successfully delivered mail for " << mail_to << " (" << addr << ")"; else - Log(LOG_NORMAL, "mail") << "Error delivering mail for " << MailTo << " (" << Addr << ")"; + Log(LOG_NORMAL, "mail") << "Error delivering mail for " << mail_to << " (" << addr << ")"; } -void MailThread::Run() +void Mail::Message::Run() { - FILE *pipe = popen(SendMailPath.c_str(), "w"); + FILE *pipe = popen(sendmail_path.c_str(), "w"); if (!pipe) { @@ -36,22 +36,22 @@ void MailThread::Run() return; } - fprintf(pipe, "From: %s\n", SendFrom.c_str()); - if (this->DontQuoteAddresses) - fprintf(pipe, "To: %s <%s>\n", MailTo.c_str(), Addr.c_str()); + fprintf(pipe, "From: %s\n", send_from.c_str()); + if (this->dont_quote_addresses) + fprintf(pipe, "To: %s <%s>\n", mail_to.c_str(), addr.c_str()); else - fprintf(pipe, "To: \"%s\" <%s>\n", MailTo.c_str(), Addr.c_str()); - fprintf(pipe, "Subject: %s\n", Subject.c_str()); - fprintf(pipe, "%s", Message.c_str()); + fprintf(pipe, "To: \"%s\" <%s>\n", mail_to.c_str(), addr.c_str()); + fprintf(pipe, "Subject: %s\n", subject.c_str()); + fprintf(pipe, "%s", message.c_str()); fprintf(pipe, "\n.\n"); pclose(pipe); - Success = true; + success = true; SetExitState(); } -bool Mail(User *u, NickCore *nc, const BotInfo *service, const Anope::string &subject, const Anope::string &message) +bool Mail::Send(User *u, NickCore *nc, const BotInfo *service, const Anope::string &subject, const Anope::string &message) { if (!nc || !service || subject.empty() || message.empty()) return false; @@ -64,7 +64,7 @@ bool Mail(User *u, NickCore *nc, const BotInfo *service, const Anope::string &su return false; nc->lastmail = Anope::CurTime; - Thread *t = new MailThread(Config->SendMailPath, Config->SendFrom, nc->display, nc->email, subject, message); + Thread *t = new Mail::Message(Config->SendFrom, nc->display, nc->email, subject, message); t->Start(); return true; } @@ -79,7 +79,7 @@ bool Mail(User *u, NickCore *nc, const BotInfo *service, const Anope::string &su else { u->lastmail = nc->lastmail = Anope::CurTime; - Thread *t = new MailThread(Config->SendMailPath, Config->SendFrom, nc->display, nc->email, subject, message); + Thread *t = new Mail::Message(Config->SendFrom, nc->display, nc->email, subject, message); t->Start(); return true; } @@ -88,13 +88,13 @@ bool Mail(User *u, NickCore *nc, const BotInfo *service, const Anope::string &su } } -bool Mail(NickCore *nc, const Anope::string &subject, const Anope::string &message) +bool Mail::Send(NickCore *nc, const Anope::string &subject, const Anope::string &message) { if (!Config->UseMail || !nc || nc->email.empty() || subject.empty() || message.empty()) return false; nc->lastmail = Anope::CurTime; - Thread *t = new MailThread(Config->SendMailPath, Config->SendFrom, nc->display, nc->email, subject, message); + Thread *t = new Mail::Message(Config->SendFrom, nc->display, nc->email, subject, message); t->Start(); return true; @@ -109,7 +109,7 @@ bool Mail(NickCore *nc, const Anope::string &subject, const Anope::string &messa * @param email Email to Validate * @return bool */ -bool MailValidate(const Anope::string &email) +bool Mail::Validate(const Anope::string &email) { bool has_period = false; diff --git a/src/main.cpp b/src/main.cpp index 2cbacbb0f..82cd1af90 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -8,32 +8,15 @@ * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. * - * This program 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; either version 2 of the License, or - * (at your option) any later version. - * - * 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 (see the file COPYING); if not, write to the - * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "services.h" #include "timers.h" -#include "extern.h" -#include "uplink.h" #include "config.h" -#include "protocol.h" -#include "servers.h" #include "bots.h" -#include "dns.h" #include "signals.h" #include "socketengine.h" +#include "uplink.h" #ifndef _WIN32 #include <limits.h> @@ -41,37 +24,23 @@ #include <process.h> #endif -/******** Global variables! ********/ - -/* Command-line options: (note that configuration variables are in config.c) */ -Anope::string services_dir; /* -dir dirname */ -Anope::string services_bin; /* Binary as specified by the user */ -Anope::string binary_dir; /* Used to store base path for Anope */ -int debug = 0; /* -debug */ -bool readonly = false; /* -readonly */ -bool nofork = false; /* -nofork */ -bool nothird = false; /* -nothrid */ -bool noexpire = false; /* -noexpire */ -bool protocoldebug = false; /* -protocoldebug */ - -/* Set to 1 if we are to quit */ -bool quitting = false; -int return_code = 0; - -/* Set to true if we are restarting */ -bool restarting = false; +/* Command-line options: */ +int Anope::Debug = 0; +bool Anope::ReadOnly = false, Anope::NoFork = false, Anope::NoThird = false, Anope::NoExpire = false, Anope::ProtocolDebug = false; +Anope::string Anope::ServicesDir; +Anope::string Anope::ServicesBin; -/* Contains a message as to why services is terminating */ -Anope::string quitmsg; +int Anope::ReturnValue = 0; +bool Anope::Quitting = false; +bool Anope::Restarting = false; +Anope::string Anope::QuitReason; -/* At what time were we started? */ -time_t start_time = time(NULL); +static Anope::string BinaryDir; /* Full path to services bin directory */ +time_t Anope::StartTime = time(NULL); time_t Anope::CurTime = time(NULL); -/******** Local variables! ********/ - -/*************************************************************************/ +int Anope::CurrentUplink = -1; class UpdateTimer : public Timer { @@ -80,202 +49,13 @@ class UpdateTimer : public Timer void Tick(time_t) { - save_databases(); - } -}; - -UplinkSocket *UplinkSock = NULL; -int CurrentUplink = -1; - -static void Connect(); - -class ReconnectTimer : public Timer -{ - public: - ReconnectTimer(int wait) : Timer(wait) { } - - void Tick(time_t) - { - try - { - Connect(); - } - catch (const SocketException &ex) - { - Log(LOG_TERMINAL) << "Unable to connect to uplink #" << (CurrentUplink + 1) << " (" << Config->Uplinks[CurrentUplink]->host << ":" << Config->Uplinks[CurrentUplink]->port << "): " << ex.GetReason(); - } + Anope::SaveDatabases(); } }; -UplinkSocket::UplinkSocket() : Socket(-1, Config->Uplinks[CurrentUplink]->ipv6), ConnectionSocket(), BufferedSocket() -{ - UplinkSock = this; -} - -UplinkSocket::~UplinkSocket() +void Anope::SaveDatabases() { - if (ircdproto && Me && !Me->GetLinks().empty() && Me->GetLinks()[0]->IsSynced()) - { - FOREACH_MOD(I_OnServerDisconnect, OnServerDisconnect()); - - for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) - { - User *u = it->second; - - if (u->server == Me) - { - /* Don't use quitmsg here, it may contain information you don't want people to see */ - ircdproto->SendQuit(u, "Shutting down"); - BotInfo* bi = findbot(u->nick); - if (bi != NULL) - bi->introduced = false; - } - } - - ircdproto->SendSquit(Me, quitmsg); - - this->ProcessWrite(); // Write out the last bit - } - - for (unsigned i = Me->GetLinks().size(); i > 0; --i) - if (!Me->GetLinks()[i - 1]->HasFlag(SERVER_JUPED)) - Me->GetLinks()[i - 1]->Delete(Me->GetName() + " " + Me->GetLinks()[i - 1]->GetName()); - - UplinkSock = NULL; - - Me->SetFlag(SERVER_SYNCING); - - if (AtTerm()) - { - if (static_cast<unsigned>(CurrentUplink + 1) == Config->Uplinks.size()) - { - quitting = true; - quitmsg = "Unable to connect to any uplink"; - return_code = -1; - } - else - { - new ReconnectTimer(1); - } - } - else if (!quitting) - { - int Retry = Config->RetryWait; - if (Retry <= 0) - Retry = 60; - - Log() << "Disconnected, retrying in " << Retry << " seconds"; - new ReconnectTimer(Retry); - } -} - -bool UplinkSocket::Read(const Anope::string &buf) -{ - process(buf); - return true; -} - -void UplinkSocket::OnConnect() -{ - Log(LOG_TERMINAL) << "Successfully connected to uplink #" << (CurrentUplink + 1) << " " << Config->Uplinks[CurrentUplink]->host << ":" << Config->Uplinks[CurrentUplink]->port; - ircdproto->SendConnect(); - FOREACH_MOD(I_OnServerConnect, OnServerConnect()); -} - -void UplinkSocket::OnError(const Anope::string &error) -{ - Log(LOG_TERMINAL) << "Unable to connect to uplink #" << (CurrentUplink + 1) << " (" << Config->Uplinks[CurrentUplink]->host << ":" << Config->Uplinks[CurrentUplink]->port << ")" << (!error.empty() ? (": " + error) : ""); -} - -UplinkSocket::Message::Message() : server(NULL), user(NULL) -{ -} - -UplinkSocket::Message::Message(const Server *s) : server(s), user(NULL) -{ -} - -UplinkSocket::Message::Message(const User *u) : server(NULL), user(u) -{ - if (!u) - server = Me; -} - -UplinkSocket::Message::~Message() -{ - Anope::string message_source = ""; - - if (this->server != NULL) - { - if (this->server != Me && !this->server->HasFlag(SERVER_JUPED)) - { - Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" from " << this->server->GetName() << " who is not from me?"; - return; - } - - message_source = this->server->GetSID(); - } - else if (this->user != NULL) - { - if (this->user->server != Me && !this->user->server->HasFlag(SERVER_JUPED)) - { - Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" from " << this->user->nick << " who is not from me?"; - return; - } - - const BotInfo *bi = findbot(this->user->nick); - if (bi != NULL && bi->introduced == false) - { - Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" from " << bi->nick << " when not introduced"; - return; - } - - message_source = this->user->GetUID(); - } - - if (!UplinkSock) - { - if (!message_source.empty()) - Log(LOG_DEBUG) << "Attempted to send \"" << message_source << " " << this->buffer.str() << "\" with UplinkSock NULL"; - else - Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" with UplinkSock NULL"; - return; - } - - if (!message_source.empty()) - { - UplinkSock->Write(":" + message_source + " " + this->buffer.str()); - Log(LOG_RAWIO) << "Sent: :" << message_source << " " << this->buffer.str(); - } - else - { - UplinkSock->Write(this->buffer.str()); - Log(LOG_RAWIO) << "Sent: " << this->buffer.str(); - } -} - -static void Connect() -{ - if (static_cast<unsigned>(++CurrentUplink) >= Config->Uplinks.size()) - CurrentUplink = 0; - - ServerConfig::Uplink *u = Config->Uplinks[CurrentUplink]; - - new UplinkSocket(); - if (!Config->LocalHost.empty()) - UplinkSock->Bind(Config->LocalHost); - FOREACH_MOD(I_OnPreServerConnect, OnPreServerConnect()); - DNSQuery rep = DNSManager::BlockingQuery(u->host, u->ipv6 ? DNS_QUERY_AAAA : DNS_QUERY_A); - Anope::string reply_ip = !rep.answers.empty() ? rep.answers.front().rdata : u->host; - Log(LOG_TERMINAL) << "Attempting to connect to uplink #" << (CurrentUplink + 1) << " " << u->host << " (" << reply_ip << "), port " << u->port; - UplinkSock->Connect(reply_ip, u->port); -} - -/*************************************************************************/ - -void save_databases() -{ - if (readonly) + if (Anope::ReadOnly) return; EventReturn MOD_RESULT; @@ -283,8 +63,6 @@ void save_databases() Log(LOG_DEBUG) << "Saving databases"; } -/*************************************************************************/ - std::vector<Signal *> Signal::SignalHandlers; void Signal::SignalHandler(int signal) @@ -321,7 +99,7 @@ Signal::~Signal() /** The following comes from InspIRCd to get the full path of the Anope executable */ -Anope::string GetFullProgDir(const Anope::string &argv0) +static Anope::string GetFullProgDir(const Anope::string &argv0) { char buffer[PATH_MAX]; #ifdef _WIN32 @@ -333,7 +111,7 @@ Anope::string GetFullProgDir(const Anope::string &argv0) { Anope::string fullpath = buffer; Anope::string::size_type n = fullpath.rfind("\\"); - services_bin = fullpath.substr(n + 1, fullpath.length()); + Anope::ServicesBin = fullpath.substr(n + 1, fullpath.length()); return fullpath.substr(0, n); } #else @@ -342,14 +120,14 @@ Anope::string GetFullProgDir(const Anope::string &argv0) { Anope::string remainder = argv0; - services_bin = remainder; - Anope::string::size_type n = services_bin.rfind("/"); + Anope::ServicesBin = remainder; + Anope::string::size_type n = Anope::ServicesBin.rfind("/"); Anope::string fullpath; - if (services_bin[0] == '/') - fullpath = services_bin.substr(0, n); + if (Anope::ServicesBin[0] == '/') + fullpath = Anope::ServicesBin.substr(0, n); else - fullpath = Anope::string(buffer) + "/" + services_bin.substr(0, n); - services_bin = services_bin.substr(n + 1, remainder.length()); + fullpath = Anope::string(buffer) + "/" + Anope::ServicesBin.substr(0, n); + Anope::ServicesBin = Anope::ServicesBin.substr(n + 1, remainder.length()); return fullpath; } #endif @@ -362,16 +140,16 @@ Anope::string GetFullProgDir(const Anope::string &argv0) int main(int ac, char **av, char **envp) { - binary_dir = GetFullProgDir(av[0]); - if (binary_dir[binary_dir.length() - 1] == '.') - binary_dir = binary_dir.substr(0, binary_dir.length() - 2); + BinaryDir = GetFullProgDir(av[0]); + if (BinaryDir[BinaryDir.length() - 1] == '.') + BinaryDir = BinaryDir.substr(0, BinaryDir.length() - 2); #ifdef _WIN32 - Anope::string::size_type n = binary_dir.rfind('\\'); + Anope::string::size_type n = BinaryDir.rfind('\\'); #else - Anope::string::size_type n = binary_dir.rfind('/'); + Anope::string::size_type n = BinaryDir.rfind('/'); #endif - services_dir = binary_dir.substr(0, n); + Anope::ServicesDir = BinaryDir.substr(0, n); /* Clean out the module runtime directory prior to running, just in case files were left behind during a previous run */ ModuleManager::CleanupRuntimeDirectory(); @@ -383,9 +161,9 @@ int main(int ac, char **av, char **envp) try { /* General initialization first */ - Init(ac, av); + Anope::Init(ac, av); } - catch (const FatalException &ex) + catch (const CoreException &ex) { Log() << ex.GetReason(); return -1; @@ -393,11 +171,11 @@ int main(int ac, char **av, char **envp) try { - Connect(); + Uplink::Connect(); } catch (const SocketException &ex) { - Log(LOG_TERMINAL) << "Unable to connect to uplink #" << CurrentUplink << " (" << Config->Uplinks[CurrentUplink]->host << ":" << Config->Uplinks[CurrentUplink]->port << "): " << ex.GetReason(); + Log(LOG_TERMINAL) << "Unable to connect to uplink #" << Anope::CurrentUplink << " (" << Config->Uplinks[Anope::CurrentUplink]->host << ":" << Config->Uplinks[Anope::CurrentUplink]->port << "): " << ex.GetReason(); } /* Set up timers */ @@ -405,7 +183,7 @@ int main(int ac, char **av, char **envp) UpdateTimer updateTimer(Config->UpdateTimeout); /*** Main loop. ***/ - while (!quitting) + while (!Anope::Quitting) { Log(LOG_DEBUG_2) << "Top of main loop"; @@ -420,7 +198,7 @@ int main(int ac, char **av, char **envp) SocketEngine::Process(); } - if (restarting) + if (Anope::Restarting) { FOREACH_MOD(I_OnRestart, OnRestart()); } @@ -429,9 +207,9 @@ int main(int ac, char **av, char **envp) FOREACH_MOD(I_OnShutdown, OnShutdown()); } - if (quitmsg.empty()) - quitmsg = "Terminating, reason unknown"; - Log() << quitmsg; + if (Anope::QuitReason.empty()) + Anope::QuitReason = "Terminating, reason unknown"; + Log() << Anope::QuitReason; delete UplinkSock; @@ -446,14 +224,15 @@ int main(int ac, char **av, char **envp) OnShutdown(); #endif - if (restarting) + if (Anope::Restarting) { - chdir(binary_dir.c_str()); - av[0] = const_cast<char *>(("./" + services_bin).c_str()); - execve(services_bin.c_str(), av, envp); + chdir(BinaryDir.c_str()); + Anope::string sbin = "./" + Anope::ServicesBin; + av[0] = const_cast<char *>(sbin.c_str()); + execve(Anope::ServicesBin.c_str(), av, envp); Log() << "Restart failed"; - return_code = -1; + Anope::ReturnValue = -1; } - return return_code; + return Anope::ReturnValue; } diff --git a/src/memoserv.cpp b/src/memos.cpp index 13d4d04d6..2b221b03a 100644 --- a/src/memoserv.cpp +++ b/src/memos.cpp @@ -7,9 +7,9 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ - #include "services.h" #include "modules.h" #include "service.h" @@ -19,14 +19,17 @@ #include "account.h" #include "regchannel.h" -Memo::Memo() : Flags<MemoFlag>(MemoFlagStrings), Serializable("Memo") { } +static const Anope::string MemoFlagString[] = { "MF_UNREAD", "MF_RECEIPT", "" }; +template<> const Anope::string* Flags<MemoFlag>::flags_strings = MemoFlagString; + +Memo::Memo() : Serializable("Memo") { } -Serialize::Data Memo::serialize() const +Serialize::Data Memo::Serialize() const { Serialize::Data data; data["owner"] << this->owner; - data["time"].setType(Serialize::DT_INT) << this->time; + data["time"].SetType(Serialize::DT_INT) << this->time; data["sender"] << this->sender; data["text"] << this->text; data["flags"] << this->ToString(); @@ -34,13 +37,13 @@ Serialize::Data Memo::serialize() const return data; } -Serializable* Memo::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* Memo::Unserialize(Serializable *obj, Serialize::Data &data) { - if (!memoserv) + if (!MemoServService) return NULL; bool ischan; - MemoInfo *mi = memoserv->GetMemoInfo(data["owner"].astr(), ischan); + MemoInfo *mi = MemoServService->GetMemoInfo(data["owner"].astr(), ischan); if (!mi) return NULL; @@ -85,7 +88,7 @@ void MemoInfo::Del(unsigned index) { if (index >= this->memos->size()) return; - this->GetMemo(index)->destroy(); + this->GetMemo(index)->Destroy(); this->memos->erase(this->memos->begin() + index); } @@ -95,7 +98,7 @@ void MemoInfo::Del(Memo *memo) if (it != this->memos->end()) { - memo->destroy(); + memo->Destroy(); this->memos->erase(it); } } diff --git a/src/messages.cpp b/src/messages.cpp index 774816e44..62170e24e 100644 --- a/src/messages.cpp +++ b/src/messages.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -14,43 +15,45 @@ #include "users.h" #include "protocol.h" #include "config.h" -#include "extern.h" #include "uplink.h" #include "opertype.h" #include "messages.h" #include "servers.h" #include "channels.h" -bool CoreIRCDMessageAway::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +using namespace Message; + +bool Away::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { FOREACH_MOD(I_OnUserAway, OnUserAway(source.GetUser(), params.empty() ? "" : params[0])); return true; } -bool CoreIRCDMessageCapab::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Capab::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { if (params.size() == 1) { spacesepstream sep(params[0]); Anope::string token; while (sep.GetToken(token)) - Capab.insert(token); + Servers::Capab.insert(token); } else for (unsigned i = 0; i < params.size(); ++i) - Capab.insert(params[i]); + Servers::Capab.insert(params[i]); return true; } -bool CoreIRCDMessageError::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Error::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { Log(LOG_TERMINAL) << "ERROR: " << params[0]; - quitmsg = "Received ERROR from uplink: " + params[0]; + Anope::QuitReason = "Received ERROR from uplink: " + params[0]; + Anope::Quitting = true; return true; } -bool CoreIRCDMessageJoin::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Join::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { User *user = source.GetUser(); const Anope::string &channels = params[0]; @@ -70,46 +73,94 @@ bool CoreIRCDMessageJoin::Run(MessageSource &source, const std::vector<Anope::st Anope::string channame = cc->chan->name; FOREACH_MOD(I_OnPrePartChannel, OnPrePartChannel(user, cc->chan)); cc->chan->DeleteUser(user); - FOREACH_MOD(I_OnPartChannel, OnPartChannel(user, findchan(channame), channame, "")); + FOREACH_MOD(I_OnPartChannel, OnPartChannel(user, Channel::Find(channame), channame, "")); } user->chans.clear(); continue; } - Channel *chan = findchan(channel); - /* Channel doesn't exist, create it */ - if (!chan) - chan = new Channel(channel, Anope::CurTime); + std::list<SJoinUser> users; + users.push_back(std::make_pair(ChannelStatus(), user)); + + Channel *chan = Channel::Find(channel); + SJoin(source, channel, chan ? chan->creation_time : Anope::CurTime, "", users); + } + + return true; +} + +void Join::SJoin(MessageSource &source, const Anope::string &chan, time_t ts, const Anope::string &modes, const std::list<SJoinUser> &users) +{ + Channel *c = Channel::Find(chan); + bool keep_their_modes = true; + + if (!c) + { + c = new Channel(chan, ts ? ts : Anope::CurTime); + c->SetFlag(CH_SYNCING); + } + /* Some IRCds do not include a TS */ + else if (!ts) + ; + /* Our creation time is newer than what the server gave us, so reset the channel to the older time */ + else if (c->creation_time > ts) + { + c->creation_time = ts; + c->Reset(); + } + /* Their TS is newer, don't accept any modes from them */ + else if (ts > c->creation_time) + keep_their_modes = false; + + /* Update the modes for the channel */ + if (keep_their_modes && !modes.empty()) + c->SetModesInternal(source, modes); + + for (std::list<SJoinUser>::const_iterator it = users.begin(), it_end = users.end(); it != it_end; ++it) + { + const ChannelStatus &status = it->first; + User *u = it->second; EventReturn MOD_RESULT; - FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(user, chan)); + FOREACH_RESULT(I_OnPreJoinChannel, OnPreJoinChannel(u, c)); + + /* Add the user to the channel */ + UserContainer *cc = c->JoinUser(u); - /* Join the user to the channel */ - chan->JoinUser(user); - /* Set the proper modes on the user */ - chan_set_correct_modes(user, chan, 1, true); + /* Update their status internally on the channel */ + *cc->status = status; - /* Modules may want to allow this user in the channel, check. - * If not, CheckKick will kick/ban them, don't call OnJoinChannel after this as the user will have - * been destroyed + /* Set whatever modes the user should have, and remove any that + * they aren't allowed to have (secureops etc). */ - if (MOD_RESULT != EVENT_STOP && chan && chan->ci && chan->ci->CheckKick(user)) + c->SetCorrectModes(u, true, true); + + /* Check to see if modules want the user to join, if they do + * check to see if they are allowed to join (CheckKick will kick/ban them + * if they aren't). + */ + if (MOD_RESULT != EVENT_STOP && c->ci && c->ci->CheckKick(u)) continue; - FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(user, chan)); + FOREACH_MOD(I_OnJoinChannel, OnJoinChannel(u, c)); } - return true; + /* Channel is done syncing */ + if (c->HasFlag(CH_SYNCING)) + { + c->UnsetFlag(CH_SYNCING); + /* Sync the channel (mode lock, topic, etc) */ + c->Sync(); + } } - -bool CoreIRCDMessageKick::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Kick::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { const Anope::string &channel = params[0]; const Anope::string &users = params[1]; const Anope::string &reason = params.size() > 2 ? params[2] : ""; - Channel *c = findchan(channel); + Channel *c = Channel::Find(channel); if (!c) return true; @@ -121,9 +172,9 @@ bool CoreIRCDMessageKick::Run(MessageSource &source, const std::vector<Anope::st return true; } -bool CoreIRCDMessageKill::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Kill::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); BotInfo *bi; if (!u) @@ -132,9 +183,22 @@ bool CoreIRCDMessageKill::Run(MessageSource &source, const std::vector<Anope::st /* Recover if someone kills us. */ if (u->server == Me && (bi = dynamic_cast<BotInfo *>(u))) { + static time_t last_time = 0; + + if (last_time == Anope::CurTime) + { + Anope::QuitReason = "Kill loop detected. Are Services U:Lined?"; + Anope::Quitting = true; + return true; + } + last_time = Anope::CurTime; + bi->introduced = false; - introduce_user(bi->nick); - bi->RejoinAll(); + IRCD->SendClientIntroduction(bi); + bi->introduced = true; + + for (UChannelList::const_iterator cit = bi->chans.begin(), cit_end = bi->chans.end(); cit != cit_end; ++cit) + IRCD->SendJoin(bi, (*cit)->chan, (*cit)->status); } else u->KillInternal(source.GetSource(), params[1]); @@ -142,8 +206,28 @@ bool CoreIRCDMessageKill::Run(MessageSource &source, const std::vector<Anope::st return true; } +bool Message::Mode::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +{ + if (IRCD->IsChannelValid(params[0])) + { + Channel *c = Channel::Find(params[0]); + + if (c) + c->SetModesInternal(source, params[2], 0); + } + else + { + User *u = User::Find(params[0]); + + if (u) + u->SetModesInternal("%s", params[1].c_str()); + } + + return true; +} + /* XXX We should cache the file somewhere not open/read/close it on every request */ -bool CoreIRCDMessageMOTD::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool MOTD::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { Server *s = Server::Find(params[0]); if (s != Me) @@ -152,23 +236,23 @@ bool CoreIRCDMessageMOTD::Run(MessageSource &source, const std::vector<Anope::st FILE *f = fopen(Config->MOTDFilename.c_str(), "r"); if (f) { - ircdproto->SendNumeric(375, source.GetSource(), ":- %s Message of the Day", Config->ServerName.c_str()); + IRCD->SendNumeric(375, source.GetSource(), ":- %s Message of the Day", Config->ServerName.c_str()); char buf[BUFSIZE]; while (fgets(buf, sizeof(buf), f)) { buf[strlen(buf) - 1] = 0; - ircdproto->SendNumeric(372, source.GetSource(), ":- %s", buf); + IRCD->SendNumeric(372, source.GetSource(), ":- %s", buf); } fclose(f); - ircdproto->SendNumeric(376, source.GetSource(), ":End of /MOTD command."); + IRCD->SendNumeric(376, source.GetSource(), ":End of /MOTD command."); } else - ircdproto->SendNumeric(422, source.GetSource(), ":- MOTD file not found! Please contact your IRC administrator."); + IRCD->SendNumeric(422, source.GetSource(), ":- MOTD file not found! Please contact your IRC administrator."); return true; } -bool CoreIRCDMessagePart::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Part::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { User *u = source.GetUser(); const Anope::string &reason = params.size() > 1 ? params[1] : ""; @@ -178,7 +262,7 @@ bool CoreIRCDMessagePart::Run(MessageSource &source, const std::vector<Anope::st while (sep.GetToken(channel)) { - dynamic_reference<Channel> c = findchan(channel); + Reference<Channel> c = Channel::Find(channel); if (!c || !u->FindChannel(c)) continue; @@ -193,22 +277,22 @@ bool CoreIRCDMessagePart::Run(MessageSource &source, const std::vector<Anope::st return true; } -bool CoreIRCDMessagePing::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Ping::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { - ircdproto->SendPong(params.size() > 1 ? params[1] : Me->GetSID(), params[0]); + IRCD->SendPong(params.size() > 1 ? params[1] : Me->GetSID(), params[0]); return true; } -bool CoreIRCDMessagePrivmsg::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Privmsg::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { const Anope::string &receiver = params[0]; Anope::string message = params[1]; User *u = source.GetUser(); - if (ircdproto->IsChannelValid(receiver)) + if (IRCD->IsChannelValid(receiver)) { - Channel *c = findchan(receiver); + Channel *c = Channel::Find(receiver); if (c) { FOREACH_MOD(I_OnPrivmsg, OnPrivmsg(u, c, message)); @@ -229,7 +313,7 @@ bool CoreIRCDMessagePrivmsg::Run(MessageSource &source, const std::vector<Anope: } else if (Config->UseStrictPrivMsg) { - const BotInfo *bi = findbot(receiver); + const BotInfo *bi = BotInfo::Find(receiver); if (!bi) return true; Log(LOG_DEBUG) << "Ignored PRIVMSG without @ from " << u->nick; @@ -237,7 +321,7 @@ bool CoreIRCDMessagePrivmsg::Run(MessageSource &source, const std::vector<Anope: return true; } - BotInfo *bi = findbot(botname); + BotInfo *bi = BotInfo::Find(botname); if (bi) { @@ -253,12 +337,12 @@ bool CoreIRCDMessagePrivmsg::Run(MessageSource &source, const std::vector<Anope: Anope::string buf = message; buf.erase(buf.begin()); buf.erase(buf.end() - 1); - ircdproto->SendCTCP(bi, u->nick, "%s", buf.c_str()); + IRCD->SendCTCP(bi, u->nick, "%s", buf.c_str()); } else if (message.substr(0, 9).equals_ci("\1VERSION\1")) { Module *enc = ModuleManager::FindFirstOf(ENCRYPTION); - ircdproto->SendCTCP(bi, u->nick, "VERSION Anope-%s %s :%s - (%s) -- %s", Anope::Version().c_str(), Config->ServerName.c_str(), ircdproto->GetProtocolName().c_str(), enc ? enc->name.c_str() : "unknown", Anope::VersionBuildString().c_str()); + IRCD->SendCTCP(bi, u->nick, "VERSION Anope-%s %s :%s - (%s) -- %s", Anope::Version().c_str(), Config->ServerName.c_str(), IRCD->GetProtocolName().c_str(), enc ? enc->name.c_str() : "unknown", Anope::VersionBuildString().c_str()); } return true; } @@ -270,14 +354,14 @@ bool CoreIRCDMessagePrivmsg::Run(MessageSource &source, const std::vector<Anope: return true; } -bool CoreIRCDMessageQuit::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Quit::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { const Anope::string &reason = params[0]; User *user = source.GetUser(); Log(user, "quit") << "quit (Reason: " << (!reason.empty() ? reason : "no reason") << ")"; - NickAlias *na = findnick(user->nick); + NickAlias *na = NickAlias::Find(user->nick); if (na && !na->nc->HasFlag(NI_SUSPENDED) && (user->IsRecognized() || user->IsIdentified(true))) { na->last_seen = Anope::CurTime; @@ -289,7 +373,7 @@ bool CoreIRCDMessageQuit::Run(MessageSource &source, const std::vector<Anope::st return true; } -bool CoreIRCDMessageSQuit::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool SQuit::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { Server *s = Server::Find(params[0]); @@ -306,7 +390,7 @@ bool CoreIRCDMessageSQuit::Run(MessageSource &source, const std::vector<Anope::s return true; } -bool CoreIRCDMessageStats::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Stats::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { User *u = source.GetUser(); @@ -315,92 +399,92 @@ bool CoreIRCDMessageStats::Run(MessageSource &source, const std::vector<Anope::s case 'l': if (u->HasMode(UMODE_OPER)) { - ircdproto->SendNumeric(211, source.GetSource(), "Server SendBuf SentBytes SentMsgs RecvBuf RecvBytes RecvMsgs ConnTime"); - ircdproto->SendNumeric(211, source.GetSource(), "%s %d %d %d %d %d %d %ld", Config->Uplinks[CurrentUplink]->host.c_str(), UplinkSock->WriteBufferLen(), TotalWritten, -1, UplinkSock->ReadBufferLen(), TotalRead, -1, static_cast<long>(Anope::CurTime - start_time)); + IRCD->SendNumeric(211, source.GetSource(), "Server SendBuf SentBytes SentMsgs RecvBuf RecvBytes RecvMsgs ConnTime"); + IRCD->SendNumeric(211, source.GetSource(), "%s %d %d %d %d %d %d %ld", Config->Uplinks[Anope::CurrentUplink]->host.c_str(), UplinkSock->WriteBufferLen(), TotalWritten, -1, UplinkSock->ReadBufferLen(), TotalRead, -1, static_cast<long>(Anope::CurTime - Anope::StartTime)); } - ircdproto->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); + IRCD->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); break; case 'o': case 'O': /* Check whether the user is an operator */ if (!u->HasMode(UMODE_OPER) && Config->HideStatsO) - ircdproto->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); + IRCD->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); else { for (unsigned i = 0; i < Config->Opers.size(); ++i) { Oper *o = Config->Opers[i]; - const NickAlias *na = findnick(o->name); + const NickAlias *na = NickAlias::Find(o->name); if (na) - ircdproto->SendNumeric(243, source.GetSource(), "O * * %s %s 0", o->name.c_str(), o->ot->GetName().c_str()); + IRCD->SendNumeric(243, source.GetSource(), "O * * %s %s 0", o->name.c_str(), o->ot->GetName().c_str()); } - ircdproto->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); + IRCD->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); } break; case 'u': { - time_t uptime = Anope::CurTime - start_time; - ircdproto->SendNumeric(242, source.GetSource(), ":Services up %d day%s, %02d:%02d:%02d", uptime / 86400, uptime / 86400 == 1 ? "" : "s", (uptime / 3600) % 24, (uptime / 60) % 60, uptime % 60); - ircdproto->SendNumeric(250, source.GetSource(), ":Current users: %d (%d ops); maximum %d", usercnt, opcnt, maxusercnt); - ircdproto->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); + time_t uptime = Anope::CurTime - Anope::StartTime; + IRCD->SendNumeric(242, source.GetSource(), ":Services up %d day%s, %02d:%02d:%02d", uptime / 86400, uptime / 86400 == 1 ? "" : "s", (uptime / 3600) % 24, (uptime / 60) % 60, uptime % 60); + IRCD->SendNumeric(250, source.GetSource(), ":Current users: %d (%d ops); maximum %d", UserListByNick.size(), OperCount, MaxUserCount); + IRCD->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); break; } /* case 'u' */ default: - ircdproto->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); + IRCD->SendNumeric(219, source.GetSource(), "%c :End of /STATS report.", params[0][0]); } return true; } -bool CoreIRCDMessageTime::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Time::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { time_t t; time(&t); struct tm *tm = localtime(&t); char buf[64]; strftime(buf, sizeof(buf), "%a %b %d %H:%M:%S %Y %Z", tm); - ircdproto->SendNumeric(391, source.GetSource(), "%s :%s", Config->ServerName.c_str(), buf); + IRCD->SendNumeric(391, source.GetSource(), "%s :%s", Config->ServerName.c_str(), buf); return true; } -bool CoreIRCDMessageTopic::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Topic::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { - Channel *c = findchan(params[0]); + Channel *c = Channel::Find(params[0]); if (c) c->ChangeTopicInternal(source.GetSource(), params[1], Anope::CurTime); return true; } -bool CoreIRCDMessageVersion::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Version::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { Module *enc = ModuleManager::FindFirstOf(ENCRYPTION); - ircdproto->SendNumeric(351, source.GetSource(), "Anope-%s %s :%s -(%s) -- %s", Anope::Version().c_str(), Config->ServerName.c_str(), ircdproto->GetProtocolName().c_str(), enc ? enc->name.c_str() : "unknown", Anope::VersionBuildString().c_str()); + IRCD->SendNumeric(351, source.GetSource(), "Anope-%s %s :%s -(%s) -- %s", Anope::Version().c_str(), Config->ServerName.c_str(), IRCD->GetProtocolName().c_str(), enc ? enc->name.c_str() : "unknown", Anope::VersionBuildString().c_str()); return true; } -bool CoreIRCDMessageWhois::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) +bool Whois::Run(MessageSource &source, const std::vector<Anope::string> ¶ms) { - User *u = finduser(params[0]); + User *u = User::Find(params[0]); if (u && u->server == Me) { - const BotInfo *bi = findbot(u->nick); - ircdproto->SendNumeric(311, source.GetSource(), "%s %s %s * :%s", u->nick.c_str(), u->GetIdent().c_str(), u->host.c_str(), u->realname.c_str()); + const BotInfo *bi = BotInfo::Find(u->nick); + IRCD->SendNumeric(311, source.GetSource(), "%s %s %s * :%s", u->nick.c_str(), u->GetIdent().c_str(), u->host.c_str(), u->realname.c_str()); if (bi) - ircdproto->SendNumeric(307, source.GetSource(), "%s :is a registered nick", bi->nick.c_str()); - ircdproto->SendNumeric(312, source.GetSource(), "%s %s :%s", u->nick.c_str(), Config->ServerName.c_str(), Config->ServerDesc.c_str()); + IRCD->SendNumeric(307, source.GetSource(), "%s :is a registered nick", bi->nick.c_str()); + IRCD->SendNumeric(312, source.GetSource(), "%s %s :%s", u->nick.c_str(), Config->ServerName.c_str(), Config->ServerDesc.c_str()); if (bi) - ircdproto->SendNumeric(317, source.GetSource(), "%s %ld %ld :seconds idle, signon time", bi->nick.c_str(), static_cast<long>(Anope::CurTime - bi->lastmsg), static_cast<long>(bi->signon)); - ircdproto->SendNumeric(318, source.GetSource(), "%s :End of /WHOIS list.", params[0].c_str()); + IRCD->SendNumeric(317, source.GetSource(), "%s %ld %ld :seconds idle, signon time", bi->nick.c_str(), static_cast<long>(Anope::CurTime - bi->lastmsg), static_cast<long>(bi->signon)); + IRCD->SendNumeric(318, source.GetSource(), "%s :End of /WHOIS list.", params[0].c_str()); } else - ircdproto->SendNumeric(401, source.GetSource(), "%s :No such user.", params[0].c_str()); + IRCD->SendNumeric(401, source.GetSource(), "%s :No such user.", params[0].c_str()); return true; } diff --git a/src/misc.cpp b/src/misc.cpp index cd7516b76..7196a1534 100644 --- a/src/misc.cpp +++ b/src/misc.cpp @@ -1,4 +1,3 @@ - /* Miscellaneous routines. * * (C) 2003-2012 Anope Team @@ -8,12 +7,12 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" #include "version.h" #include "modules.h" -#include "extern.h" #include "lists.h" #include "config.h" #include "bots.h" @@ -24,37 +23,6 @@ #include <sys/types.h> #include <sys/stat.h> -ExtensibleItem::ExtensibleItem() -{ -} - -ExtensibleItem::~ExtensibleItem() -{ -} - -void ExtensibleItem::OnDelete() -{ - delete this; -} - -/*************************************************************************/ - -/** Check if a file exists - * @param filename The file - * @return true if the file exists, false if it doens't - */ -bool IsFile(const Anope::string &filename) -{ - struct stat fileinfo; - if (!stat(filename.c_str(), &fileinfo)) - return true; - - return false; -} - - -/*************************************************************************/ - NumberList::NumberList(const Anope::string &list, bool descending) : is_valid(true), desc(descending) { Anope::string error; @@ -134,18 +102,18 @@ bool NumberList::InvalidRange(const Anope::string &) return true; } -ListFormatter &ListFormatter::addColumn(const Anope::string &name) +ListFormatter &ListFormatter::AddColumn(const Anope::string &name) { this->columns.push_back(name); return *this; } -void ListFormatter::addEntry(const ListEntry &entry) +void ListFormatter::AddEntry(const ListEntry &entry) { this->entries.push_back(entry); } -bool ListFormatter::isEmpty() const +bool ListFormatter::IsEmpty() const { return this->entries.empty(); } @@ -235,7 +203,7 @@ void InfoFormatter::Process(std::vector<Anope::string> &buffer) Anope::string s; for (unsigned i = it->first.length(); i < this->longest; ++i) s += " "; - s += Anope::string(translate(this->nc, it->first.c_str())) + ": " + it->second; + s += Anope::string(Language::Translate(this->nc, it->first.c_str())) + ": " + it->second; buffer.push_back(s); } @@ -249,18 +217,16 @@ Anope::string& InfoFormatter::operator[](const Anope::string &key) return this->replies.back().second; } -/** - * dotime: Return the number of seconds corresponding to the given time - * string. If the given string does not represent a valid time, - * return -1. - * - * A time string is either a plain integer (representing a number - * of seconds), or an integer followed by one of these characters: - * "s" (seconds), "m" (minutes), "h" (hours), or "d" (days). - * @param s String to convert - * @return time_t - */ -time_t dotime(const Anope::string &s) +bool Anope::IsFile(const Anope::string &filename) +{ + struct stat fileinfo; + if (!stat(filename.c_str(), &fileinfo)) + return true; + + return false; +} + +time_t Anope::DoTime(const Anope::string &s) { if (s.empty()) return -1; @@ -297,15 +263,7 @@ time_t dotime(const Anope::string &s) return 0; } -/*************************************************************************/ - -/** - * Expresses in a string the period of time represented by a given amount - * of seconds (with days/hours/minutes). - * @param seconds time in seconds - * @return buffer - */ -Anope::string duration(const time_t &t, const NickCore *nc) +Anope::string Anope::Duration(time_t t, const NickCore *nc) { /* We first calculate everything */ time_t days = (t / 86400); @@ -314,58 +272,50 @@ Anope::string duration(const time_t &t, const NickCore *nc) time_t seconds = (t) % 60; if (!days && !hours && !minutes) - return stringify(seconds) + " " + (seconds != 1 ? translate(nc, _("seconds")) : translate(nc, _("second"))); + return stringify(seconds) + " " + (seconds != 1 ? Language::Translate(nc, _("seconds")) : Language::Translate(nc, _("second"))); else { bool need_comma = false; Anope::string buffer; if (days) { - buffer = stringify(days) + " " + (days != 1 ? translate(nc, _("days")) : translate(nc, _("day"))); + buffer = stringify(days) + " " + (days != 1 ? Language::Translate(nc, _("days")) : Language::Translate(nc, _("day"))); need_comma = true; } if (hours) { buffer += need_comma ? ", " : ""; - buffer += stringify(hours) + " " + (hours != 1 ? translate(nc, _("hours")) : translate(nc, _("hour"))); + buffer += stringify(hours) + " " + (hours != 1 ? Language::Translate(nc, _("hours")) : Language::Translate(nc, _("hour"))); need_comma = true; } if (minutes) { buffer += need_comma ? ", " : ""; - buffer += stringify(minutes) + " " + (minutes != 1 ? translate(nc, _("minutes")) : translate(nc, _("minute"))); + buffer += stringify(minutes) + " " + (minutes != 1 ? Language::Translate(nc, _("minutes")) : Language::Translate(nc, _("minute"))); } return buffer; } } -Anope::string do_strftime(const time_t &t, const NickCore *nc, bool short_output) +Anope::string Anope::strftime(time_t t, const NickCore *nc, bool short_output) { tm tm = *localtime(&t); char buf[BUFSIZE]; - strftime(buf, sizeof(buf), translate(nc, _("%b %d %H:%M:%S %Y %Z")), &tm); + strftime(buf, sizeof(buf), Language::Translate(nc, _("%b %d %H:%M:%S %Y %Z")), &tm); if (short_output) return buf; if (t < Anope::CurTime) - return Anope::string(buf) + " " + Anope::printf(translate(nc, _("(%s ago)")), duration(Anope::CurTime - t).c_str(), nc); + return Anope::string(buf) + " " + Anope::printf(Language::Translate(nc, _("(%s ago)")), Duration(Anope::CurTime - t).c_str(), nc); else - return Anope::string(buf) + " " + Anope::printf(translate(nc, _("(%s from now)")), duration(t - Anope::CurTime).c_str(), nc); + return Anope::string(buf) + " " + Anope::printf(Language::Translate(nc, _("(%s from now)")), Duration(t - Anope::CurTime).c_str(), nc); } -/*************************************************************************/ - -/** - * Generates a human readable string of type "expires in ..." - * @param na Nick Alias - * @param seconds time in seconds - * @return buffer - */ -Anope::string expire_left(const NickCore *nc, time_t expires) +Anope::string Anope::Expires(time_t expires, const NickCore *nc) { if (!expires) - return translate(nc, NO_EXPIRE); + return Language::Translate(nc, NO_EXPIRE); else if (expires <= Anope::CurTime) - return translate(nc, _("expires momentarily")); + return Language::Translate(nc, _("expires momentarily")); else { char buf[256]; @@ -374,21 +324,21 @@ Anope::string expire_left(const NickCore *nc, time_t expires) if (diff >= 86400) { int days = diff / 86400; - snprintf(buf, sizeof(buf), translate(nc, days == 1 ? _("expires in %d day") : _("expires in %d days")), days); + snprintf(buf, sizeof(buf), Language::Translate(nc, days == 1 ? _("expires in %d day") : _("expires in %d days")), days); } else { if (diff <= 3600) { int minutes = diff / 60; - snprintf(buf, sizeof(buf), translate(nc, minutes == 1 ? _("expires in %d minute") : _("expires in %d minutes")), minutes); + snprintf(buf, sizeof(buf), Language::Translate(nc, minutes == 1 ? _("expires in %d minute") : _("expires in %d minutes")), minutes); } else { int hours = diff / 3600, minutes; diff -= hours * 3600; minutes = diff / 60; - snprintf(buf, sizeof(buf), translate(nc, hours == 1 && minutes == 1 ? _("expires in %d hour, %d minute") : (hours == 1 && minutes != 1 ? _("expires in %d hour, %d minutes") : (hours != 1 && minutes == 1 ? _("expires in %d hours, %d minute") : _("expires in %d hours, %d minutes")))), hours, minutes); + snprintf(buf, sizeof(buf), Language::Translate(nc, hours == 1 && minutes == 1 ? _("expires in %d hour, %d minute") : (hours == 1 && minutes != 1 ? _("expires in %d hour, %d minutes") : (hours != 1 && minutes == 1 ? _("expires in %d hours, %d minute") : _("expires in %d hours, %d minutes")))), hours, minutes); } } @@ -396,181 +346,6 @@ Anope::string expire_left(const NickCore *nc, time_t expires) } } -/*************************************************************************/ - -/** Checks if a username is valid - * @param ident The username - * @return true if the ident is valid - */ -bool IsValidIdent(const Anope::string &ident) -{ - if (ident.empty() || ident.length() > Config->UserLen) - return false; - for (unsigned i = 0; i < ident.length(); ++i) - { - const char &c = ident[i]; - if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.' || c == '-') - ; - else - return false; - } - - return true; -} - -/** Checks if a host is valid - * @param host The host - * @param true if the host is valid - */ -bool IsValidHost(const Anope::string &host) -{ - if (host.empty() || host.length() > Config->HostLen) - return false; - - if (Config->VhostDisallowBE.find_first_of(host[0]) != Anope::string::npos) - return false; - else if (Config->VhostDisallowBE.find_first_of(host[host.length() - 1]) != Anope::string::npos) - return false; - - int dots = 0; - for (unsigned i = 0; i < host.length(); ++i) - { - if (host[i] == '.') - ++dots; - if (Config->VhostChars.find_first_of(host[i]) == Anope::string::npos) - return false; - } - - return Config->VhostUndotted || dots > 0; -} - -/*************************************************************************/ - -/** - * Get the token - * @param str String to search in - * @param dilim Character to search for - * @param token_number the token number - * @return token - */ -Anope::string myStrGetToken(const Anope::string &str, char dilim, int token_number) -{ - if (str.empty() || str.find(dilim) == Anope::string::npos) - return token_number ? "" : str; - - Anope::string substring; - sepstream sep(str, dilim); - - for (int i = 0; i < token_number + 1 && !sep.StreamEnd() && sep.GetToken(substring); ++i); - - return substring; -} - -/*************************************************************************/ - -/** - * Get the Remaining tokens - * @param str String to search in - * @param dilim Character to search for - * @param token_number the token number - * @return token - */ -Anope::string myStrGetTokenRemainder(const Anope::string &str, const char dilim, int token_number) -{ - if (str.empty() || str.find(dilim) == Anope::string::npos) - return token_number ? "" : str; - - Anope::string substring; - sepstream sep(str, dilim); - - for (int i = 0; i < token_number + 1 && !sep.StreamEnd() && sep.GetToken(substring); ++i); - - if (!sep.StreamEnd()) - substring += dilim + sep.GetRemaining(); - return substring; -} - -/*************************************************************************/ - -/** - * Is the given nick a network service - * @param nick to check - * @param int Check if botserv bots - * @return int - */ -bool nickIsServices(const Anope::string &tempnick, bool bot) -{ - if (tempnick.empty()) - return false; - - Anope::string nick = tempnick; - - size_t at = nick.find('@'); - if (at != Anope::string::npos) - { - Anope::string servername = nick.substr(at + 1); - if (!servername.equals_ci(Config->ServerName)) - return false; - nick = nick.substr(0, at); - } - - const BotInfo *bi = findbot(nick); - if (bi) - return bot ? true : bi->HasFlag(BI_CORE); - return false; -} - -/*************************************************************************/ - -/** - * Number of tokens in a string - * @param str String - * @param dilim Dilimiter - * @return number of tokens - */ -int myNumToken(const Anope::string &str, char dilim) -{ - if (str.empty()) - return 0; - int counter = 0; - for (size_t idx = 0, len = str.length(); idx <= len; ++idx) - if (str[idx] == dilim || idx == len) - ++counter; - return counter; -} - -/*************************************************************************/ - -/** Build a string list from a source string - * @param src The source string - * @return a list of strings - */ -std::list<Anope::string> BuildStringList(const Anope::string &src, char delim) -{ - sepstream tokens(src, delim); - Anope::string token; - std::list<Anope::string> Ret; - - while (tokens.GetToken(token)) - Ret.push_back(token); - - return Ret; -} - -std::vector<Anope::string> BuildStringVector(const Anope::string &src, char delim) -{ - sepstream tokens(src, delim); - Anope::string token; - std::vector<Anope::string> Ret; - - while (tokens.GetToken(token)) - Ret.push_back(token); - - return Ret; -} - -/*************************************************************************/ - bool Anope::Match(const Anope::string &str, const Anope::string &mask, bool case_sensitive, bool use_regex) { size_t s = 0, m = 0, str_len = str.length(), mask_len = mask.length(); @@ -583,7 +358,7 @@ bool Anope::Match(const Anope::string &str, const Anope::string &mask, bool case if (r == NULL || r->GetExpression() != stripped_mask) { - service_reference<RegexProvider> provider("Regex", Config->RegexEngine); + ServiceReference<RegexProvider> provider("Regex", Config->RegexEngine); if (provider) { try @@ -675,13 +450,6 @@ bool Anope::Match(const Anope::string &str, const Anope::string &mask, bool case return m == mask_len; } -/** Returns a sequence of data formatted as the format argument specifies. - ** After the format parameter, the function expects at least as many - ** additional arguments as specified in format. - * @param fmt Format of the Message - * @param ... any number of parameters - * @return a Anope::string - */ Anope::string Anope::printf(const char *fmt, ...) { va_list args; @@ -692,35 +460,6 @@ Anope::string Anope::printf(const char *fmt, ...) return buf; } - -/*************************************************************************/ - -/** - * Check if the given string is some sort of wildcard - * @param str String to check - * @return 1 for wildcard, 0 for anything else - */ -bool str_is_wildcard(const Anope::string &str) -{ - return str.find_first_of("*?") != Anope::string::npos; -} - -/** - * Check if the given string is a pure wildcard - * @param str String to check - * @return 1 for pure wildcard, 0 for anything else - */ -bool str_is_pure_wildcard(const Anope::string &str) -{ - return str.find_first_not_of('*') == Anope::string::npos; -} - -/*************************************************************************/ - -/** Converts a string to hex - * @param the data to be converted - * @return a anope::string containing the hex value - */ Anope::string Anope::Hex(const Anope::string &data) { const char hextable[] = "0123456789abcdef"; @@ -750,10 +489,6 @@ Anope::string Anope::Hex(const char *data, unsigned len) return rv; } -/** Converts a string from hex - * @param src The data to be converted - * @param dest The destination string - */ void Anope::Unhex(const Anope::string &src, Anope::string &dest) { size_t len = src.length(); @@ -827,12 +562,7 @@ int Anope::VersionMajor() { return VERSION_MAJOR; } int Anope::VersionMinor() { return VERSION_MINOR; } int Anope::VersionPatch() { return VERSION_PATCH; } -/** - * Normalize buffer stripping control characters and colors - * @param A string to be parsed for control and color codes - * @return A string stripped of control and color codes - */ -Anope::string normalizeBuffer(const Anope::string &buf) +Anope::string Anope::NormalizeBuffer(const Anope::string &buf) { Anope::string newbuf; diff --git a/src/modes.cpp b/src/modes.cpp index c14e09f70..ae550d788 100644 --- a/src/modes.cpp +++ b/src/modes.cpp @@ -4,11 +4,11 @@ * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #include "services.h" #include "modules.h" -#include "extern.h" #include "config.h" #include "sockets.h" #include "protocol.h" @@ -23,70 +23,52 @@ std::vector<ChannelMode *> ModeManager::ChannelModes; std::vector<UserMode *> ModeManager::UserModes; /* Number of generic modes we support */ -unsigned GenericChannelModes = 0, GenericUserModes = 0; -/* Default mlocked modes */ -ChannelInfo::ModeList def_mode_locks; +unsigned ModeManager::GenericChannelModes = 0, ModeManager::GenericUserModes = 0; -/** Parse the mode string from the config file and set the default mlocked modes - */ -void SetDefaultMLock(ServerConfig *config) -{ - for (ChannelInfo::ModeList::iterator it = def_mode_locks.begin(), it_end = def_mode_locks.end(); it != it_end; ++it) - delete it->second; - def_mode_locks.clear(); +/* Default channel mode lock */ +ChannelInfo::ModeList ModeManager::DefaultModeLocks; - Anope::string modes; - spacesepstream sep(config->MLock); - sep.GetToken(modes); +/* Default modes bots have on channels */ +ChannelStatus ModeManager::DefaultBotModes; - int adding = -1; - for (unsigned i = 0, end_mode = modes.length(); i < end_mode; ++i) - { - if (modes[i] == '+') - adding = 1; - else if (modes[i] == '-') - adding = 0; - else if (adding != -1) - { - ChannelMode *cm = ModeManager::FindChannelModeByChar(modes[i]); +static const Anope::string UserModeNameStrings[] = { + "UMODE_BEGIN", - if (cm && cm->Type != MODE_STATUS) - { - Anope::string param; - if (adding == 1 && cm->Type != MODE_REGULAR && !sep.GetToken(param)) // MODE_LIST OR MODE_PARAM - { - Log() << "Warning: Got default mlock mode " << cm->ModeChar << " with no param?"; - continue; - } + "UMODE_SERV_ADMIN", "UMODE_BOT", "UMODE_CO_ADMIN", "UMODE_FILTER", "UMODE_HIDEOPER", "UMODE_NETADMIN", + "UMODE_REGPRIV", "UMODE_PROTECTED", "UMODE_NOCTCP", "UMODE_WEBTV", "UMODE_WEBIRC", "UMODE_WHOIS", "UMODE_ADMIN", "UMODE_DEAF", + "UMODE_GLOBOPS", "UMODE_HELPOP", "UMODE_INVIS", "UMODE_OPER", "UMODE_PRIV", "UMODE_GOD", "UMODE_REGISTERED", + "UMODE_SNOMASK", "UMODE_VHOST", "UMODE_WALLOPS", "UMODE_CLOAK", "UMODE_SSL", "UMODE_SOFTCALLERID", "UMODE_CALLERID", + "UMODE_COMMONCHANS", "UMODE_HIDDEN", "UMODE_STRIPCOLOR", "UMODE_INVISIBLE_OPER", "UMODE_RESTRICTED", "UMODE_HIDEIDLE", - if (cm->Type != MODE_LIST) // Only MODE_LIST can have duplicates - { - ChannelInfo::ModeList::iterator it = def_mode_locks.find(cm->Name); - if (it != def_mode_locks.end()) - { - delete it->second; - def_mode_locks.erase(it); - } - } - def_mode_locks.insert(std::make_pair(cm->Name, new ModeLock(NULL, adding == 1, cm->Name, param))); - } - } - } + "" +}; +template<> const Anope::string* Flags<UserModeName>::flags_strings = UserModeNameStrings; - /* Set Bot Modes */ - config->BotModeList.ClearFlags(); - for (unsigned i = 0; i < config->BotModes.length(); ++i) - { - ChannelMode *cm = ModeManager::FindChannelModeByChar(config->BotModes[i]); +static const Anope::string ChannelModeNameStrings[] = { + "CMODE_BEGIN", - if (cm && cm->Type == MODE_STATUS) - config->BotModeList.SetFlag(cm->Name); - } -} + /* Channel modes */ + "CMODE_BLOCKCOLOR", "CMODE_FLOOD", "CMODE_INVITE", "CMODE_KEY", "CMODE_LIMIT", "CMODE_MODERATED", "CMODE_NOEXTERNAL", + "CMODE_PRIVATE", "CMODE_REGISTERED", "CMODE_SECRET", "CMODE_TOPIC", "CMODE_AUDITORIUM", "CMODE_SSL", "CMODE_ADMINONLY", + "CMODE_NOCTCP", "CMODE_FILTER", "CMODE_NOKNOCK", "CMODE_REDIRECT", "CMODE_REGMODERATED", "CMODE_NONICK", "CMODE_OPERONLY", + "CMODE_NOKICK", "CMODE_REGISTEREDONLY", "CMODE_STRIPCOLOR", "CMODE_NONOTICE", "CMODE_NOINVITE", "CMODE_ALLINVITE", + "CMODE_BLOCKCAPS", "CMODE_PERM", "CMODE_NICKFLOOD", "CMODE_JOINFLOOD", "CMODE_DELAYEDJOIN", "CMODE_NOREJOIN", + "CMODE_BANDWIDTH", -ChannelStatus::ChannelStatus() : Flags<ChannelModeName, CMODE_END * 2>(ChannelModeNameStrings) -{ -} + /* b/e/I */ + "CMODE_BAN", "CMODE_EXCEPT", + "CMODE_INVITEOVERRIDE", + + /* v/h/o/a/q */ + "CMODE_VOICE", "CMODE_HALFOP", "CMODE_OP", + "CMODE_PROTECT", "CMODE_OWNER", + + "" +}; +template<> const Anope::string* Flags<ChannelModeName>::flags_strings = ChannelModeNameStrings; + +static const Anope::string EntryFlagString[] = { "ENTRYTYPE_NONE", "ENTRYTYPE_CIDR", "ENTRYTYPE_NICK_WILD", "ENTRYTYPE_NICK", "ENTRYTYPE_USER_WILD", "ENTRYTYPE_USER", "ENTRYTYPE_HOST_WILD", "ENTRYTYPE_HOST", "" }; +template<> const Anope::string* Flags<EntryType>::flags_strings = EntryFlagString; Anope::string ChannelStatus::BuildCharPrefixList() const { @@ -96,8 +78,8 @@ Anope::string ChannelStatus::BuildCharPrefixList() const { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (this->HasFlag(cm->Name)) - ret += cm->ModeChar; + if (this->HasFlag(cm->name)) + ret += cm->mchar; } return ret; @@ -111,7 +93,7 @@ Anope::string ChannelStatus::BuildModePrefixList() const { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (this->HasFlag(cm->Name)) + if (this->HasFlag(cm->name)) { ChannelModeStatus *cms = anope_dynamic_static_cast<ChannelModeStatus *>(cm); ret += cms->Symbol; @@ -121,139 +103,83 @@ Anope::string ChannelStatus::BuildModePrefixList() const return ret; } -/** Default constructor - * @param mClass The type of mode this is - * @param modeChar The mode char - * @param modeType The mode type - */ -Mode::Mode(ModeClass mClass, char modeChar, ModeType modeType) : Class(mClass), ModeChar(modeChar), Type(modeType) +Mode::Mode(ModeClass mcl, char mch, ModeType mt) : mclass(mcl), mchar(mch), type(mt) { } -/** Default destructor - */ Mode::~Mode() { } -/** Default constructor - * @param mName The mode name - * @param modeChar The mode char - */ -UserMode::UserMode(UserModeName mName, char modeChar) : Mode(MC_USER, modeChar, MODE_REGULAR), Name(mName) +UserMode::UserMode(UserModeName un, char mch) : Mode(MC_USER, mch, MODE_REGULAR), name(un) { } -/** Default destructor - */ UserMode::~UserMode() { } -/** Returns the mode name as a string - */ const Anope::string UserMode::NameAsString() { - if (this->Name > UMODE_END) - return this->ModeChar; - return UserModeNameStrings[this->Name]; + if (this->name >= UMODE_END) + return this->mchar; + return UserModeNameStrings[this->name]; } -/** Default constructor - * @param mName The mode name - * @param modeChar The mode char - */ -UserModeParam::UserModeParam(UserModeName mName, char modeChar) : UserMode(mName, modeChar) +UserModeParam::UserModeParam(UserModeName un, char mch) : UserMode(un, mch) { - this->Type = MODE_PARAM; + this->type = MODE_PARAM; } -/** Default constrcutor - * @param mName The mode name - * @param modeChar The mode char - */ -ChannelMode::ChannelMode(ChannelModeName mName, char modeChar) : Mode(MC_CHANNEL, modeChar, MODE_REGULAR), Name(mName) +ChannelMode::ChannelMode(ChannelModeName cm, char mch) : Mode(MC_CHANNEL, mch, MODE_REGULAR), name(cm) { } -/** Default destructor - */ ChannelMode::~ChannelMode() { } -/** Can a user set this mode, used for mlock - * NOTE: User CAN be NULL, this is for checking if it can be locked with defcon - * @param u The user, or NULL - */ bool ChannelMode::CanSet(User *u) const { - if (Config->NoMLock.find(this->ModeChar) != Anope::string::npos || Config->CSRequire.find(this->ModeChar) != Anope::string::npos) + if (Config->NoMLock.find(this->mchar) != Anope::string::npos || Config->CSRequire.find(this->mchar) != Anope::string::npos) return false; return true; } -/** Returns the mode name as a string - */ const Anope::string ChannelMode::NameAsString() { - if (this->Name > CMODE_END) - return this->ModeChar; - return ChannelModeNameStrings[this->Name]; + if (this->name >= CMODE_END) + return this->mchar; + return ChannelModeNameStrings[this->name]; } -/** Default constructor - * @param mName The mode name - * @param modeChar The mode char - */ -ChannelModeList::ChannelModeList(ChannelModeName mName, char modeChar) : ChannelMode(mName, modeChar) +ChannelModeList::ChannelModeList(ChannelModeName cm, char mch) : ChannelMode(cm, mch) { - this->Type = MODE_LIST; + this->type = MODE_LIST; } -/** Default destructor - */ ChannelModeList::~ChannelModeList() { } -/** Default constructor - * @param mName The mode name - * @param modeChar The mode char - * @param MinusArg true if the mode sends no arg when unsetting - */ -ChannelModeParam::ChannelModeParam(ChannelModeName mName, char modeChar, bool MinusArg) : ChannelMode(mName, modeChar), MinusNoArg(MinusArg) +ChannelModeParam::ChannelModeParam(ChannelModeName cm, char mch, bool ma) : ChannelMode(cm, mch), minus_no_arg(ma) { - this->Type = MODE_PARAM; + this->type = MODE_PARAM; } -/** Default destructor - */ ChannelModeParam::~ChannelModeParam() { } -/** Default constructor - * @param mName The mode name - * @param modeChar The mode char - * @param mSymbol The symbol for the mode, eg @ % + - * @param mLevel A level for the mode, which is usually determined by the PREFIX capab - */ ChannelModeStatus::ChannelModeStatus(ChannelModeName mName, char modeChar, char mSymbol, unsigned short mLevel) : ChannelMode(mName, modeChar), Symbol(mSymbol), Level(mLevel) { - this->Type = MODE_STATUS; + this->type = MODE_STATUS; } -/** Default destructor - */ ChannelModeStatus::~ChannelModeStatus() { } -/** Is the key valid - * @param value The key - * @return true or false - */ bool ChannelModeKey::IsValid(const Anope::string &value) const { if (!value.empty() && value.find(':') == Anope::string::npos && value.find(',') == Anope::string::npos) @@ -262,10 +188,6 @@ bool ChannelModeKey::IsValid(const Anope::string &value) const return false; } -/** Can admin only mode be set by the user - * @param u The user - can be NULL if defcon is checking - * @return true or false - */ bool ChannelModeAdmin::CanSet(User *u) const { if (u && u->HasMode(UMODE_OPER)) @@ -274,10 +196,6 @@ bool ChannelModeAdmin::CanSet(User *u) const return false; } -/** Can oper only mode be set by the user - * @param u The user - can be NULL if defcon is checking - * @return true or false - */ bool ChannelModeOper::CanSet(User *u) const { if (u && u->HasMode(UMODE_OPER)) @@ -286,21 +204,17 @@ bool ChannelModeOper::CanSet(User *u) const return false; } -/** Can the user set the registered mode? - * No. - * @return false - */ bool ChannelModeRegistered::CanSet(User *u) const { return false; } -void StackerInfo::AddMode(Mode *mode, bool Set, const Anope::string &Param) +void StackerInfo::AddMode(Mode *mode, bool set, const Anope::string ¶m) { - bool IsParam = mode->Type == MODE_PARAM; + bool is_param = mode->type == MODE_PARAM; std::list<std::pair<Mode *, Anope::string> > *list, *otherlist; - if (Set) + if (set) { list = &AddModes; otherlist = &DelModes; @@ -318,7 +232,7 @@ void StackerInfo::AddMode(Mode *mode, bool Set, const Anope::string &Param) /* The param must match too (can have multiple status or list modes), but * if it is a param mode it can match no matter what the param is */ - if (it->first == mode && (Param.equals_cs(it->second) || IsParam)) + if (it->first == mode && (is_param || param.equals_cs(it->second))) { list->erase(it); /* It can only be on this list once */ @@ -331,7 +245,7 @@ void StackerInfo::AddMode(Mode *mode, bool Set, const Anope::string &Param) /* The param must match too (can have multiple status or list modes), but * if it is a param mode it can match no matter what the param is */ - if (it->first == mode && (Param.equals_cs(it->second) || IsParam)) + if (it->first == mode && (is_param || param.equals_cs(it->second))) { otherlist->erase(it); return; @@ -343,7 +257,7 @@ void StackerInfo::AddMode(Mode *mode, bool Set, const Anope::string &Param) } /* Add this mode and its param to our list */ - list->push_back(std::make_pair(mode, Param)); + list->push_back(std::make_pair(mode, param)); } static class ModePipe : public Pipe @@ -371,10 +285,6 @@ static StackerInfo *GetInfo(List &l, Object *o) return s; } -/** Build a list of mode strings to send to the IRCd from the mode stacker - * @param info The stacker info for a channel or user - * @return a list of strings - */ std::list<Anope::string> ModeManager::BuildModeStrings(StackerInfo *info) { std::list<Anope::string> ret; @@ -384,7 +294,7 @@ std::list<Anope::string> ModeManager::BuildModeStrings(StackerInfo *info) for (it = info->AddModes.begin(), it_end = info->AddModes.end(); it != it_end; ++it) { - if (++NModes > ircdproto->MaxModes) + if (++NModes > IRCD->MaxModes) { ret.push_back(buf + parambuf); buf = "+"; @@ -392,7 +302,7 @@ std::list<Anope::string> ModeManager::BuildModeStrings(StackerInfo *info) NModes = 1; } - buf += it->first->ModeChar; + buf += it->first->mchar; if (!it->second.empty()) parambuf += " " + it->second; @@ -404,7 +314,7 @@ std::list<Anope::string> ModeManager::BuildModeStrings(StackerInfo *info) buf += "-"; for (it = info->DelModes.begin(), it_end = info->DelModes.end(); it != it_end; ++it) { - if (++NModes > ircdproto->MaxModes) + if (++NModes > IRCD->MaxModes) { ret.push_back(buf + parambuf); buf = "-"; @@ -412,7 +322,7 @@ std::list<Anope::string> ModeManager::BuildModeStrings(StackerInfo *info) NModes = 1; } - buf += it->first->ModeChar; + buf += it->first->mchar; if (!it->second.empty()) parambuf += " " + it->second; @@ -427,19 +337,15 @@ std::list<Anope::string> ModeManager::BuildModeStrings(StackerInfo *info) return ret; } -/** Add a user mode to Anope - * @param um A UserMode or UserMode derived class - * @return true on success, false on error - */ bool ModeManager::AddUserMode(UserMode *um) { - if (ModeManager::FindUserModeByChar(um->ModeChar) != NULL) + if (ModeManager::FindUserModeByChar(um->mchar) != NULL) return false; - if (um->Name == UMODE_END) + if (um->name == UMODE_END) { - um->Name = static_cast<UserModeName>(UMODE_END + ++GenericUserModes); - Log() << "ModeManager: Added generic support for user mode " << um->ModeChar; + um->name = static_cast<UserModeName>(UMODE_END + ++GenericUserModes); + Log() << "ModeManager: Added generic support for user mode " << um->mchar; } ModeManager::UserModes.push_back(um); @@ -448,154 +354,145 @@ bool ModeManager::AddUserMode(UserMode *um) return true; } -/** Add a channel mode to Anope - * @param cm A ChannelMode or ChannelMode derived class - * @return true on success, false on error - */ bool ModeManager::AddChannelMode(ChannelMode *cm) { - if (ModeManager::FindChannelModeByChar(cm->ModeChar) != NULL) + if (ModeManager::FindChannelModeByChar(cm->mchar) != NULL) return false; - if (cm->Name == CMODE_END) + if (cm->name == CMODE_END) { - cm->Name = static_cast<ChannelModeName>(CMODE_END + ++GenericChannelModes); - Log() << "ModeManager: Added generic support for channel mode " << cm->ModeChar; + cm->name = static_cast<ChannelModeName>(CMODE_END + ++GenericChannelModes); + Log() << "ModeManager: Added generic support for channel mode " << cm->mchar; } ModeManager::ChannelModes.push_back(cm); /* Apply this mode to the new default mlock if its used */ - SetDefaultMLock(Config); + UpdateDefaultMLock(Config); FOREACH_MOD(I_OnChannelModeAdd, OnChannelModeAdd(cm)); return true; } -/** Find a channel mode - * @param Mode The mode - * @return The mode class - */ + +void ModeManager::RemoveUserMode(UserMode *um) +{ + for (unsigned i = 0; i < ModeManager::UserModes.size(); ++i) + { + UserMode *mode = ModeManager::UserModes[i]; + if (um == mode) + { + ModeManager::UserModes.erase(ModeManager::UserModes.begin() + i); + break; + } + } + + StackerDel(um); +} + +void ModeManager::RemoveChannelMode(ChannelMode *cm) +{ + for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) + { + ChannelMode *mode = ModeManager::ChannelModes[i]; + if (cm == mode) + { + ModeManager::ChannelModes.erase(ModeManager::ChannelModes.begin() + i); + break; + } + } + + StackerDel(cm); +} + ChannelMode *ModeManager::FindChannelModeByChar(char Mode) { for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (cm->ModeChar == Mode) + if (cm->mchar == Mode) return cm; } return NULL; } -/** Find a user mode - * @param Mode The mode - * @return The mode class - */ UserMode *ModeManager::FindUserModeByChar(char Mode) { for (unsigned i = 0; i < ModeManager::UserModes.size(); ++i) { UserMode *um = ModeManager::UserModes[i]; - if (um->ModeChar == Mode) + if (um->mchar == Mode) return um; } return NULL; } -/** Find a channel mode - * @param Mode The modename - * @return The mode class - */ ChannelMode *ModeManager::FindChannelModeByName(ChannelModeName Name) { for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (cm->Name == Name) + if (cm->name == Name) return cm; } return NULL; } -/** Find a user mode - * @param Mode The modename - * @return The mode class - */ UserMode *ModeManager::FindUserModeByName(UserModeName Name) { for (unsigned i = 0; i < ModeManager::UserModes.size(); ++i) { UserMode *um = ModeManager::UserModes[i]; - if (um->Name == Name) + if (um->name == Name) return um; } return NULL; } -/** Find channel mode by string - * @param name The mode name - * @return The mode - */ ChannelMode *ModeManager::FindChannelModeByString(const Anope::string &name) { for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (cm->NameAsString() == name || Anope::string(cm->ModeChar) == name) + if (cm->NameAsString() == name || Anope::string(cm->mchar) == name) return cm; } return NULL; } -/** Find user mode by string - * @param name The mode name - * @return The mode - */ UserMode *ModeManager::FindUserModeByString(const Anope::string &name) { for (size_t i = UMODE_BEGIN + 1; i != UMODE_END; ++i) { UserMode *um = ModeManager::FindUserModeByName(static_cast<UserModeName>(i)); - if (um != NULL && (um->NameAsString() == name || Anope::string(um->ModeChar) == name)) + if (um != NULL && (um->NameAsString() == name || Anope::string(um->mchar) == name)) return um; } return NULL; } - -/** Gets the channel mode char for a symbol (eg + returns v) - * @param Value The symbol - * @return The char - */ char ModeManager::GetStatusChar(char Value) { for (unsigned i = 0; i < ModeManager::ChannelModes.size(); ++i) { ChannelMode *cm = ModeManager::ChannelModes[i]; - if (cm->Type == MODE_STATUS) + if (cm->type == MODE_STATUS) { ChannelModeStatus *cms = anope_dynamic_static_cast<ChannelModeStatus *>(cm); if (Value == cms->Symbol) - return cms->ModeChar; + return cms->mchar; } } return 0; } -/** Add a mode to the stacker to be set on a channel - * @param bi The client to set the modes from - * @param c The channel - * @param cm The channel mode - * @param Set true for setting, false for removing - * @param Param The param, if there is one - */ void ModeManager::StackerAdd(const BotInfo *bi, Channel *c, ChannelMode *cm, bool Set, const Anope::string &Param) { StackerInfo *s = GetInfo(ChannelStackerObjects, c); @@ -610,13 +507,6 @@ void ModeManager::StackerAdd(const BotInfo *bi, Channel *c, ChannelMode *cm, boo modePipe->Notify(); } -/** Add a mode to the stacker to be set on a user - * @param bi The client to set the modes from - * @param u The user - * @param um The user mode - * @param Set true for setting, false for removing - * @param param The param, if there is one - */ void ModeManager::StackerAdd(const BotInfo *bi, User *u, UserMode *um, bool Set, const Anope::string &Param) { StackerInfo *s = GetInfo(UserStackerObjects, u); @@ -631,8 +521,6 @@ void ModeManager::StackerAdd(const BotInfo *bi, User *u, UserMode *um, bool Set, modePipe->Notify(); } -/** Process all of the modes in the stacker and send them to the IRCd to be set on channels/users - */ void ModeManager::ProcessModes() { if (!UserStackerObjects.empty()) @@ -644,7 +532,7 @@ void ModeManager::ProcessModes() std::list<Anope::string> ModeStrings = BuildModeStrings(s); for (std::list<Anope::string>::iterator lit = ModeStrings.begin(), lit_end = ModeStrings.end(); lit != lit_end; ++lit) - ircdproto->SendMode(s->bi, u, lit->c_str()); + IRCD->SendMode(s->bi, u, lit->c_str()); delete it->second; } UserStackerObjects.clear(); @@ -659,15 +547,13 @@ void ModeManager::ProcessModes() std::list<Anope::string> ModeStrings = BuildModeStrings(s); for (std::list<Anope::string>::iterator lit = ModeStrings.begin(), lit_end = ModeStrings.end(); lit != lit_end; ++lit) - ircdproto->SendMode(s->bi, c, lit->c_str()); + IRCD->SendMode(s->bi, c, lit->c_str()); delete it->second; } ChannelStackerObjects.clear(); } } -/** Delete a user or channel from the stacker - */ void ModeManager::StackerDel(User *u) { UserStackerObjects.erase(u); @@ -678,3 +564,245 @@ void ModeManager::StackerDel(Channel *c) ChannelStackerObjects.erase(c); } +void ModeManager::StackerDel(Mode *m) +{ + for (std::map<User *, StackerInfo *>::const_iterator it = UserStackerObjects.begin(), it_end = UserStackerObjects.end(); it != it_end;) + { + StackerInfo *si = it->second; + ++it; + + for (std::list<std::pair<Mode *, Anope::string> >::iterator it2 = si->AddModes.begin(), it2_end = si->AddModes.end(); it2 != it2_end;) + { + Mode *mode = it2->first; + ++it2; + + if (mode == m) + si->AddModes.erase(it2); + } + + for (std::list<std::pair<Mode *, Anope::string> >::iterator it2 = si->DelModes.begin(), it2_end = si->DelModes.end(); it2 != it2_end;) + { + Mode *mode = it2->first; + ++it2; + + if (mode == m) + si->DelModes.erase(it2); + } + } + + for (std::map<Channel *, StackerInfo *>::const_iterator it = ChannelStackerObjects.begin(), it_end = ChannelStackerObjects.end(); it != it_end;) + { + StackerInfo *si = it->second; + ++it; + + for (std::list<std::pair<Mode *, Anope::string> >::iterator it2 = si->AddModes.begin(), it2_end = si->AddModes.end(); it2 != it2_end;) + { + Mode *mode = it2->first; + ++it2; + + if (mode == m) + si->AddModes.erase(it2); + } + + for (std::list<std::pair<Mode *, Anope::string> >::iterator it2 = si->DelModes.begin(), it2_end = si->DelModes.end(); it2 != it2_end;) + { + Mode *mode = it2->first; + ++it2; + + if (mode == m) + si->DelModes.erase(it2); + } + } +} + +void ModeManager::UpdateDefaultMLock(ServerConfig *config) +{ + for (ChannelInfo::ModeList::iterator it = DefaultModeLocks.begin(), it_end = DefaultModeLocks.end(); it != it_end; ++it) + delete it->second; + DefaultModeLocks.clear(); + + Anope::string modes; + spacesepstream sep(config->MLock); + sep.GetToken(modes); + + int adding = -1; + for (unsigned i = 0, end_mode = modes.length(); i < end_mode; ++i) + { + if (modes[i] == '+') + adding = 1; + else if (modes[i] == '-') + adding = 0; + else if (adding != -1) + { + ChannelMode *cm = ModeManager::FindChannelModeByChar(modes[i]); + + if (cm && cm->type != MODE_STATUS) + { + Anope::string param; + if (adding == 1 && cm->type != MODE_REGULAR && !sep.GetToken(param)) // MODE_LIST OR MODE_PARAM + { + Log() << "Warning: Got default mlock mode " << cm->mchar << " with no param?"; + continue; + } + + if (cm->type != MODE_LIST) // Only MODE_LIST can have duplicates + { + ChannelInfo::ModeList::iterator it = DefaultModeLocks.find(cm->name); + if (it != DefaultModeLocks.end()) + { + delete it->second; + DefaultModeLocks.erase(it); + } + } + DefaultModeLocks.insert(std::make_pair(cm->name, new ModeLock(NULL, adding == 1, cm->name, param))); + } + } + } + + /* Set Bot Modes */ + DefaultBotModes.ClearFlags(); + for (unsigned i = 0; i < config->BotModes.length(); ++i) + { + ChannelMode *cm = ModeManager::FindChannelModeByChar(config->BotModes[i]); + + if (cm && cm->type == MODE_STATUS) + DefaultBotModes.SetFlag(cm->name); + } +} + +Entry::Entry(ChannelModeName mode, const Anope::string &_host) : modename(mode) +{ + this->SetFlag(ENTRYTYPE_NONE); + this->cidr_len = 0; + this->mask = _host; + + Anope::string _nick, _user, _realhost; + size_t at = _host.find('@'); + if (at != Anope::string::npos) + { + _realhost = _host.substr(at + 1); + Anope::string _nickident = _host.substr(0, at); + + size_t ex = _nickident.find('!'); + if (ex != Anope::string::npos) + { + _user = _nickident.substr(ex + 1); + _nick = _nickident.substr(0, ex); + } + else + _user = _nickident; + } + else + _realhost = _host; + + if (!_nick.empty() && _nick.find_first_not_of("*") != Anope::string::npos) + { + this->nick = _nick; + if (_nick.find_first_of("*?") != Anope::string::npos) + this->SetFlag(ENTRYTYPE_NICK_WILD); + else + this->SetFlag(ENTRYTYPE_NICK); + } + + if (!_user.empty() && _user.find_first_not_of("*") != Anope::string::npos) + { + this->user = _user; + if (_user.find_first_of("*?") != Anope::string::npos) + this->SetFlag(ENTRYTYPE_USER_WILD); + else + this->SetFlag(ENTRYTYPE_USER); + } + + if (!_realhost.empty() && _realhost.find_first_not_of("*") != Anope::string::npos) + { + size_t sl = _realhost.find_last_of('/'); + if (sl != Anope::string::npos) + { + try + { + sockaddrs addr(_realhost.substr(0, sl)); + /* If we got here, _realhost is a valid IP */ + + Anope::string cidr_range = _realhost.substr(sl + 1); + if (cidr_range.is_pos_number_only()) + { + _realhost = _realhost.substr(0, sl); + this->cidr_len = convertTo<unsigned int>(cidr_range); + this->SetFlag(ENTRYTYPE_CIDR); + Log(LOG_DEBUG) << "Ban " << _realhost << " has cidr " << static_cast<unsigned int>(this->cidr_len); + } + } + catch (const SocketException &) { } + } + + this->host = _realhost; + + if (!this->HasFlag(ENTRYTYPE_CIDR)) + { + if (_realhost.find_first_of("*?") != Anope::string::npos) + this->SetFlag(ENTRYTYPE_HOST_WILD); + else + this->SetFlag(ENTRYTYPE_HOST); + } + } +} + +const Anope::string Entry::GetMask() +{ + return this->mask; +} + +bool Entry::Matches(const User *u, bool full) const +{ + bool ret = true; + + if (this->HasFlag(ENTRYTYPE_CIDR)) + { + try + { + if (full) + { + cidr cidr_mask(this->host, this->cidr_len); + sockaddrs addr(u->ip); + if (!cidr_mask.match(addr)) + ret = false; + } + /* If we're not matching fully and their displayed host isnt their IP */ + else if (u->ip != u->GetDisplayedHost()) + ret = false; + } + catch (const SocketException &) + { + ret = false; + } + } + if (this->HasFlag(ENTRYTYPE_NICK) && !this->nick.equals_ci(u->nick)) + ret = false; + if (this->HasFlag(ENTRYTYPE_USER) && !this->user.equals_ci(u->GetVIdent()) && (!full || + !this->user.equals_ci(u->GetIdent()))) + ret = false; + if (this->HasFlag(ENTRYTYPE_HOST) && !this->host.equals_ci(u->GetDisplayedHost()) && (!full || + (!this->host.equals_ci(u->host) && !this->host.equals_ci(u->chost) && !this->host.equals_ci(u->vhost) && + !this->host.equals_ci(u->ip)))) + ret = false; + if (this->HasFlag(ENTRYTYPE_NICK_WILD) && !Anope::Match(u->nick, this->nick)) + ret = false; + if (this->HasFlag(ENTRYTYPE_USER_WILD) && !Anope::Match(u->GetVIdent(), this->user) && (!full || + !Anope::Match(u->GetIdent(), this->user))) + ret = false; + if (this->HasFlag(ENTRYTYPE_HOST_WILD) && !Anope::Match(u->GetDisplayedHost(), this->host) && (!full || + (!Anope::Match(u->host, this->host) && !Anope::Match(u->chost, this->host) && + !Anope::Match(u->vhost, this->host) && !Anope::Match(u->ip, this->host)))) + ret = false; + + ChannelMode *cm = ModeManager::FindChannelModeByName(this->modename); + if (cm != NULL && cm->type == MODE_LIST) + { + ChannelModeList *cml = anope_dynamic_static_cast<ChannelModeList *>(cm); + if (cml->Matches(u, this)) + ret = true; + } + + return ret; +} + diff --git a/src/module.cpp b/src/module.cpp index e69b7c6a3..3c3b8fdd1 100644 --- a/src/module.cpp +++ b/src/module.cpp @@ -4,13 +4,13 @@ * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ - #include "services.h" #include "modules.h" -#include "extern.h" #include "dns.h" +#include "language.h" #ifdef GETTEXT_FOUND # include <libintl.h> @@ -26,19 +26,19 @@ Module::Module(const Anope::string &modname, const Anope::string &, ModType modt if (ModuleManager::FindModule(this->name)) throw CoreException("Module already exists!"); - if (nothird && modtype == THIRD) + if (Anope::NoThird && modtype == THIRD) throw ModuleException("Third party modules may not be loaded"); - Modules.push_back(this); + ModuleManager::Modules.push_back(this); #if GETTEXT_FOUND - for (unsigned i = 0; i < languages.size(); ++i) - if (IsFile(locale_dir + "/" + languages[i] + "/LC_MESSAGES/" + modname + ".mo")) + for (unsigned i = 0; i < Language::Languages.size(); ++i) + if (Anope::IsFile(Anope::LocaleDir + "/" + Language::Languages[i] + "/LC_MESSAGES/" + modname + ".mo")) { - if (!bindtextdomain(this->name.c_str(), locale_dir.c_str())) + if (!bindtextdomain(this->name.c_str(), Anope::LocaleDir.c_str())) Log() << "Error calling bindtextdomain, " << Anope::LastError(); else - domains.push_back(modname); + Language::Domains.push_back(modname); break; } #endif @@ -46,22 +46,22 @@ Module::Module(const Anope::string &modname, const Anope::string &, ModType modt Module::~Module() { - if (DNSEngine) - DNSEngine->Cleanup(this); + if (DNS::Engine) + DNS::Engine->Cleanup(this); /* Detach all event hooks for this module */ ModuleManager::DetachAll(this); /* Clear any active callbacks this module has */ ModuleManager::ClearCallBacks(this); IdentifyRequest::ModuleUnload(this); - std::list<Module *>::iterator it = std::find(Modules.begin(), Modules.end(), this); - if (it != Modules.end()) - Modules.erase(it); + std::list<Module *>::iterator it = std::find(ModuleManager::Modules.begin(), ModuleManager::Modules.end(), this); + if (it != ModuleManager::Modules.end()) + ModuleManager::Modules.erase(it); #if GETTEXT_FOUND - std::vector<Anope::string>::iterator dit = std::find(domains.begin(), domains.end(), this->name); - if (dit != domains.end()) - domains.erase(dit); + std::vector<Anope::string>::iterator dit = std::find(Language::Domains.begin(), Language::Domains.end(), this->name); + if (dit != Language::Domains.end()) + Language::Domains.erase(dit); #endif } @@ -85,26 +85,38 @@ void Module::SetAuthor(const Anope::string &nauthor) this->author = nauthor; } -ModuleVersion::ModuleVersion(int vMajor, int vMinor, int vPatch) : Major(vMajor), Minor(vMinor), Patch(vPatch) +IRCDProto *Module::GetIRCDProto() { + return NULL; } -ModuleVersion::~ModuleVersion() +ModuleVersion::ModuleVersion(int maj, int min, int pa) : version_major(maj), version_minor(min), version_patch(pa) { } int ModuleVersion::GetMajor() const { - return this->Major; + return this->version_major; } int ModuleVersion::GetMinor() const { - return this->Minor; + return this->version_minor; } int ModuleVersion::GetPatch() const { - return this->Patch; + return this->version_patch; +} + +CallBack::CallBack(Module *mod, long time_from_now, time_t now, bool repeating) : Timer(time_from_now, now, repeating), m(mod) +{ +} + +CallBack::~CallBack() +{ + std::list<CallBack *>::iterator it = std::find(m->callbacks.begin(), m->callbacks.end(), this); + if (it != m->callbacks.end()) + m->callbacks.erase(it); } diff --git a/src/modulemanager.cpp b/src/modulemanager.cpp index 360a0d34b..5e2165e30 100644 --- a/src/modulemanager.cpp +++ b/src/modulemanager.cpp @@ -4,11 +4,11 @@ * Contact us at team@anope.org * * Please read COPYING and README for further details. + * */ #include "services.h" #include "modules.h" -#include "extern.h" #include "users.h" #include "regchannel.h" @@ -20,11 +20,12 @@ #include <dlfcn.h> #endif +std::list<Module *> ModuleManager::Modules; std::vector<Module *> ModuleManager::EventHandlers[I_END]; void ModuleManager::CleanupRuntimeDirectory() { - Anope::string dirbuf = db_dir + "/runtime"; + Anope::string dirbuf = Anope::DataDir + "/runtime"; Log(LOG_DEBUG) << "Cleaning out Module run time directory (" << dirbuf << ") - this may take a moment please wait"; @@ -59,7 +60,7 @@ void ModuleManager::CleanupRuntimeDirectory() */ static ModuleReturn moduleCopyFile(const Anope::string &name, Anope::string &output) { - Anope::string input = modules_dir + "/modules/" + name + ".so"; + Anope::string input = Anope::ModuleDir + "/modules/" + name + ".so"; struct stat s; if (stat(input.c_str(), &s) == -1) @@ -114,7 +115,7 @@ static ModuleReturn moduleCopyFile(const Anope::string &name, Anope::string &out * This function will take a pointer from either dlsym or GetProcAddress and cast it in * a way that won't cause C++ warnings/errors to come up. */ -template <class TYPE> TYPE function_cast(void *symbol) +template <class TYPE> static TYPE function_cast(void *symbol) { union { @@ -136,7 +137,7 @@ ModuleReturn ModuleManager::LoadModule(const Anope::string &modname, User *u) Log(LOG_DEBUG) << "trying to load [" << modname << "]"; /* Generate the filename for the temporary copy of the module */ - Anope::string pbuf = db_dir + "/runtime/" + modname + ".so.XXXXXX"; + Anope::string pbuf = Anope::DataDir + "/runtime/" + modname + ".so.XXXXXX"; /* Don't skip return value checking! -GD */ ModuleReturn ret = moduleCopyFile(modname, pbuf); @@ -219,12 +220,6 @@ ModuleReturn ModuleManager::LoadModule(const Anope::string &modname, User *u) else Log(LOG_DEBUG_2) << "Module " << modname << " is compiled against current version of Anope " << Anope::VersionShort(); - if (m->type == PROTOCOL && ModuleManager::FindFirstOf(PROTOCOL) != m) - { - DeleteModule(m); - Log() << "You cannot load two protocol modules"; - return MOD_ERR_UNKNOWN; - } Log(LOG_DEBUG) << "Module loaded."; FOREACH_MOD(I_OnModuleLoad, OnModuleLoad(u, m)); @@ -455,17 +450,12 @@ bool ModuleManager::SetPriority(Module *mod, Implementation i, Priority s, Modul return true; } -/** Delete all callbacks attached to a module - * @param m The module - */ void ModuleManager::ClearCallBacks(Module *m) { - while (!m->CallBacks.empty()) - delete m->CallBacks.front(); + while (!m->callbacks.empty()) + delete m->callbacks.front(); } -/** Unloading all modules except the protocol module. - */ void ModuleManager::UnloadAll() { std::vector<Anope::string> modules[MT_END]; diff --git a/src/modules.cpp b/src/modules.cpp deleted file mode 100644 index 453a89a1a..000000000 --- a/src/modules.cpp +++ /dev/null @@ -1,28 +0,0 @@ -/* Modular support - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - - -#include "services.h" -#include "modules.h" - -std::list<Module *> Modules; - -CallBack::CallBack(Module *mod, long time_from_now, time_t now, bool repeating) : Timer(time_from_now, now, repeating), m(mod) -{ -} - -CallBack::~CallBack() -{ - std::list<CallBack *>::iterator it = std::find(m->CallBacks.begin(), m->CallBacks.end(), this); - if (it != m->CallBacks.end()) - m->CallBacks.erase(it); -} - diff --git a/src/nickalias.cpp b/src/nickalias.cpp index 0268b98be..f163c145f 100644 --- a/src/nickalias.cpp +++ b/src/nickalias.cpp @@ -7,9 +7,9 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ - #include "services.h" #include "account.h" #include "modules.h" @@ -19,17 +19,9 @@ #include "servers.h" #include "config.h" -serialize_checker<nickalias_map> NickAliasList("NickAlias"); +Serialize::Checker<nickalias_map> NickAliasList("NickAlias"); -class NickServHeld; -typedef std::map<Anope::string, NickServHeld *> nickservheld_map; -static nickservheld_map NickServHelds; - -/** Default constructor - * @param nick The nick - * @param nickcore The nickcore for this nick - */ -NickAlias::NickAlias(const Anope::string &nickname, NickCore* nickcore) : Serializable("NickAlias"), Flags<NickNameFlag, NS_END>(NickNameFlagStrings) +NickAlias::NickAlias(const Anope::string &nickname, NickCore* nickcore) : Serializable("NickAlias") { if (nickname.empty()) throw CoreException("Empty nick passed to NickAlias constructor"); @@ -57,8 +49,6 @@ NickAlias::NickAlias(const Anope::string &nickname, NickCore* nickcore) : Serial } } -/** Default destructor - */ NickAlias::~NickAlias() { FOREACH_MOD(I_OnDelNick, OnDelNick(this)); @@ -67,19 +57,19 @@ NickAlias::~NickAlias() if (this->nc) { /* Next: see if our core is still useful. */ - std::list<serialize_obj<NickAlias> >::iterator it = std::find(this->nc->aliases.begin(), this->nc->aliases.end(), this); + std::list<Serialize::Reference<NickAlias> >::iterator it = std::find(this->nc->aliases.begin(), this->nc->aliases.end(), this); if (it != this->nc->aliases.end()) this->nc->aliases.erase(it); if (this->nc->aliases.empty()) { - this->nc->destroy(); + this->nc->Destroy(); this->nc = NULL; } else { /* Display updating stuff */ if (this->nick.equals_ci(this->nc->display)) - change_core_display(this->nc); + this->nc->SetDisplay(this->nc->aliases.front()); } } @@ -87,19 +77,15 @@ NickAlias::~NickAlias() NickAliasList->erase(this->nick); } -/** Release a nick from being held. This can be called from the core (ns_release) - * or from a timer used when forcing clients off of nicks. Note that if this is called - * from a timer, ircd->svshold is NEVER true - */ void NickAlias::Release() { if (this->HasFlag(NS_HELD)) { - if (ircdproto->CanSVSHold) - ircdproto->SendSVSHoldDel(this->nick); + if (IRCD->CanSVSHold) + IRCD->SendSVSHoldDel(this->nick); else { - User *u = finduser(this->nick); + User *u = User::Find(this->nick); if (u && u->server == Me) { delete u; @@ -114,12 +100,14 @@ void NickAlias::Release() */ class NickServHeld : public Timer { - dynamic_reference<NickAlias> na; + static std::map<Anope::string, NickServHeld *> NickServHelds; + + Reference<NickAlias> na; Anope::string nick; public: NickServHeld(NickAlias *n, long l) : Timer(l), na(n), nick(na->nick) { - nickservheld_map::iterator nit = NickServHelds.find(na->nick); + std::map<Anope::string, NickServHeld *>::iterator nit = NickServHelds.find(na->nick); if (nit != NickServHelds.end()) delete nit->second; @@ -137,6 +125,7 @@ class NickServHeld : public Timer na->UnsetFlag(NS_HELD); } }; +std::map<Anope::string, NickServHeld *> NickServHeld::NickServHelds; /** Timers for releasing nicks to be available for use */ @@ -146,27 +135,25 @@ class CoreExport NickServRelease : public User, public Timer Anope::string nick; public: - /** Default constructor + /** Constructor * @param na The nick * @param delay The delay before the nick is released */ - NickServRelease(NickAlias *na, time_t delay) : User(na->nick, Config->NSEnforcerUser, Config->NSEnforcerHost, "", "", Me, "Services Enforcer", Anope::CurTime, "", ts6_uid_retrieve()), Timer(delay), nick(na->nick) + NickServRelease(NickAlias *na, time_t delay) : User(na->nick, Config->NSEnforcerUser, Config->NSEnforcerHost, "", "", Me, "Services Enforcer", Anope::CurTime, "", Servers::TS6_UID_Retrieve()), Timer(delay), nick(na->nick) { /* Erase the current release timer and use the new one */ std::map<Anope::string, NickServRelease *>::iterator nit = NickServReleases.find(this->nick); if (nit != NickServReleases.end()) { - ircdproto->SendQuit(nit->second, ""); + IRCD->SendQuit(nit->second, ""); delete nit->second; } NickServReleases.insert(std::make_pair(this->nick, this)); - ircdproto->SendClientIntroduction(this); + IRCD->SendClientIntroduction(this); } - /** Default destructor - */ virtual ~NickServRelease() { NickServReleases.erase(this->nick); @@ -177,15 +164,11 @@ class CoreExport NickServRelease : public User, public Timer */ void Tick(time_t t) { - ircdproto->SendQuit(this, ""); + IRCD->SendQuit(this, ""); } }; std::map<Anope::string, NickServRelease *> NickServRelease::NickServReleases; -/** Called when a user gets off this nick - * See the comment in users.cpp for User::Collide() - * @param u The user - */ void NickAlias::OnCancel(User *) { if (this->HasFlag(NS_COLLIDED)) @@ -195,8 +178,8 @@ void NickAlias::OnCancel(User *) new NickServHeld(this, Config->NSReleaseTimeout); - if (ircdproto->CanSVSHold) - ircdproto->SendSVSHold(this->nick); + if (IRCD->CanSVSHold) + IRCD->SendSVSHold(this->nick); else new NickServRelease(this, Config->NSReleaseTimeout); } @@ -243,17 +226,29 @@ time_t NickAlias::GetVhostCreated() const return this->vhost_created; } -Serialize::Data NickAlias::serialize() const +NickAlias *NickAlias::Find(const Anope::string &nick) +{ + nickalias_map::const_iterator it = NickAliasList->find(nick); + if (it != NickAliasList->end()) + { + it->second->QueueUpdate(); + return it->second; + } + + return NULL; +} + +Serialize::Data NickAlias::Serialize() const { Serialize::Data data; - data["nick"].setMax(Config->NickLen) << this->nick; + data["nick"].SetMax(Config->NickLen) << this->nick; data["last_quit"] << this->last_quit; data["last_realname"] << this->last_realname; data["last_usermask"] << this->last_usermask; data["last_realhost"] << this->last_realhost; - data["time_registered"].setType(Serialize::DT_INT) << this->time_registered; - data["last_seen"].setType(Serialize::DT_INT) << this->last_seen; + data["time_registered"].SetType(Serialize::DT_INT) << this->time_registered; + data["last_seen"].SetType(Serialize::DT_INT) << this->last_seen; data["nc"] << this->nc->display; data["flags"] << this->ToString(); @@ -268,9 +263,9 @@ Serialize::Data NickAlias::serialize() const return data; } -Serializable* NickAlias::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* NickAlias::Unserialize(Serializable *obj, Serialize::Data &data) { - NickCore *core = findcore(data["nc"].astr()); + NickCore *core = NickCore::Find(data["nc"].astr()); if (core == NULL) return NULL; @@ -282,14 +277,14 @@ Serializable* NickAlias::unserialize(Serializable *obj, Serialize::Data &data) if (na->nc != core) { - std::list<serialize_obj<NickAlias> >::iterator it = std::find(na->nc->aliases.begin(), na->nc->aliases.end(), na); + std::list<Serialize::Reference<NickAlias> >::iterator it = std::find(na->nc->aliases.begin(), na->nc->aliases.end(), na); if (it != na->nc->aliases.end()) na->nc->aliases.erase(it); if (na->nc->aliases.empty()) delete na->nc; else if (na->nick.equals_ci(na->nc->display)) - change_core_display(na->nc); + na->nc->SetDisplay(na->nc->aliases.front()); na->nc = core; core->aliases.push_back(na); diff --git a/src/nickcore.cpp b/src/nickcore.cpp index 0e637d0cf..f9ac3ef6c 100644 --- a/src/nickcore.cpp +++ b/src/nickcore.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -14,12 +15,21 @@ #include "account.h" #include "config.h" -serialize_checker<nickcore_map> NickCoreList("NickCore"); +Serialize::Checker<nickcore_map> NickCoreList("NickCore"); -/** Default constructor - * @param display The display nick - */ -NickCore::NickCore(const Anope::string &coredisplay) : Serializable("NickCore"), Flags<NickCoreFlag, NI_END>(NickCoreFlagStrings) +static const Anope::string NickNameFlagStrings[] = { + "BEGIN", "NO_EXPIRE", "HELD", "COLLIDED", "" +}; +template<> const Anope::string* Flags<NickNameFlag>::flags_strings = NickNameFlagStrings; + +static const Anope::string NickCoreFlagStrings[] = { + "BEGIN", "KILLPROTECT", "SECURE", "MSG", "MEMO_HARDMAX", "MEMO_SIGNON", "MEMO_RECEIVE", + "PRIVATE", "HIDE_EMAIL", "HIDE_MASK", "HIDE_QUIT", "KILL_QUICK", "KILL_IMMED", + "MEMO_MAIL", "HIDE_STATUS", "SUSPENDED", "AUTOOP", "UNCONFIRMED", "STATS", "" +}; +template<> const Anope::string* Flags<NickCoreFlag>::flags_strings = NickCoreFlagStrings; + +NickCore::NickCore(const Anope::string &coredisplay) : Serializable("NickCore") { if (coredisplay.empty()) throw CoreException("Empty display passed to NickCore constructor"); @@ -43,12 +53,17 @@ NickCore::NickCore(const Anope::string &coredisplay) : Serializable("NickCore"), Log(LOG_DEBUG) << "Duplicate account " << coredisplay << " in nickcore table?"; } -/** Default destructor - */ NickCore::~NickCore() { FOREACH_MOD(I_OnDelCore, OnDelCore(this)); + for (std::list<User *>::iterator it = this->users.begin(); it != this->users.end();) + { + User *user = *it++; + user->Logout(); + } + this->users.clear(); + /* Remove the core from the list */ NickCoreList->erase(this->display); @@ -58,16 +73,16 @@ NickCore::~NickCore() if (!this->memos.memos->empty()) { for (unsigned i = 0, end = this->memos.memos->size(); i < end; ++i) - this->memos.GetMemo(i)->destroy(); + this->memos.GetMemo(i)->Destroy(); this->memos.memos->clear(); } } -Serialize::Data NickCore::serialize() const +Serialize::Data NickCore::Serialize() const { Serialize::Data data; - data["display"].setMax(Config->NickLen) << this->display; + data["display"].SetMax(Config->NickLen) << this->display; data["pass"] << this->pass; data["email"] << this->email; data["greet"] << this->greet; @@ -84,7 +99,7 @@ Serialize::Data NickCore::serialize() const return data; } -Serializable* NickCore::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* NickCore::Unserialize(Serializable *obj, Serialize::Data &data) { NickCore *nc; @@ -127,6 +142,21 @@ Serializable* NickCore::unserialize(Serializable *obj, Serialize::Data &data) return nc; } +void NickCore::SetDisplay(const NickAlias *na) +{ + if (na->nc != this || na->nick == this->display) + return; + + FOREACH_MOD(I_OnChangeCoreDisplay, OnChangeCoreDisplay(this, na->nick)); + + /* Remove the core from the list */ + NickCoreList->erase(this->display); + + this->display = na->nick; + + (*NickCoreList)[this->display] = this; +} + bool NickCore::IsServicesOper() const { return this->o != NULL; @@ -171,6 +201,23 @@ void NickCore::ClearAccess() this->access.clear(); } +bool NickCore::IsOnAccess(const User *u) const +{ + Anope::string buf = u->GetIdent() + "@" + u->host, buf2, buf3; + if (!u->vhost.empty()) + buf2 = u->GetIdent() + "@" + u->vhost; + if (!u->GetCloakedHost().empty()) + buf3 = u->GetIdent() + "@" + u->GetCloakedHost(); + + for (unsigned i = 0, end = this->access.size(); i < end; ++i) + { + Anope::string a = this->GetAccess(i); + if (Anope::Match(buf, a) || (!buf2.empty() && Anope::Match(buf2, a)) || (!buf3.empty() && Anope::Match(buf3, a))) + return true; + } + return false; +} + void NickCore::AddCert(const Anope::string &entry) { this->cert.push_back(entry); @@ -209,3 +256,16 @@ void NickCore::ClearCert() FOREACH_MOD(I_OnNickClearCert, OnNickClearCert(this)); this->cert.clear(); } + +NickCore* NickCore::Find(const Anope::string &nick) +{ + nickcore_map::const_iterator it = NickCoreList->find(nick); + if (it != NickCoreList->end()) + { + it->second->QueueUpdate(); + return it->second; + } + + return NULL; +} + diff --git a/src/nickserv.cpp b/src/nickserv.cpp deleted file mode 100644 index 8b5c41df9..000000000 --- a/src/nickserv.cpp +++ /dev/null @@ -1,157 +0,0 @@ -/* NickServ functions. - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - -#include "services.h" -#include "account.h" -#include "modules.h" -#include "users.h" -#include "protocol.h" -#include "regchannel.h" - -NickAlias* findnick(const Anope::string &nick) -{ - nickalias_map::const_iterator it = NickAliasList->find(nick); - if (it != NickAliasList->end()) - { - it->second->QueueUpdate(); - return it->second; - } - - return NULL; -} - -/*************************************************************************/ - -NickCore* findcore(const Anope::string &nick) -{ - nickcore_map::const_iterator it = NickCoreList->find(nick); - if (it != NickCoreList->end()) - { - it->second->QueueUpdate(); - return it->second; - } - - return NULL; -} - -/** Is the user's address on the nickcores access list? - * @param u The user - * @param nc The nickcore - * @return true or false - */ -bool is_on_access(const User *u, const NickCore *nc) -{ - if (!u || !nc || nc->access.empty()) - return false; - - Anope::string buf = u->GetIdent() + "@" + u->host, buf2, buf3; - if (!u->vhost.empty()) - buf2 = u->GetIdent() + "@" + u->vhost; - if (!u->GetCloakedHost().empty()) - buf3 = u->GetIdent() + "@" + u->GetCloakedHost(); - - for (unsigned i = 0, end = nc->access.size(); i < end; ++i) - { - Anope::string access = nc->GetAccess(i); - if (Anope::Match(buf, access) || (!buf2.empty() && Anope::Match(buf2, access)) || (!buf3.empty() && Anope::Match(buf3, access))) - return true; - } - return false; -} - -/*************************************************************************/ - -/* Sets nc->display to newdisplay. If newdisplay is NULL, it will change - * it to the first alias in the list. - */ - -void change_core_display(NickCore *nc, const Anope::string &newdisplay) -{ - FOREACH_MOD(I_OnChangeCoreDisplay, OnChangeCoreDisplay(nc, newdisplay)); - - /* Remove the core from the list */ - NickCoreList->erase(nc->display); - - nc->display = newdisplay; - - (*NickCoreList)[nc->display] = nc; -} - -void change_core_display(NickCore *nc) -{ - const NickAlias *na; - if (nc->aliases.empty()) - return; - na = nc->aliases.front(); - change_core_display(nc, na->nick); -} - -std::set<IdentifyRequest *> IdentifyRequest::requests; - -IdentifyRequest::IdentifyRequest(Module *o, const Anope::string &acc, const Anope::string &pass) : owner(o), account(acc), password(pass), dispatched(false), success(false) -{ - requests.insert(this); -} - -IdentifyRequest::~IdentifyRequest() -{ - requests.erase(this); -} - -void IdentifyRequest::Hold(Module *m) -{ - holds.insert(m); -} - -void IdentifyRequest::Release(Module *m) -{ - holds.erase(m); - if (holds.empty() && dispatched) - { - if (!success) - this->OnFail(); - delete this; - } -} - -void IdentifyRequest::Success(Module *m) -{ - if (!success) - { - this->OnSuccess(); - success = true; - } -} - -void IdentifyRequest::Dispatch() -{ - if (holds.empty()) - { - if (!success) - this->OnFail(); - delete this; - } - else - dispatched = true; -} - -void IdentifyRequest::ModuleUnload(Module *m) -{ - for (std::set<IdentifyRequest *>::iterator it = requests.begin(), it_end = requests.end(); it != it_end;) - { - IdentifyRequest *ir = *it; - ++it; - - ir->Release(m); - if (ir->owner == m) - delete ir; - } -} diff --git a/src/operserv.cpp b/src/operserv.cpp deleted file mode 100644 index f1c2edeea..000000000 --- a/src/operserv.cpp +++ /dev/null @@ -1,484 +0,0 @@ -/* OperServ functions. - * - * (C) 2003-2012 Anope Team - * Contact us at team@anope.org - * - * Please read COPYING and README for further details. - * - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. - */ - - -#include "services.h" -#include "modules.h" -#include "oper.h" -#include "users.h" -#include "extern.h" -#include "sockets.h" -#include "regexpr.h" -#include "config.h" -#include "commands.h" - -/* List of XLine managers we check users against in XLineManager::CheckAll */ -std::list<XLineManager *> XLineManager::XLineManagers; -serialize_checker<std::multimap<Anope::string, XLine *, ci::less> > XLineManager::XLinesByUID("XLine"); - -void XLine::InitRegex() -{ - if (!Config->RegexEngine.empty() && this->Mask.length() >= 2 && this->Mask[0] == '/' && this->Mask[this->Mask.length() - 1] == '/') - { - Anope::string stripped_mask = this->Mask.substr(1, this->Mask.length() - 2); - - service_reference<RegexProvider> provider("Regex", Config->RegexEngine); - if (provider) - { - try - { - this->regex = provider->Compile(stripped_mask); - } - catch (const RegexException &ex) - { - Log(LOG_DEBUG) << ex.GetReason(); - } - } - } -} - -XLine::XLine(const Anope::string &mask, const Anope::string &reason, const Anope::string &uid) : Serializable("XLine"), Mask(mask), By(Config->OperServ), Created(0), Expires(0), Reason(reason), UID(uid) -{ - regex = NULL; - manager = NULL; - - this->InitRegex(); -} - -XLine::XLine(const Anope::string &mask, const Anope::string &by, const time_t expires, const Anope::string &reason, const Anope::string &uid) : Serializable("XLine"), Mask(mask), By(by), Created(Anope::CurTime), Expires(expires), Reason(reason), UID(uid) -{ - regex = NULL; - manager = NULL; - - this->InitRegex(); -} - -XLine::~XLine() -{ - delete regex; -} - -Anope::string XLine::GetNick() const -{ - size_t nick_t = this->Mask.find('!'); - - if (nick_t == Anope::string::npos) - return ""; - - return this->Mask.substr(0, nick_t); -} - -Anope::string XLine::GetUser() const -{ - size_t user_t = this->Mask.find('!'), host_t = this->Mask.find('@'); - - if (host_t != Anope::string::npos) - { - if (user_t != Anope::string::npos && host_t > user_t) - return this->Mask.substr(user_t + 1, host_t - user_t - 1); - else - return this->Mask.substr(0, host_t); - } - else - return ""; -} - -Anope::string XLine::GetHost() const -{ - size_t host_t = this->Mask.find('@'), real_t = this->Mask.find('#'); - - if (host_t != Anope::string::npos) - { - if (real_t != Anope::string::npos && real_t > host_t) - return this->Mask.substr(host_t + 1, real_t - host_t - 1); - else - return this->Mask.substr(host_t + 1); - } - else - return ""; -} - -Anope::string XLine::GetReal() const -{ - size_t real_t = this->Mask.find('#'); - - if (real_t != Anope::string::npos) - return this->Mask.substr(real_t + 1); - else - return ""; -} - -Anope::string XLine::GetReason() const -{ - Anope::string r = this->Reason; - if (Config->AddAkiller && !this->By.empty()) - r = "[" + this->By + "] " + r; - if (!this->UID.empty()) - r += " (ID: " + this->UID + ")"; - return r; -} - -bool XLine::HasNickOrReal() const -{ - bool r = this->GetNick().find_first_not_of("?*") != Anope::string::npos; - r = r || this->GetReal().find_first_not_of("?*") != Anope::string::npos; - return r; -} - -bool XLine::IsRegex() const -{ - return !this->Mask.empty() && this->Mask[0] == '/' && this->Mask[this->Mask.length() - 1] == '/'; -} - -Serialize::Data XLine::serialize() const -{ - Serialize::Data data; - - data["mask"] << this->Mask; - data["by"] << this->By; - data["created"] << this->Created; - data["expires"] << this->Expires; - data["reason"] << this->Reason; - data["uid"] << this->UID; - if (this->manager) - data["manager"] << this->manager->name; - - return data; -} - -Serializable* XLine::unserialize(Serializable *obj, Serialize::Data &data) -{ - service_reference<XLineManager> xlm("XLineManager", data["manager"].astr()); - if (!xlm) - return NULL; - - XLine *xl; - if (obj) - { - xl = anope_dynamic_static_cast<XLine *>(obj); - data["mask"] >> xl->Mask; - data["by"] >> xl->By; - data["reason"] >> xl->Reason; - data["uid"] >> xl->UID; - - if (xlm != xl->manager) - { - xl->manager->DelXLine(xl); - xlm->AddXLine(xl); - } - } - else - { - time_t expires; - data["expires"] >> expires; - xl = new XLine(data["mask"].astr(), data["by"].astr(), expires, data["reason"].astr(), data["uid"].astr()); - xlm->AddXLine(xl); - } - - data["created"] >> xl->Created; - xl->manager = xlm; - - return xl; -} - -/** Register a XLineManager, places it in XLineManagers for use in XLineManager::CheckAll - * It is important XLineManagers are registered in the proper order. Eg, if you had one akilling - * clients and one handing them free olines, you would want the akilling one first. This way if a client - * matches an entry on both of the XLineManagers, they would be akilled. - * @param xlm THe XLineManager - */ -void XLineManager::RegisterXLineManager(XLineManager *xlm) -{ - XLineManagers.push_back(xlm); -} - -/** Unregister a XLineManager - * @param xlm The XLineManager - */ -void XLineManager::UnregisterXLineManager(XLineManager *xlm) -{ - std::list<XLineManager *>::iterator it = std::find(XLineManagers.begin(), XLineManagers.end(), xlm); - - if (it != XLineManagers.end()) - XLineManagers.erase(it); -} - -/* Check a user against all known XLineManagers - * @param u The user - * @return A pair of the XLineManager the user was found in and the XLine they matched, both may be NULL for no match - */ -void XLineManager::CheckAll(User *u) -{ - for (std::list<XLineManager *>::iterator it = XLineManagers.begin(), it_end = XLineManagers.end(); it != it_end; ++it) - { - XLineManager *xlm = *it; - - XLine *x = xlm->CheckAllXLines(u); - - if (x) - { - xlm->OnMatch(u, x); - break; - } - } -} - -Anope::string XLineManager::GenerateUID() -{ - Anope::string id; - int count = 0; - while (id.empty() || XLinesByUID->count(id) > 0) - { - if (++count > 10) - { - id.clear(); - Log(LOG_DEBUG) << "Unable to generate XLine UID"; - break; - } - - for (int i = 0; i < 10; ++i) - { - char c; - do - c = (rand() % 75) + 48; - while (!isupper(c) && !isdigit(c)); - id += c; - } - } - - return id; -} - -/** Constructor - */ -XLineManager::XLineManager(Module *creator, const Anope::string &xname, char t) : Service(creator, "XLineManager", xname), type(t), XLines("XLine") -{ -} - -/** Destructor - * Clears all XLines in this XLineManager - */ -XLineManager::~XLineManager() -{ - this->Clear(); -} - -/** The type of xline provided by this service - * @return The type - */ -const char &XLineManager::Type() -{ - return this->type; -} - -/** Get the number of XLines in this XLineManager - * @return The number of XLines - */ -size_t XLineManager::GetCount() const -{ - return this->XLines->size(); -} - -/** Get the XLine vector - * @return The vecotr - */ -const std::vector<XLine *> &XLineManager::GetList() const -{ - return this->XLines; -} - -/** Add an entry to this XLineManager - * @param x The entry - */ -void XLineManager::AddXLine(XLine *x) -{ - if (!x->UID.empty()) - XLinesByUID->insert(std::make_pair(x->UID, x)); - this->XLines->push_back(x); - x->manager = this; -} - -/** Delete an entry from this XLineManager - * @param x The entry - * @return true if the entry was found and deleted, else false - */ -bool XLineManager::DelXLine(XLine *x) -{ - std::vector<XLine *>::iterator it = std::find(this->XLines->begin(), this->XLines->end(), x); - - if (!x->UID.empty()) - { - std::multimap<Anope::string, XLine *, ci::less>::iterator it2 = XLinesByUID->find(x->UID), it3 = XLinesByUID->upper_bound(x->UID); - for (; it2 != XLinesByUID->end() && it2 != it3; ++it2) - if (it2->second == x) - { - XLinesByUID->erase(it2); - break; - } - } - - if (it != this->XLines->end()) - { - this->SendDel(x); - - x->destroy(); - this->XLines->erase(it); - - return true; - } - - return false; -} - -/** Gets an entry by index - * @param index The index - * @return The XLine, or NULL if the index is out of bounds - */ -XLine* XLineManager::GetEntry(unsigned index) -{ - if (index >= this->XLines->size()) - return NULL; - - XLine *x = this->XLines->at(index); - x->QueueUpdate(); - return x; -} - -/** Clear the XLine vector - */ -void XLineManager::Clear() -{ - for (unsigned i = 0; i < this->XLines->size(); ++i) - { - XLine *x = this->XLines->at(i); - if (!x->UID.empty()) - XLinesByUID->erase(x->UID); - x->destroy(); - } - this->XLines->clear(); -} - -/** Checks if a mask can/should be added to the XLineManager - * @param source The source adding the mask. - * @param mask The mask - * @param expires When the mask would expire - * @param reason the reason - * @return true if the mask can be added - */ -bool XLineManager::CanAdd(CommandSource &source, const Anope::string &mask, time_t expires, const Anope::string &reason) -{ - for (unsigned i = this->GetCount(); i > 0; --i) - { - XLine *x = this->GetEntry(i - 1); - - if (x->Mask.equals_ci(mask)) - { - if (!x->Expires || x->Expires >= expires) - { - if (x->Reason != reason) - { - x->Reason = reason; - source.Reply(_("Reason for %s updated."), x->Mask.c_str()); - } - else - source.Reply(_("%s already exists."), mask.c_str()); - } - else - { - x->Expires = expires; - if (x->Reason != reason) - { - x->Reason = reason; - source.Reply(_("Expiry and reason updated for %s."), x->Mask.c_str()); - } - else - source.Reply(_("Expiry for %s updated."), x->Mask.c_str()); - } - - return false; - } - else if (Anope::Match(mask, x->Mask) && (!x->Expires || x->Expires >= expires)) - { - source.Reply(_("%s is already covered by %s."), mask.c_str(), x->Mask.c_str()); - return false; - } - else if (Anope::Match(x->Mask, mask) && (!expires || x->Expires <= expires)) - { - source.Reply(_("Removing %s because %s covers it."), x->Mask.c_str(), mask.c_str()); - this->DelXLine(x); - } - } - - return true; -} - -/** Checks if this list has an entry - * @param mask The mask - * @return The XLine the user matches, or NULL - */ -XLine* XLineManager::HasEntry(const Anope::string &mask) -{ - std::multimap<Anope::string, XLine *, ci::less>::iterator it = XLinesByUID->find(mask); - if (it != XLinesByUID->end()) - for (std::multimap<Anope::string, XLine *, ci::less>::iterator it2 = XLinesByUID->upper_bound(mask); it != it2; ++it) - if (it->second->manager == NULL || it->second->manager == this) - { - it->second->QueueUpdate(); - return it->second; - } - for (unsigned i = 0, end = this->XLines->size(); i < end; ++i) - { - XLine *x = this->XLines->at(i); - - if (x->Mask.equals_ci(mask)) - { - x->QueueUpdate(); - return x; - } - } - - return NULL; -} - -/** Check a user against all of the xlines in this XLineManager - * @param u The user - * @return The xline the user marches, if any. - */ -XLine *XLineManager::CheckAllXLines(User *u) -{ - for (unsigned i = this->XLines->size(); i > 0; --i) - { - XLine *x = this->XLines->at(i - 1); - - if (x->Expires && x->Expires < Anope::CurTime) - { - this->OnExpire(x); - this->DelXLine(x); - continue; - } - - if (this->Check(u, x)) - { - this->OnMatch(u, x); - return x; - } - } - - return NULL; -} - -/** Called when an XLine expires - * @param x The xline - */ -void XLineManager::OnExpire(const XLine *x) -{ -} - diff --git a/src/opertype.cpp b/src/opertype.cpp index b719b4cc7..f468e0c13 100644 --- a/src/opertype.cpp +++ b/src/opertype.cpp @@ -1,8 +1,10 @@ /* + * * Copyright (C) 2008-2011 Robin Burchell <w00t@inspircd.org> * Copyright (C) 2008-2012 Anope Team <team@anope.org> * * Please read COPYING and README for further details. + * */ #include "services.h" diff --git a/src/process.cpp b/src/process.cpp index dfc4f5563..cc2b32a27 100644 --- a/src/process.cpp +++ b/src/process.cpp @@ -11,16 +11,12 @@ #include "services.h" #include "modules.h" -#include "extern.h" #include "protocol.h" #include "servers.h" #include "users.h" #include "regchannel.h" -/** Main process routine - * @param buffer A raw line from the uplink to do things with - */ -void process(const Anope::string &buffer) +void Anope::Process(const Anope::string &buffer) { /* If debugging, log the buffer */ Log(LOG_RAWIO) << "Received: " << buffer; @@ -46,12 +42,11 @@ void process(const Anope::string &buffer) } spacesepstream buf_sep(buf); - Anope::string buf_token; Anope::string command = buf; - if (buf_sep.GetToken(buf_token)) - command = buf_token; + buf_sep.GetToken(command); + Anope::string buf_token; std::vector<Anope::string> params; while (buf_sep.GetToken(buf_token)) { @@ -67,7 +62,7 @@ void process(const Anope::string &buffer) params.push_back(buf_token); } - if (protocoldebug) + if (Anope::ProtocolDebug) { Log() << "Source : " << (source.empty() ? "No source" : source); Log() << "Command: " << command; @@ -79,29 +74,26 @@ void process(const Anope::string &buffer) Log() << "params " << i << ": " << params[i]; } - const std::vector<IRCDMessage *> *messages = IRCDMessage::Find(command); + static const Anope::string proto_name = ModuleManager::FindFirstOf(PROTOCOL) ? ModuleManager::FindFirstOf(PROTOCOL)->name : ""; + + // event - if (messages && !messages->empty()) + ServiceReference<IRCDMessage> m("IRCDMessage", proto_name + "/" + command.lower()); + if (!m) { - MessageSource src(source); + Log(LOG_DEBUG) << "unknown message from server (" << buffer << ")"; + return; + } - bool retVal = true; - /* Newer messages take priority */ - for (unsigned i = messages->size(); retVal && i > 0; --i) - { - IRCDMessage *m = messages->at(i - 1); + MessageSource src(source); - if (m->HasFlag(IRCDMESSAGE_SOFT_LIMIT) ? (params.size() < m->GetParamCount()) : (params.size() != m->GetParamCount())) - Log(LOG_DEBUG) << "invalid parameters for " << command << ": " << params.size() << " != " << m->GetParamCount(); - else if (m->HasFlag(IRCDMESSAGE_REQUIRE_USER) && !src.GetUser()) - Log(LOG_DEBUG) << "unexpected non-user source " << source << " for " << command; - else if (m->HasFlag(IRCDMESSAGE_REQUIRE_SERVER) && !source.empty() && !src.GetServer()) - Log(LOG_DEBUG) << "unexpected non-server soruce " << source << " for " << command; - else - retVal = m->Run(src, params); - } - } + if (m->HasFlag(IRCDMESSAGE_SOFT_LIMIT) ? (params.size() < m->GetParamCount()) : (params.size() != m->GetParamCount())) + Log(LOG_DEBUG) << "invalid parameters for " << command << ": " << params.size() << " != " << m->GetParamCount(); + else if (m->HasFlag(IRCDMESSAGE_REQUIRE_USER) && !src.GetUser()) + Log(LOG_DEBUG) << "unexpected non-user source " << source << " for " << command; + else if (m->HasFlag(IRCDMESSAGE_REQUIRE_SERVER) && !source.empty() && !src.GetServer()) + Log(LOG_DEBUG) << "unexpected non-server soruce " << source << " for " << command; else - Log(LOG_DEBUG) << "unknown message from server (" << buffer << ")"; + m->Run(src, params); } diff --git a/src/protocol.cpp b/src/protocol.cpp index 5d836b7f4..d3372731c 100644 --- a/src/protocol.cpp +++ b/src/protocol.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -17,10 +18,10 @@ #include "config.h" #include "uplink.h" #include "bots.h" -#include "extern.h" #include "channels.h" +#include "operserv.h" -IRCDProto *ircdproto; +IRCDProto *IRCD = NULL; IRCDProto::IRCDProto(const Anope::string &p) : proto_name(p) { @@ -29,13 +30,14 @@ IRCDProto::IRCDProto(const Anope::string &p) : proto_name(p) CanSVSO = CanCertFP = RequiresID = false; MaxModes = 3; - ircdproto = this; + if (IRCD == NULL) + IRCD = this; } IRCDProto::~IRCDProto() { - if (ircdproto == this) - ircdproto = NULL; + if (IRCD == this) + IRCD = NULL; } const Anope::string &IRCDProto::GetProtocolName() @@ -105,7 +107,7 @@ void IRCDProto::SendGlobopsInternal(const BotInfo *source, const Anope::string & void IRCDProto::SendCTCPInternal(const BotInfo *bi, const Anope::string &dest, const Anope::string &buf) { - Anope::string s = normalizeBuffer(buf); + Anope::string s = Anope::NormalizeBuffer(buf); this->SendNoticeInternal(bi, dest, "\1" + s + "\1"); } @@ -278,9 +280,9 @@ void IRCDProto::SendSquit(Server *s, const Anope::string &message) UplinkSocket::Message() << "SQUIT " << s->GetName() << " :" << message; } -void IRCDProto::SendChangeBotNick(const BotInfo *bi, const Anope::string &newnick) +void IRCDProto::SendNickChange(const User *u, const Anope::string &newnick) { - UplinkSocket::Message(bi) << "NICK " << newnick << " " << Anope::CurTime; + UplinkSocket::Message(u) << "NICK " << newnick << " " << Anope::CurTime; } void IRCDProto::SendForceNickChange(const User *u, const Anope::string &newnick, time_t when) @@ -308,6 +310,29 @@ void IRCDProto::SendNumeric(int numeric, const Anope::string &dest, const char * SendNumericInternal(numeric, dest, buf); } +bool IRCDProto::IsNickValid(const Anope::string &nick) +{ + /** + * RFC: defination of a valid nick + * nickname = ( letter / special ) ( letter / digit / special / "-" ) + * letter = A-Z / a-z + * digit = 0-9 + * special = [, ], \, `, _, ^, {, |, } + **/ + + if (nick.empty()) + return false; + + Anope::string special = "{}\\`_^{|}"; + + for (unsigned i = 0; i < nick.length(); ++i) + if (!(nick[i] >= 'A' && nick[i] <= 'Z') && !(nick[i] >= 'a' && nick[i] <= 'z') && special.find(nick[i]) == Anope::string::npos + && (!i || (!(nick[i] >= '0' && nick[i] <= '9') && nick[i] != '-'))) + return false; + + return true; +} + bool IRCDProto::IsChannelValid(const Anope::string &chan) { if (chan.empty() || chan[0] != '#' || chan.length() > Config->ChanLen) @@ -316,20 +341,59 @@ bool IRCDProto::IsChannelValid(const Anope::string &chan) return true; } +bool IRCDProto::IsIdentValid(const Anope::string &ident) +{ + if (ident.empty() || ident.length() > Config->UserLen) + return false; + + for (unsigned i = 0; i < ident.length(); ++i) + { + const char &c = ident[i]; + if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '.' || c == '-') + ; + else + return false; + } + + return true; +} + +bool IRCDProto::IsHostValid(const Anope::string &host) +{ + if (host.empty() || host.length() > Config->HostLen) + return false; + + if (Config->VhostDisallowBE.find_first_of(host[0]) != Anope::string::npos) + return false; + else if (Config->VhostDisallowBE.find_first_of(host[host.length() - 1]) != Anope::string::npos) + return false; + + int dots = 0; + for (unsigned i = 0; i < host.length(); ++i) + { + if (host[i] == '.') + ++dots; + if (Config->VhostChars.find_first_of(host[i]) == Anope::string::npos) + return false; + } + + return Config->VhostUndotted || dots > 0; +} + void IRCDProto::SendOper(User *u) { SendNumericInternal(381, u->GetUID(), ":You are now an IRC operator (set by services)"); - u->SetMode(findbot(Config->OperServ), UMODE_OPER); + u->SetMode(OperServ, UMODE_OPER); } MessageSource::MessageSource(const Anope::string &src) : source(src), u(NULL), s(NULL) { if (src.empty()) this->s = !Me->GetLinks().empty() ? Me->GetLinks().front() : NULL; - else if (ircdproto->RequiresID || src.find('.') != Anope::string::npos) + else if (IRCD->RequiresID || src.find('.') != Anope::string::npos) this->s = Server::Find(src); if (this->s == NULL) - this->u = finduser(src); + this->u = User::Find(src); } MessageSource::MessageSource(User *_u) : source(_u ? _u->nick : ""), u(_u), s(NULL) @@ -365,26 +429,8 @@ Server *MessageSource::GetServer() return this->s; } -std::map<Anope::string, std::vector<IRCDMessage *> > IRCDMessage::messages; - -const std::vector<IRCDMessage *> *IRCDMessage::Find(const Anope::string &name) -{ - std::map<Anope::string, std::vector<IRCDMessage *> >::iterator it = messages.find(name); - if (it != messages.end()) - return &it->second; - return NULL; -} - -IRCDMessage::IRCDMessage(const Anope::string &n, unsigned p) : name(n), param_count(p) -{ - messages[n].insert(messages[n].begin(), this); -} - -IRCDMessage::~IRCDMessage() +IRCDMessage::IRCDMessage(Module *o, const Anope::string &n, unsigned p) : Service(o, "IRCDMessage", o->name + "/" + n.lower()), name(n), param_count(p) { - std::vector<IRCDMessage *>::iterator it = std::find(messages[this->name].begin(), messages[this->name].end(), this); - if (it != messages[this->name].end()) - messages[this->name].erase(it); } unsigned IRCDMessage::GetParamCount() const diff --git a/src/regchannel.cpp b/src/regchannel.cpp index a559d3127..3075ea301 100644 --- a/src/regchannel.cpp +++ b/src/regchannel.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -17,26 +18,36 @@ #include "channels.h" #include "config.h" #include "bots.h" -#include "extern.h" #include "language.h" #include "servers.h" +#include "chanserv.h" + +Serialize::Checker<registered_channel_map> RegisteredChannelList("ChannelInfo"); + +static const Anope::string ChannelInfoFlagStrings[] = { + "BEGIN", "KEEPTOPIC", "SECUREOPS", "PRIVATE", "TOPICLOCK", "RESTRICTED", + "PEACE", "SECURE", "NO_EXPIRE", "MEMO_HARDMAX", "SECUREFOUNDER", + "SIGNKICK", "SIGNKICK_LEVEL", "SUSPENDED", "PERSIST", "STATS", "NOAUTOOP", "" +}; +template<> const Anope::string* Flags<ChannelInfoFlag>::flags_strings = ChannelInfoFlagStrings; -serialize_checker<registered_channel_map> RegisteredChannelList("ChannelInfo"); +static const Anope::string AutoKickFlagString[] = { "AK_ISNICK", "" }; +template<> const Anope::string* Flags<AutoKickFlag>::flags_strings = AutoKickFlagString; -Serialize::Data BadWord::serialize() const +Serialize::Data BadWord::Serialize() const { Serialize::Data data; - data["ci"].setMax(64)/*XXX*/ << this->ci->name; - data["word"].setMax(512) << this->word; - data["type"].setType(Serialize::DT_INT) << this->type; + data["ci"].SetMax(64)/*XXX*/ << this->ci->name; + data["word"].SetMax(512) << this->word; + data["type"].SetType(Serialize::DT_INT) << this->type; return data; } -Serializable* BadWord::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* BadWord::Unserialize(Serializable *obj, Serialize::Data &data) { - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (!ci) return NULL; @@ -56,42 +67,42 @@ Serializable* BadWord::unserialize(Serializable *obj, Serialize::Data &data) return bw; } -AutoKick::AutoKick() : Flags<AutoKickFlag>(AutoKickFlagString), Serializable("AutoKick") +AutoKick::AutoKick() : Serializable("AutoKick") { } -Serialize::Data AutoKick::serialize() const +Serialize::Data AutoKick::Serialize() const { Serialize::Data data; - data["ci"].setMax(64)/*XXX*/ << this->ci->name; + data["ci"].SetMax(64)/*XXX*/ << this->ci->name; if (this->HasFlag(AK_ISNICK) && this->nc) - data["nc"].setMax(Config->NickLen) << this->nc->display; + data["nc"].SetMax(Config->NickLen) << this->nc->display; else - data["mask"].setMax(Config->NickLen) << this->mask; + data["mask"].SetMax(Config->NickLen) << this->mask; data["reason"] << this->reason; data["creator"] << this->creator; - data["addtime"].setType(Serialize::DT_INT) << this->addtime; - data["last_used"].setType(Serialize::DT_INT) << this->last_used; + data["addtime"].SetType(Serialize::DT_INT) << this->addtime; + data["last_used"].SetType(Serialize::DT_INT) << this->last_used; data["flags"] << this->ToString(); return data; } -Serializable* AutoKick::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* AutoKick::Unserialize(Serializable *obj, Serialize::Data &data) { - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (!ci) return NULL; AutoKick *ak; - NickCore *nc = findcore(data["nc"].astr()); + NickCore *nc = NickCore::Find(data["nc"].astr()); if (obj) { ak = anope_dynamic_static_cast<AutoKick *>(obj); data["creator"] >> ak->creator; data["reason"] >> ak->reason; - ak->nc = findcore(data["nc"].astr()); + ak->nc = NickCore::Find(data["nc"].astr()); data["mask"] >> ak->mask; data["addtime"] >> ak->addtime; data["last_used"] >> ak->last_used; @@ -115,31 +126,33 @@ ModeLock::ModeLock(ChannelInfo *ch, bool s, ChannelModeName n, const Anope::stri { } -Serialize::Data ModeLock::serialize() const +Serialize::Data ModeLock::Serialize() const { Serialize::Data data; if (!this->ci) return data; - data["ci"].setMax(64)/*XXX*/ << this->ci->name; - data["set"].setMax(5) << this->set; - data["name"].setMax(64) << ChannelModeNameStrings[this->name]; - data["param"].setMax(512) << this->param; + const Anope::string* ChannelModeNameStrings = Flags<ChannelModeName>::GetFlagStrings(); + data["ci"].SetMax(64)/*XXX*/ << this->ci->name; + data["set"].SetMax(5) << this->set; + data["name"].SetMax(64) << ChannelModeNameStrings[this->name]; + data["param"].SetMax(512) << this->param; data["setter"] << this->setter; - data["created"].setType(Serialize::DT_INT) << this->created; + data["created"].SetType(Serialize::DT_INT) << this->created; return data; } -Serializable* ModeLock::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* ModeLock::Unserialize(Serializable *obj, Serialize::Data &data) { - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (!ci) return NULL; ChannelModeName name = CMODE_END; + const Anope::string* ChannelModeNameStrings = Flags<ChannelModeName>::GetFlagStrings(); for (unsigned i = 0; !ChannelModeNameStrings[i].empty(); ++i) if (ChannelModeNameStrings[i] == data["name"].astr()) { @@ -177,7 +190,7 @@ Serializable* ModeLock::unserialize(Serializable *obj, Serialize::Data &data) } } -Serialize::Data LogSetting::serialize() const +Serialize::Data LogSetting::Serialize() const { Serialize::Data data; @@ -191,14 +204,14 @@ Serialize::Data LogSetting::serialize() const data["method"] << method; data["extra"] << extra; data["creator"] << creator; - data["created"].setType(Serialize::DT_INT) << created; + data["created"].SetType(Serialize::DT_INT) << created; return data; } -Serializable* LogSetting::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* LogSetting::Unserialize(Serializable *obj, Serialize::Data &data) { - ChannelInfo *ci = cs_findchan(data["ci"].astr()); + ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr()); if (ci == NULL) return NULL; @@ -223,19 +236,16 @@ Serializable* LogSetting::unserialize(Serializable *obj, Serialize::Data &data) return ls; } -/** Default constructor - * @param chname The channel name - */ -ChannelInfo::ChannelInfo(const Anope::string &chname) : Serializable("ChannelInfo"), Flags<ChannelInfoFlag, CI_END>(ChannelInfoFlagStrings), +ChannelInfo::ChannelInfo(const Anope::string &chname) : Serializable("ChannelInfo"), access("ChanAccess"), akick("AutoKick"), - badwords("BadWord"), mode_locks("ModeLock"), log_settings("LogSetting"), botflags(BotServFlagStrings) + badwords("BadWord"), mode_locks("ModeLock"), log_settings("LogSetting") { if (chname.empty()) throw CoreException("Empty channel passed to ChannelInfo constructor"); this->founder = NULL; this->successor = NULL; - this->c = findchan(chname); + this->c = Channel::Find(chname); if (this->c) this->c->ci = this; this->capsmin = this->capspercent = 0; @@ -274,12 +284,9 @@ ChannelInfo::ChannelInfo(const Anope::string &chname) : Serializable("ChannelInf FOREACH_MOD(I_OnCreateChan, OnCreateChan(this)); } -/** Copy constructor - * @param ci The ChannelInfo to copy settings to - */ -ChannelInfo::ChannelInfo(const ChannelInfo &ci) : Serializable("ChannelInfo"), Flags<ChannelInfoFlag, CI_END>(ChannelInfoFlagStrings), +ChannelInfo::ChannelInfo(const ChannelInfo &ci) : Serializable("ChannelInfo"), access("ChanAccess"), akick("AutoKick"), - badwords("BadWord"), mode_locks("ModeLock"), log_settings("LogSetting"), botflags(BotServFlagStrings) + badwords("BadWord"), mode_locks("ModeLock"), log_settings("LogSetting") { *this = ci; @@ -304,7 +311,7 @@ ChannelInfo::ChannelInfo(const ChannelInfo &ci) : Serializable("ChannelInfo"), F newaccess->creator = taccess->creator; newaccess->last_seen = taccess->last_seen; newaccess->created = taccess->created; - newaccess->Unserialize(taccess->Serialize()); + newaccess->AccessUnserialize(taccess->AccessSerialize()); this->AddAccess(newaccess); } @@ -331,8 +338,6 @@ ChannelInfo::ChannelInfo(const ChannelInfo &ci) : Serializable("ChannelInfo"), F } } -/** Default destructor, cleans up the channel complete and removes it from the internal list - */ ChannelInfo::~ChannelInfo() { FOREACH_MOD(I_OnDelChan, OnDelChan(this)); @@ -353,17 +358,17 @@ ChannelInfo::~ChannelInfo() this->ClearBadWords(); for (unsigned i = 0; i < this->log_settings->size(); ++i) - this->log_settings->at(i)->destroy(); + this->log_settings->at(i)->Destroy(); this->log_settings->clear(); for (ChannelInfo::ModeList::iterator it = this->mode_locks->begin(), it_end = this->mode_locks->end(); it != it_end; ++it) - it->second->destroy(); + it->second->Destroy(); this->mode_locks->clear(); if (!this->memos.memos->empty()) { for (unsigned i = 0, end = this->memos.memos->size(); i < end; ++i) - this->memos.GetMemo(i)->destroy(); + this->memos.GetMemo(i)->Destroy(); this->memos.memos->clear(); } @@ -371,22 +376,22 @@ ChannelInfo::~ChannelInfo() --this->founder->channelcount; } -Serialize::Data ChannelInfo::serialize() const +Serialize::Data ChannelInfo::Serialize() const { Serialize::Data data; - data["name"].setMax(255) << this->name; + data["name"].SetMax(255) << this->name; if (this->founder) data["founder"] << this->founder->display; if (this->successor) data["successor"] << this->successor->display; data["description"] << this->desc; - data["time_registered"].setType(Serialize::DT_INT) << this->time_registered; - data["last_used"].setType(Serialize::DT_INT) << this->last_used; + data["time_registered"].SetType(Serialize::DT_INT) << this->time_registered; + data["last_used"].SetType(Serialize::DT_INT) << this->last_used; data["last_topic"] << this->last_topic; data["last_topic_setter"] << this->last_topic_setter; - data["last_topic_time"].setType(Serialize::DT_INT) << this->last_topic_time; - data["bantype"].setType(Serialize::DT_INT) << this->bantype; + data["last_topic_time"].SetType(Serialize::DT_INT) << this->last_topic_time; + data["bantype"].SetType(Serialize::DT_INT) << this->bantype; data["flags"] << this->ToString(); data["botflags"] << this->botflags.ToString(); { @@ -399,11 +404,11 @@ Serialize::Data ChannelInfo::serialize() const data["bi"] << this->bi->nick; for (int i = 0; i < TTB_SIZE; ++i) data["ttb"] << this->ttb[i] << " "; - data["capsmin"].setType(Serialize::DT_INT) << this->capsmin; - data["capspercent"].setType(Serialize::DT_INT) << this->capspercent; - data["floodlines"].setType(Serialize::DT_INT) << this->floodlines; - data["floodsecs"].setType(Serialize::DT_INT) << this->floodsecs; - data["repeattimes"].setType(Serialize::DT_INT) << this->repeattimes; + data["capsmin"].SetType(Serialize::DT_INT) << this->capsmin; + data["capspercent"].SetType(Serialize::DT_INT) << this->capspercent; + data["floodlines"].SetType(Serialize::DT_INT) << this->floodlines; + data["floodsecs"].SetType(Serialize::DT_INT) << this->floodsecs; + data["repeattimes"].SetType(Serialize::DT_INT) << this->repeattimes; data["memomax"] << this->memos.memomax; for (unsigned i = 0; i < this->memos.ignores.size(); ++i) data["memoignores"] << this->memos.ignores[i] << " "; @@ -411,7 +416,7 @@ Serialize::Data ChannelInfo::serialize() const return data; } -Serializable* ChannelInfo::unserialize(Serializable *obj, Serialize::Data &data) +Serializable* ChannelInfo::Unserialize(Serializable *obj, Serialize::Data &data) { ChannelInfo *ci; if (obj) @@ -423,13 +428,13 @@ Serializable* ChannelInfo::unserialize(Serializable *obj, Serialize::Data &data) { if (ci->founder) --ci->founder->channelcount; - ci->founder = findcore(data["founder"].astr()); + ci->founder = NickCore::Find(data["founder"].astr()); if (ci->founder) ++ci->founder->channelcount; } if (data.count("successor") > 0) { - ci->successor = findcore(data["successor"].astr()); + ci->successor = NickCore::Find(data["successor"].astr()); if (ci->founder && *ci->founder == *ci->successor) ci->successor = NULL; } @@ -443,11 +448,12 @@ Serializable* ChannelInfo::unserialize(Serializable *obj, Serialize::Data &data) ci->FromString(data["flags"].astr()); ci->botflags.FromString(data["botflags"].astr()); { - std::vector<Anope::string> v = BuildStringVector(data["levels"].astr()); + std::vector<Anope::string> v; + spacesepstream(data["levels"].astr()).GetTokens(v); for (unsigned i = 0; i + 1 < v.size(); i += 2) ci->levels[v[i]] = convertTo<int16_t>(v[i + 1]); } - BotInfo *bi = findbot(data["bi"].astr()); + BotInfo *bi = BotInfo::Find(data["bi"].astr()); if (*ci->bi != bi) { if (ci->bi) @@ -475,9 +481,6 @@ Serializable* ChannelInfo::unserialize(Serializable *obj, Serialize::Data &data) } -/** Change the founder of the channek - * @params nc The new founder - */ void ChannelInfo::SetFounder(NickCore *nc) { if (this->founder) @@ -489,44 +492,27 @@ void ChannelInfo::SetFounder(NickCore *nc) this->successor = NULL; } -/** Get the founder of the channel - * @return The founder - */ NickCore *ChannelInfo::GetFounder() const { return this->founder; } -/** Find which bot should send mode/topic/etc changes for this channel - * @return The bot - */ BotInfo *ChannelInfo::WhoSends() const { if (this && this->bi) return this->bi; - BotInfo *tbi = findbot(Config->ChanServ); - if (tbi) - return tbi; + else if (ChanServ) + return ChanServ; else if (!BotListByNick->empty()) return BotListByNick->begin()->second; return NULL; } -/** Add an entry to the channel access list - * @param taccess The entry - */ void ChannelInfo::AddAccess(ChanAccess *taccess) { this->access->push_back(taccess); } -/** Get an entry from the channel access list by index - * - * @param index The index in the access list vector - * @return A ChanAccess struct corresponding to the index given, or NULL if outside the bounds - * - * Retrieves an entry from the access list that matches the given index. - */ ChanAccess *ChannelInfo::GetAccess(unsigned index) const { if (this->access->empty() || index >= this->access->size()) @@ -547,13 +533,13 @@ AccessGroup ChannelInfo::AccessFor(const User *u) const NickCore *nc = u->Account(); if (nc == NULL && u->IsRecognized()) { - const NickAlias *na = findnick(u->nick); + const NickAlias *na = NickAlias::Find(u->nick); if (na != NULL) nc = na->nc; } - group.SuperAdmin = u->SuperAdmin; - group.Founder = IsFounder(u, this); + group.super_admin = u->super_admin; + group.founder = IsFounder(u, this); group.ci = this; group.nc = nc; @@ -561,9 +547,14 @@ AccessGroup ChannelInfo::AccessFor(const User *u) if (this->GetAccess(i)->Matches(u, nc)) group.push_back(this->GetAccess(i)); - if (group.Founder || !group.empty()) + if (group.founder || !group.empty()) + { this->last_used = Anope::CurTime; + for (unsigned i = 0; i < group.size(); ++i) + group[i]->last_seen = Anope::CurTime; + } + return group; } @@ -571,7 +562,7 @@ AccessGroup ChannelInfo::AccessFor(const NickCore *nc) { AccessGroup group; - group.Founder = (this->founder && this->founder == nc); + group.founder = (this->founder && this->founder == nc); group.ci = this; group.nc = nc; @@ -579,41 +570,31 @@ AccessGroup ChannelInfo::AccessFor(const NickCore *nc) if (this->GetAccess(i)->Matches(NULL, nc)) group.push_back(this->GetAccess(i)); - if (group.Founder || !group.empty()) + if (group.founder || !group.empty()) + { this->last_used = Anope::CurTime; + for (unsigned i = 0; i < group.size(); ++i) + group[i]->last_seen = Anope::CurTime; + } + return group; } -/** Get the size of the accss vector for this channel - * @return The access vector size - */ unsigned ChannelInfo::GetAccessCount() const { return this->access->size(); } -/** Erase an entry from the channel access list - * - * @param index The index in the access list vector - * - * Clears the memory used by the given access entry and removes it from the vector. - */ void ChannelInfo::EraseAccess(unsigned index) { if (this->access->empty() || index >= this->access->size()) return; - this->access->at(index)->destroy(); + this->access->at(index)->Destroy(); this->access->erase(this->access->begin() + index); } -/** Erase an entry from the channel access list - * - * @param taccess The access to remove - * - * Clears the memory used by the given access entry and removes it from the vector. - */ void ChannelInfo::EraseAccess(const ChanAccess *taccess) { for (unsigned i = 0, end = this->access->size(); i < end; ++i) @@ -626,25 +607,13 @@ void ChannelInfo::EraseAccess(const ChanAccess *taccess) } } -/** Clear the entire channel access list - * - * Clears the entire access list by deleting every item and then clearing the vector. - */ void ChannelInfo::ClearAccess() { for (unsigned i = this->access->size(); i > 0; --i) - this->GetAccess(i - 1)->destroy(); + this->GetAccess(i - 1)->Destroy(); this->access->clear(); } -/** Add an akick entry to the channel by NickCore - * @param user The user who added the akick - * @param akicknc The nickcore being akicked - * @param reason The reason for the akick - * @param t The time the akick was added, defaults to now - * @param lu The time the akick was last used, defaults to never - * @return The AutoKick structure - */ AutoKick *ChannelInfo::AddAkick(const Anope::string &user, NickCore *akicknc, const Anope::string &reason, time_t t, time_t lu) { AutoKick *autokick = new AutoKick(); @@ -661,14 +630,6 @@ AutoKick *ChannelInfo::AddAkick(const Anope::string &user, NickCore *akicknc, co return autokick; } -/** Add an akick entry to the channel by reason - * @param user The user who added the akick - * @param mask The mask of the akick - * @param reason The reason for the akick - * @param t The time the akick was added, defaults to now - * @param lu The time the akick was last used, defaults to never - * @return The AutoKick structure - */ AutoKick *ChannelInfo::AddAkick(const Anope::string &user, const Anope::string &mask, const Anope::string &reason, time_t t, time_t lu) { AutoKick *autokick = new AutoKick(); @@ -685,10 +646,6 @@ AutoKick *ChannelInfo::AddAkick(const Anope::string &user, const Anope::string & return autokick; } -/** Get an entry from the channel akick list - * @param index The index in the akick vector - * @return The akick structure, or NULL if not found - */ AutoKick *ChannelInfo::GetAkick(unsigned index) const { if (this->akick->empty() || index >= this->akick->size()) @@ -699,39 +656,26 @@ AutoKick *ChannelInfo::GetAkick(unsigned index) const return ak; } -/** Get the size of the akick vector for this channel - * @return The akick vector size - */ unsigned ChannelInfo::GetAkickCount() const { return this->akick->size(); } -/** Erase an entry from the channel akick list - * @param index The index of the akick - */ void ChannelInfo::EraseAkick(unsigned index) { if (this->akick->empty() || index >= this->akick->size()) return; - this->GetAkick(index)->destroy(); + this->GetAkick(index)->Destroy(); this->akick->erase(this->akick->begin() + index); } -/** Clear the whole akick list - */ void ChannelInfo::ClearAkick() { while (!this->akick->empty()) EraseAkick(0); } -/** Add a badword to the badword list - * @param word The badword - * @param type The type (SINGLE START END) - * @return The badword - */ BadWord* ChannelInfo::AddBadWord(const Anope::string &word, BadWordType type) { BadWord *bw = new BadWord(); @@ -746,10 +690,6 @@ BadWord* ChannelInfo::AddBadWord(const Anope::string &word, BadWordType type) return bw; } -/** Get a badword structure by index - * @param index The index - * @return The badword - */ BadWord* ChannelInfo::GetBadWord(unsigned index) const { if (this->badwords->empty() || index >= this->badwords->size()) @@ -760,17 +700,11 @@ BadWord* ChannelInfo::GetBadWord(unsigned index) const return bw; } -/** Get how many badwords are on this channel - * @return The number of badwords in the vector - */ unsigned ChannelInfo::GetBadWordCount() const { return this->badwords->size(); } -/** Remove a badword - * @param index The index of the badword - */ void ChannelInfo::EraseBadWord(unsigned index) { if (this->badwords->empty() || index >= this->badwords->size()) @@ -782,28 +716,21 @@ void ChannelInfo::EraseBadWord(unsigned index) this->badwords->erase(this->badwords->begin() + index); } -/** Clear all badwords from the channel - */ void ChannelInfo::ClearBadWords() { while (!this->badwords->empty()) EraseBadWord(0); } -/** Check if a mode is mlocked - * @param mode The mode - * @param status True to check mlock on, false for mlock off - * @return true on success, false on fail - */ bool ChannelInfo::HasMLock(ChannelMode *mode, const Anope::string ¶m, bool status) const { - std::multimap<ChannelModeName, ModeLock *>::const_iterator it = this->mode_locks->find(mode->Name); + std::multimap<ChannelModeName, ModeLock *>::const_iterator it = this->mode_locks->find(mode->name); if (it != this->mode_locks->end()) { - if (mode->Type != MODE_REGULAR) + if (mode->type != MODE_REGULAR) { - std::multimap<ChannelModeName, ModeLock *>::const_iterator it_end = this->mode_locks->upper_bound(mode->Name); + std::multimap<ChannelModeName, ModeLock *>::const_iterator it_end = this->mode_locks->upper_bound(mode->name); for (; it != it_end; ++it) { @@ -818,17 +745,11 @@ bool ChannelInfo::HasMLock(ChannelMode *mode, const Anope::string ¶m, bool s return false; } -/** Set a mlock - * @param mode The mode - * @param status True for mlock on, false for mlock off - * @param param The param to use for this mode, if required - * @return true on success, false on failure (module blocking) - */ bool ChannelInfo::SetMLock(ChannelMode *mode, bool status, const Anope::string ¶m, Anope::string setter, time_t created) { if (setter.empty()) setter = this->founder ? this->founder->display : "Unknown"; - std::pair<ChannelModeName, ModeLock *> ml = std::make_pair(mode->Name, new ModeLock(this, status, mode->Name, param, setter, created)); + std::pair<ChannelModeName, ModeLock *> ml = std::make_pair(mode->name, new ModeLock(this, status, mode->name, param, setter, created)); EventReturn MOD_RESULT; FOREACH_RESULT(I_OnMLock, OnMLock(this, ml.second)); @@ -836,30 +757,30 @@ bool ChannelInfo::SetMLock(ChannelMode *mode, bool status, const Anope::string & return false; /* First, remove this */ - if (mode->Type == MODE_REGULAR || mode->Type == MODE_PARAM) + if (mode->type == MODE_REGULAR || mode->type == MODE_PARAM) { - ChannelInfo::ModeList::const_iterator it = this->mode_locks->find(mode->Name); + ChannelInfo::ModeList::const_iterator it = this->mode_locks->find(mode->name); if (it != this->mode_locks->end()) { - ChannelInfo::ModeList::const_iterator it_end = this->mode_locks->upper_bound(mode->Name); + ChannelInfo::ModeList::const_iterator it_end = this->mode_locks->upper_bound(mode->name); for (; it != it_end; ++it) - it->second->destroy(); + it->second->Destroy(); } - this->mode_locks->erase(mode->Name); + this->mode_locks->erase(mode->name); } else { // For list or status modes, we must check the parameter - ChannelInfo::ModeList::iterator it = this->mode_locks->find(mode->Name); + ChannelInfo::ModeList::iterator it = this->mode_locks->find(mode->name); if (it != this->mode_locks->end()) { - ChannelInfo::ModeList::iterator it_end = this->mode_locks->upper_bound(mode->Name); + ChannelInfo::ModeList::iterator it_end = this->mode_locks->upper_bound(mode->name); for (; it != it_end; ++it) { const ModeLock *modelock = it->second; if (modelock->param == param) { - it->second->destroy(); + it->second->Destroy(); this->mode_locks->erase(it); break; } @@ -872,17 +793,11 @@ bool ChannelInfo::SetMLock(ChannelMode *mode, bool status, const Anope::string & return true; } -/** Remove a mlock - * @param mode The mode - * @param status True for mlock on, false for mlock off - * @param param The param of the mode, required if it is a list or status mode - * @return true on success, false on failure - */ bool ChannelInfo::RemoveMLock(ChannelMode *mode, bool status, const Anope::string ¶m) { - if (mode->Type == MODE_REGULAR || mode->Type == MODE_PARAM) + if (mode->type == MODE_REGULAR || mode->type == MODE_PARAM) { - ChannelInfo::ModeList::iterator it = this->mode_locks->find(mode->Name), it_end = this->mode_locks->upper_bound(mode->Name), it_next = it; + ChannelInfo::ModeList::iterator it = this->mode_locks->find(mode->name), it_end = this->mode_locks->upper_bound(mode->name), it_next = it; if (it != this->mode_locks->end()) for (; it != it_end; it = it_next) { @@ -896,7 +811,7 @@ bool ChannelInfo::RemoveMLock(ChannelMode *mode, bool status, const Anope::strin FOREACH_RESULT(I_OnUnMLock, OnUnMLock(this, it->second)); if (MOD_RESULT != EVENT_STOP) { - it->second->destroy(); + it->second->Destroy(); this->mode_locks->erase(it); return true; } @@ -906,10 +821,10 @@ bool ChannelInfo::RemoveMLock(ChannelMode *mode, bool status, const Anope::strin else { // For list or status modes, we must check the parameter - ChannelInfo::ModeList::iterator it = this->mode_locks->find(mode->Name); + ChannelInfo::ModeList::iterator it = this->mode_locks->find(mode->name); if (it != this->mode_locks->end()) { - ChannelInfo::ModeList::iterator it_end = this->mode_locks->upper_bound(mode->Name); + ChannelInfo::ModeList::iterator it_end = this->mode_locks->upper_bound(mode->name); for (; it != it_end; ++it) { const ModeLock *ml = it->second; @@ -919,7 +834,7 @@ bool ChannelInfo::RemoveMLock(ChannelMode *mode, bool status, const Anope::strin FOREACH_RESULT(I_OnUnMLock, OnUnMLock(this, it->second)); if (MOD_RESULT == EVENT_STOP) return false; - it->second->destroy(); + it->second->Destroy(); this->mode_locks->erase(it); return true; } @@ -930,25 +845,16 @@ bool ChannelInfo::RemoveMLock(ChannelMode *mode, bool status, const Anope::strin } } -/** Clear all mlocks on the channel - */ void ChannelInfo::ClearMLock() { this->mode_locks->clear(); } -/** Get all of the mlocks for this channel - * @return The mlocks - */ const ChannelInfo::ModeList &ChannelInfo::GetMLock() const { return this->mode_locks; } -/** Get a list of modes on a channel - * @param Name The mode name to get a list of - * @return a pair of iterators for the beginning and end of the list - */ std::pair<ChannelInfo::ModeList::iterator, ChannelInfo::ModeList::iterator> ChannelInfo::GetModeList(ChannelModeName Name) { ChannelInfo::ModeList::iterator it = this->mode_locks->find(Name), it_end = it; @@ -957,11 +863,6 @@ std::pair<ChannelInfo::ModeList::iterator, ChannelInfo::ModeList::iterator> Chan return std::make_pair(it, it_end); } -/** Get details for a specific mlock - * @param mname The mode name - * @param param An optional param to match with - * @return The MLock, if any - */ const ModeLock *ChannelInfo::GetMLock(ChannelModeName mname, const Anope::string ¶m) { ChannelInfo::ModeList::iterator it = this->mode_locks->find(mname); @@ -991,15 +892,15 @@ Anope::string ChannelInfo::GetMLockAsString(bool complete) const { const ModeLock *ml = it->second; ChannelMode *cm = ModeManager::FindChannelModeByName(ml->name); - if (!cm || cm->Type == MODE_LIST || cm->Type == MODE_STATUS) + if (!cm || cm->type == MODE_LIST || cm->type == MODE_STATUS) continue; if (ml->set) - pos += cm->ModeChar; + pos += cm->mchar; else - neg += cm->ModeChar; + neg += cm->mchar; - if (complete && !ml->param.empty() && cm->Type == MODE_PARAM) + if (complete && !ml->param.empty() && cm->type == MODE_PARAM) params += " " + ml->param; } @@ -1011,16 +912,12 @@ Anope::string ChannelInfo::GetMLockAsString(bool complete) const return pos + neg + params; } -/** Check whether a user is permitted to be on this channel - * @param u The user - * @return true if they were banned, false if they are allowed - */ bool ChannelInfo::CheckKick(User *user) { if (!user || !this->c) return false; - if (user->SuperAdmin) + if (user->super_admin) return false; /* We don't enforce services restrictions on clients on ulined services @@ -1041,13 +938,13 @@ bool ChannelInfo::CheckKick(User *user) Anope::string mask, reason; if (!user->HasMode(UMODE_OPER) && this->HasFlag(CI_SUSPENDED)) { - get_idealban(this, user, mask); - reason = translate(user, _("This channel may not be used.")); + mask = this->GetIdealBan(user); + reason = Language::Translate(user, _("This channel may not be used.")); set_modes = true; do_kick = true; } - if (!do_kick && matches_list(this->c, user, CMODE_EXCEPT)) + if (!do_kick && !this->c->MatchesList(user, CMODE_EXCEPT)) return false; const NickCore *nc = user->Account() || user->IsRecognized() ? user->Account() : NULL; @@ -1074,7 +971,7 @@ bool ChannelInfo::CheckKick(User *user) Log(LOG_DEBUG_2) << user->nick << " matched akick " << (autokick->HasFlag(AK_ISNICK) ? autokick->nc->display : autokick->mask); autokick->last_used = Anope::CurTime; if (autokick->HasFlag(AK_ISNICK)) - get_idealban(this, user, mask); + mask = this->GetIdealBan(user); else mask = autokick->mask; reason = autokick->reason.empty() ? Config->CSAutokickReason : autokick->reason; @@ -1086,8 +983,8 @@ bool ChannelInfo::CheckKick(User *user) if (!do_kick && this->HasFlag(CI_RESTRICTED) && this->AccessFor(user).empty() && (!this->founder || user->Account() != this->founder)) { do_kick = true; - get_idealban(this, user, mask); - reason = translate(user->Account(), CHAN_NOT_ALLOWED_TO_JOIN); + mask = this->GetIdealBan(user); + reason = Language::Translate(user->Account(), CHAN_NOT_ALLOWED_TO_JOIN); } if (!do_kick) @@ -1183,3 +1080,48 @@ void ChannelInfo::ClearLevels() this->levels.clear(); } +Anope::string ChannelInfo::GetIdealBan(User *u) const +{ + switch (this->bantype) + { + case 0: + return "*!" + u->GetVIdent() + "@" + u->GetDisplayedHost(); + case 1: + if (u->GetVIdent()[0] == '~') + return "*!*" + u->GetVIdent() + "@" + u->GetDisplayedHost(); + else + return "*!" + u->GetVIdent() + "@" + u->GetDisplayedHost(); + case 3: + return "*!" + u->Mask(); + case 2: + default: + return "*!*@" + u->GetDisplayedHost(); + } +} + +ChannelInfo* ChannelInfo::Find(const Anope::string &name) +{ + registered_channel_map::const_iterator it = RegisteredChannelList->find(name); + if (it != RegisteredChannelList->end()) + { + it->second->QueueUpdate(); + return it->second; + } + + return NULL; +} + +bool IsFounder(const User *user, const ChannelInfo *ci) +{ + if (!user || !ci) + return false; + + if (user->super_admin) + return true; + + if (user->Account() && user->Account() == ci->GetFounder()) + return true; + + return false; +} + diff --git a/src/serialize.cpp b/src/serialize.cpp index a84d103f5..b6da2da67 100644 --- a/src/serialize.cpp +++ b/src/serialize.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ @@ -14,10 +15,25 @@ #include "anope.h" #include "serialize.h" #include "modules.h" +#include "account.h" +#include "bots.h" +#include "regchannel.h" +#include "xline.h" +#include "access.h" + +using namespace Serialize; + +std::vector<Anope::string> Type::TypeOrder; +std::map<Anope::string, Type *> Serialize::Type::Types; +std::list<Serializable *> *Serializable::SerializableItems; -std::vector<Anope::string> SerializeType::type_order; -std::map<Anope::string, SerializeType *> SerializeType::types; -std::list<Serializable *> *Serializable::serializable_items; +void Serialize::RegisterTypes() +{ + static Type nc("NickCore", NickCore::Unserialize), na("NickAlias", NickAlias::Unserialize), bi("BotInfo", BotInfo::Unserialize), + ci("ChannelInfo", ChannelInfo::Unserialize), access("ChanAccess", ChanAccess::Unserialize), logsetting("LogSetting", LogSetting::Unserialize), + modelock("ModeLock", ModeLock::Unserialize), akick("AutoKick", AutoKick::Unserialize), badword("BadWord", BadWord::Unserialize), + memo("Memo", Memo::Unserialize), xline("XLine", XLine::Unserialize); +} stringstream::stringstream() : std::stringstream(), type(Serialize::DT_TEXT), _max(0) { @@ -48,24 +64,24 @@ bool stringstream::operator!=(const stringstream &other) const return !(*this == other); } -stringstream &stringstream::setType(Serialize::DataType t) +stringstream &stringstream::SetType(Serialize::DataType t) { this->type = t; return *this; } -Serialize::DataType stringstream::getType() const +DataType Serialize::stringstream::GetType() const { return this->type; } -stringstream &stringstream::setMax(unsigned m) +stringstream &stringstream::SetMax(unsigned m) { this->_max = m; return *this; } -unsigned stringstream::getMax() const +unsigned stringstream::GetMax() const { return this->_max; } @@ -77,13 +93,13 @@ Serializable::Serializable() : last_commit_time(0), id(0) Serializable::Serializable(const Anope::string &serialize_type) : last_commit_time(0), id(0) { - if (serializable_items == NULL) - serializable_items = new std::list<Serializable *>(); - serializable_items->push_back(this); + if (SerializableItems == NULL) + SerializableItems = new std::list<Serializable *>(); + SerializableItems->push_back(this); - this->s_type = SerializeType::Find(serialize_type); + this->s_type = Type::Find(serialize_type); - this->s_iter = serializable_items->end(); + this->s_iter = SerializableItems->end(); --this->s_iter; FOREACH_MOD(I_OnSerializableConstruct, OnSerializableConstruct(this)); @@ -91,8 +107,8 @@ Serializable::Serializable(const Anope::string &serialize_type) : last_commit_ti Serializable::Serializable(const Serializable &other) : last_commit_time(0), id(0) { - serializable_items->push_back(this); - this->s_iter = serializable_items->end(); + SerializableItems->push_back(this); + this->s_iter = SerializableItems->end(); --this->s_iter; this->s_type = other.s_type; @@ -102,7 +118,7 @@ Serializable::Serializable(const Serializable &other) : last_commit_time(0), id( Serializable::~Serializable() { - serializable_items->erase(this->s_iter); + SerializableItems->erase(this->s_iter); } Serializable &Serializable::operator=(const Serializable &) @@ -110,7 +126,7 @@ Serializable &Serializable::operator=(const Serializable &) return *this; } -void Serializable::destroy() +void Serializable::Destroy() { if (!this) return; @@ -130,12 +146,12 @@ void Serializable::QueueUpdate() bool Serializable::IsCached() { - return this->last_commit == this->serialize(); + return this->last_commit == this->Serialize(); } void Serializable::UpdateCache() { - this->last_commit = this->serialize(); + this->last_commit = this->Serialize(); } bool Serializable::IsTSCached() @@ -148,70 +164,70 @@ void Serializable::UpdateTS() this->last_commit_time = Anope::CurTime; } -SerializeType* Serializable::GetSerializableType() const +Type* Serializable::GetSerializableType() const { return this->s_type; } const std::list<Serializable *> &Serializable::GetItems() { - return *serializable_items; + return *SerializableItems; } -SerializeType::SerializeType(const Anope::string &n, unserialize_func f, Module *o) : name(n), unserialize(f), owner(o), timestamp(0) +Type::Type(const Anope::string &n, unserialize_func f, Module *o) : name(n), unserialize(f), owner(o), timestamp(0) { - type_order.push_back(this->name); - types[this->name] = this; + TypeOrder.push_back(this->name); + Types[this->name] = this; } -SerializeType::~SerializeType() +Type::~Type() { - std::vector<Anope::string>::iterator it = std::find(type_order.begin(), type_order.end(), this->name); - if (it != type_order.end()) - type_order.erase(it); - types.erase(this->name); + std::vector<Anope::string>::iterator it = std::find(TypeOrder.begin(), TypeOrder.end(), this->name); + if (it != TypeOrder.end()) + TypeOrder.erase(it); + Types.erase(this->name); } -const Anope::string &SerializeType::GetName() +const Anope::string &Type::GetName() { return this->name; } -Serializable *SerializeType::Unserialize(Serializable *obj, Serialize::Data &data) +Serializable *Type::Unserialize(Serializable *obj, Serialize::Data &data) { return this->unserialize(obj, data); } -void SerializeType::Check() +void Type::Check() { FOREACH_MOD(I_OnSerializeCheck, OnSerializeCheck(this)); } -time_t SerializeType::GetTimestamp() const +time_t Type::GetTimestamp() const { return this->timestamp; } -void SerializeType::UpdateTimestamp() +void Type::UpdateTimestamp() { this->timestamp = Anope::CurTime; } -Module* SerializeType::GetOwner() const +Module* Type::GetOwner() const { return this->owner; } -SerializeType *SerializeType::Find(const Anope::string &name) +Type *Serialize::Type::Find(const Anope::string &name) { - std::map<Anope::string, SerializeType *>::iterator it = types.find(name); - if (it != types.end()) + std::map<Anope::string, Type *>::iterator it = Types.find(name); + if (it != Types.end()) return it->second; return NULL; } -const std::vector<Anope::string> &SerializeType::GetTypeOrder() +const std::vector<Anope::string> &Type::GetTypeOrder() { - return type_order; + return TypeOrder; } diff --git a/src/servers.cpp b/src/servers.cpp index 3a44c8e65..447633298 100644 --- a/src/servers.cpp +++ b/src/servers.cpp @@ -7,52 +7,47 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" #include "modules.h" -#include "oper.h" +#include "xline.h" #include "servers.h" #include "bots.h" #include "regchannel.h" #include "protocol.h" #include "config.h" #include "channels.h" -#include "extern.h" + +const Anope::string ServerFlagStrings[] = { "SERVER_NONE", "SERVER_SYNCING", "SERVER_JUPED", "" }; +template<> const Anope::string* Flags<ServerFlag>::flags_strings = ServerFlagStrings; /* Anope */ Server *Me = NULL; -std::set<Anope::string> Capab; +std::set<Anope::string> Servers::Capab; -/** Constructor - * @param uplink The uplink this server is from, is only NULL when creating Me - * @param name The server name - * @param hops Hops from services server - * @param description Server rdescription - * @param sid Server sid/numeric - * @param flag An optional server flag - */ -Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const Anope::string &description, const Anope::string &sid, ServerFlag flag) : Flags<ServerFlag>(ServerFlagStrings), Name(name), Hops(hops), Description(description), SID(sid), UplinkServer(uplink) +Server::Server(Server *up, const Anope::string &sname, unsigned shops, const Anope::string &desc, const Anope::string &ssid, ServerFlag flag) : name(sname), hops(shops), description(desc), sid(ssid), uplink(up) { this->SetFlag(SERVER_SYNCING); this->SetFlag(flag); - Log(this, "connect") << "uplinked to " << (this->UplinkServer ? this->UplinkServer->GetName() : "no uplink") << " connected to the network"; + Log(this, "connect") << "uplinked to " << (this->uplink ? this->uplink->GetName() : "no uplink") << " connected to the network"; /* Add this server to our uplinks leaf list */ - if (this->UplinkServer) + if (this->uplink) { - this->UplinkServer->AddLink(this); + this->uplink->AddLink(this); /* Check to be sure this isn't a juped server */ - if (Me == this->UplinkServer && !this->HasFlag(SERVER_JUPED)) + if (Me == this->uplink && !this->HasFlag(SERVER_JUPED)) { /* Now do mode related stuff as we know what modes exist .. */ for (botinfo_map::iterator it = BotListByNick->begin(), it_end = BotListByNick->end(); it != it_end; ++it) { BotInfo *bi = it->second; - Anope::string modes = !bi->botmodes.empty() ? ("+" + bi->botmodes) : ircdproto->DefaultPseudoclientModes; + Anope::string modes = !bi->botmodes.empty() ? ("+" + bi->botmodes) : IRCD->DefaultPseudoclientModes; bi->SetModesInternal(modes.c_str()); for (unsigned i = 0; i < bi->botchannels.size(); ++i) @@ -61,7 +56,7 @@ Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const A if (h == Anope::string::npos) continue; Anope::string chname = bi->botchannels[i].substr(h); - Channel *c = findchan(chname); + Channel *c = Channel::Find(chname); if (c && c->FindUser(bi)) { Anope::string want_modes = bi->botchannels[i].substr(0, h); @@ -70,7 +65,7 @@ Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const A ChannelMode *cm = ModeManager::FindChannelModeByChar(want_modes[j]); if (cm == NULL) cm = ModeManager::FindChannelModeByChar(ModeManager::GetStatusChar(want_modes[j])); - if (cm && cm->Type == MODE_STATUS) + if (cm && cm->type == MODE_STATUS) { MessageSource ms = bi; c->SetModeInternal(ms, cm, bi->nick); @@ -80,14 +75,14 @@ Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const A } } - ircdproto->SendBOB(); + IRCD->SendBOB(); for (unsigned i = 0; i < Me->GetLinks().size(); ++i) { Server *s = Me->GetLinks()[i]; if (s->HasFlag(SERVER_JUPED)) - ircdproto->SendServer(s); + IRCD->SendServer(s); } /* We make the bots go online */ @@ -95,14 +90,14 @@ Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const A { User *u = it->second; - BotInfo *bi = findbot(u->nick); + BotInfo *bi = BotInfo::Find(u->nick); if (bi) { XLine x(bi->nick, "Reserved for services"); - ircdproto->SendSQLine(NULL, &x); + IRCD->SendSQLine(NULL, &x); } - ircdproto->SendClientIntroduction(u); + IRCD->SendClientIntroduction(u); if (bi) bi->introduced = true; } @@ -111,10 +106,10 @@ Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const A { Channel *c = it->second; if (c->users.empty()) - ircdproto->SendChannel(c); + IRCD->SendChannel(c); else for (CUserList::const_iterator cit = c->users.begin(), cit_end = c->users.end(); cit != cit_end; ++cit) - ircdproto->SendJoin((*cit)->user, c, (*cit)->Status); + IRCD->SendJoin((*cit)->user, c, (*cit)->status); } } } @@ -122,13 +117,11 @@ Server::Server(Server *uplink, const Anope::string &name, unsigned hops, const A FOREACH_MOD(I_OnNewServer, OnNewServer(this)); } -/** Destructor - */ Server::~Server() { - Log(this, "quit") << "quit from " << (this->UplinkServer ? this->UplinkServer->GetName() : "no uplink") << " for " << this->QReason; + Log(this, "quit") << "quit from " << (this->uplink ? this->uplink->GetName() : "no uplink") << " for " << this->quit_reason; - if (Capab.count("NOQUIT") > 0 || Capab.count("QS") > 0) + if (Servers::Capab.count("NOQUIT") > 0 || Servers::Capab.count("QS") > 0) { for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end();) { @@ -137,11 +130,11 @@ Server::~Server() if (u->server == this) { - NickAlias *na = findnick(u->nick); + NickAlias *na = NickAlias::Find(u->nick); if (na && !na->nc->HasFlag(NI_SUSPENDED) && (u->IsRecognized() || u->IsIdentified())) { na->last_seen = Anope::CurTime; - na->last_quit = this->QReason; + na->last_quit = this->quit_reason; } delete u; @@ -151,113 +144,80 @@ Server::~Server() Log(LOG_DEBUG) << "Finished removing all users for " << this->GetName(); } - if (this->UplinkServer) - this->UplinkServer->DelLink(this); + if (this->uplink) + this->uplink->DelLink(this); - for (unsigned i = this->Links.size(); i > 0; --i) - this->Links[i - 1]->Delete(this->QReason); + for (unsigned i = this->links.size(); i > 0; --i) + this->links[i - 1]->Delete(this->quit_reason); } -/** Delete this server with a reason - * @param reason The reason - */ void Server::Delete(const Anope::string &reason) { - this->QReason = reason; + this->quit_reason = reason; FOREACH_MOD(I_OnServerQuit, OnServerQuit(this)); delete this; } -/** Get the name for this server - * @return The name - */ const Anope::string &Server::GetName() const { - return this->Name; + return this->name; } -/** Get the number of hops this server is from services - * @return Number of hops - */ unsigned Server::GetHops() const { - return this->Hops; + return this->hops; } -/** Set the server description - * @param desc The new description - */ void Server::SetDescription(const Anope::string &desc) { - this->Description = desc; + this->description = desc; } -/** Get the server description - * @return The server description - */ const Anope::string &Server::GetDescription() const { - return this->Description; + return this->description; } -/** Change this servers SID - * @param sid The new SID - */ -void Server::SetSID(const Anope::string &sid) +void Server::SetSID(const Anope::string &nsid) { - this->SID = sid; + this->sid = nsid; } -/** Get the server numeric/SID - * @return The numeric/SID - */ const Anope::string &Server::GetSID() const { - if (!this->SID.empty() && ircdproto->RequiresID) - return this->SID; + if (!this->sid.empty() && IRCD->RequiresID) + return this->sid; else - return this->Name; + return this->name; } -/** Get the list of links this server has, or NULL if it has none - * @return A list of servers - */ const std::vector<Server *> &Server::GetLinks() const { - return this->Links; + return this->links; } -/** Get the uplink server for this server, if this is our uplink will be Me - * @return The servers uplink - */ Server *Server::GetUplink() { - return this->UplinkServer; + return this->uplink; } -/** Adds a link to this server - * @param s The linking server - */ void Server::AddLink(Server *s) { - this->Links.push_back(s); + this->links.push_back(s); Log(this, "connect") << "introduced " << s->GetName(); } -/** Delinks a server from this server - * @param s The server - */ void Server::DelLink(Server *s) { - if (this->Links.empty()) + if (this->links.empty()) throw CoreException("Server::DelLink called on " + this->GetName() + " for " + s->GetName() + " but we have no links?"); - for (unsigned i = 0, j = this->Links.size(); i < j; ++i) + for (unsigned i = 0, j = this->links.size(); i < j; ++i) { - if (this->Links[i] == s) + if (this->links[i] == s) { - this->Links.erase(this->Links.begin() + i); + this->links.erase(this->links.begin() + i); break; } } @@ -265,10 +225,7 @@ void Server::DelLink(Server *s) Log(this, "quit") << "quit " << s->GetName(); } -/** Finish syncing this server and optionally all links to it - * @param SyncLinks True to sync the links for this server too (if any) - */ -void Server::Sync(bool SyncLinks) +void Server::Sync(bool sync_links) { if (this->IsSynced()) return; @@ -279,10 +236,10 @@ void Server::Sync(bool SyncLinks) FOREACH_MOD(I_OnServerSync, OnServerSync(this)); - if (SyncLinks && !this->Links.empty()) + if (sync_links && !this->links.empty()) { - for (unsigned i = 0, j = this->Links.size(); i < j; ++i) - this->Links[i]->Sync(true); + for (unsigned i = 0, j = this->links.size(); i < j; ++i) + this->links[i]->Sync(true); } if (this->GetUplink() && this->GetUplink() == Me) @@ -302,7 +259,7 @@ void Server::Sync(bool SyncLinks) { ci->c->SetMode(NULL, CMODE_PERM); if (created) - ircdproto->SendChannel(ci->c); + IRCD->SendChannel(ci->c); } else { @@ -316,7 +273,7 @@ void Server::Sync(bool SyncLinks) FOREACH_MOD(I_OnPreUplinkSync, OnPreUplinkSync(this)); - ircdproto->SendEOB(); + IRCD->SendEOB(); Me->Sync(false); FOREACH_MOD(I_OnUplinkSync, OnUplinkSync(this)); @@ -329,25 +286,19 @@ void Server::Sync(bool SyncLinks) c->ci->RestoreTopic(); } - if (!nofork && AtTerm()) + if (!Anope::NoFork && Anope::AtTerm()) { Log(LOG_TERMINAL) << "Successfully linked, launching into background..."; - Fork(); + Anope::Fork(); } } } -/** Check if this server is synced - * @return true or false - */ bool Server::IsSynced() const { return !this->HasFlag(SERVER_SYNCING); } -/** Check if this server is ULined - * @return true or false - */ bool Server::IsULined() const { if (this == Me) @@ -359,24 +310,14 @@ bool Server::IsULined() const return false; } - -/** Send a message to alll users on this server - * @param source The source of the message - * @param message The message - */ void Server::Notice(const BotInfo *source, const Anope::string &message) { if (Config->NSDefFlags.HasFlag(NI_MSG)) - ircdproto->SendGlobalPrivmsg(source, this, message); + IRCD->SendGlobalPrivmsg(source, this, message); else - ircdproto->SendGlobalNotice(source, this, message); + IRCD->SendGlobalNotice(source, this, message); } -/** Find a server - * @param name The name or SID/numeric - * @param s The server list to search for this server on, defaults to our Uplink - * @return The server - */ Server *Server::Find(const Anope::string &name, Server *s) { Log(LOG_DEBUG_2) << "Server::Find called for " << name; @@ -417,17 +358,14 @@ static inline char& nextID(char &c) return c; } -/** Recieve the next UID in our list - * @return The UID - */ -const Anope::string ts6_uid_retrieve() +const Anope::string Servers::TS6_UID_Retrieve() { - if (!ircdproto || !ircdproto->RequiresID) + if (!IRCD || !IRCD->RequiresID) return ""; static Anope::string current_uid = "AAAAAA"; - while (finduser(Config->Numeric + current_uid) != NULL) + while (User::Find(Config->Numeric + current_uid) != NULL) { int current_len = current_uid.length() - 1; while (current_len >= 0 && nextID(current_uid[current_len--]) == 'A'); @@ -436,12 +374,9 @@ const Anope::string ts6_uid_retrieve() return Config->Numeric + current_uid; } -/** Return the next SID in our list - * @return The SID - */ -const Anope::string ts6_sid_retrieve() +const Anope::string Servers::TS6_SID_Retrieve() { - if (!ircdproto || !ircdproto->RequiresID) + if (!IRCD || !IRCD->RequiresID) return ""; static Anope::string current_sid; @@ -461,3 +396,11 @@ const Anope::string ts6_sid_retrieve() return current_sid; } +Server* Servers::GetUplink() +{ + for (unsigned i = 0; Me && i < Me->GetLinks().size(); ++i) + if (!Me->GetLinks()[i]->HasFlag(SERVER_JUPED)) + return Me->GetLinks()[i]; + return NULL; +} + diff --git a/src/socket_clients.cpp b/src/socket_clients.cpp index 44d4b873a..69700af4e 100644 --- a/src/socket_clients.cpp +++ b/src/socket_clients.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -22,7 +23,7 @@ ConnectionSocket::ConnectionSocket() : Socket() void ConnectionSocket::Connect(const Anope::string &TargetHost, int Port) { - this->IO->Connect(this, TargetHost, Port); + this->io->Connect(this, TargetHost, Port); } bool ConnectionSocket::Process() @@ -32,7 +33,7 @@ bool ConnectionSocket::Process() if (this->HasFlag(SF_CONNECTED)) return true; else if (this->HasFlag(SF_CONNECTING)) - this->SetFlag(this->IO->FinishConnect(this)); + this->SetFlag(this->io->FinishConnect(this)); else this->SetFlag(SF_DEAD); } @@ -61,7 +62,7 @@ void ConnectionSocket::OnError(const Anope::string &error) Log(LOG_DEBUG) << "Socket error: " << error; } -ClientSocket::ClientSocket(ListenSocket *ls, const sockaddrs &addr) : LS(ls), clientaddr(addr) +ClientSocket::ClientSocket(ListenSocket *l, const sockaddrs &addr) : ls(l), clientaddr(addr) { } @@ -72,7 +73,7 @@ bool ClientSocket::Process() if (this->HasFlag(SF_ACCEPTED)) return true; else if (this->HasFlag(SF_ACCEPTING)) - this->SetFlag(this->IO->FinishAccept(this)); + this->SetFlag(this->io->FinishAccept(this)); else this->SetFlag(SF_DEAD); } diff --git a/src/socket_transport.cpp b/src/socket_transport.cpp index 2297da2b2..4af3668a3 100644 --- a/src/socket_transport.cpp +++ b/src/socket_transport.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -25,28 +26,28 @@ bool BufferedSocket::ProcessRead() { char tbuffer[NET_BUFSIZE]; - this->RecvLen = 0; + this->recv_len = 0; - int len = this->IO->Recv(this, tbuffer, sizeof(tbuffer) - 1); + int len = this->io->Recv(this, tbuffer, sizeof(tbuffer) - 1); if (len <= 0) return false; tbuffer[len] = 0; - this->RecvLen = len; + this->recv_len = len; - Anope::string sbuffer = this->extrabuf; + Anope::string sbuffer = this->extra_buf; sbuffer += tbuffer; - this->extrabuf.clear(); + this->extra_buf.clear(); size_t lastnewline = sbuffer.rfind('\n'); if (lastnewline == Anope::string::npos) { - this->extrabuf = sbuffer; + this->extra_buf = sbuffer; return true; } if (lastnewline < sbuffer.length() - 1) { - this->extrabuf = sbuffer.substr(lastnewline); - this->extrabuf.trim(); + this->extra_buf = sbuffer.substr(lastnewline); + this->extra_buf.trim(); sbuffer = sbuffer.substr(0, lastnewline); } @@ -65,11 +66,11 @@ bool BufferedSocket::ProcessRead() bool BufferedSocket::ProcessWrite() { - int count = this->IO->Send(this, this->WriteBuffer); + int count = this->io->Send(this, this->write_buffer); if (count <= -1) return false; - this->WriteBuffer = this->WriteBuffer.substr(count); - if (this->WriteBuffer.empty()) + this->write_buffer = this->write_buffer.substr(count); + if (this->write_buffer.empty()) SocketEngine::Change(this, false, SF_WRITABLE); return true; @@ -82,7 +83,7 @@ bool BufferedSocket::Read(const Anope::string &buf) void BufferedSocket::Write(const char *buffer, size_t l) { - this->WriteBuffer += buffer + Anope::string("\r\n"); + this->write_buffer += buffer + Anope::string("\r\n"); SocketEngine::Change(this, true, SF_WRITABLE); } @@ -108,12 +109,12 @@ void BufferedSocket::Write(const Anope::string &message) int BufferedSocket::ReadBufferLen() const { - return RecvLen; + return recv_len; } int BufferedSocket::WriteBufferLen() const { - return this->WriteBuffer.length(); + return this->write_buffer.length(); } @@ -141,7 +142,7 @@ bool BinarySocket::ProcessRead() { char tbuffer[NET_BUFSIZE]; - int len = this->IO->Recv(this, tbuffer, sizeof(tbuffer)); + int len = this->io->Recv(this, tbuffer, sizeof(tbuffer)); if (len <= 0) return false; @@ -150,21 +151,21 @@ bool BinarySocket::ProcessRead() bool BinarySocket::ProcessWrite() { - if (this->WriteBuffer.empty()) + if (this->write_buffer.empty()) { SocketEngine::Change(this, false, SF_WRITABLE); return true; } - DataBlock *d = this->WriteBuffer.front(); + DataBlock *d = this->write_buffer.front(); - int len = this->IO->Send(this, d->buf, d->len); + int len = this->io->Send(this, d->buf, d->len); if (len <= -1) return false; else if (static_cast<size_t>(len) == d->len) { delete d; - this->WriteBuffer.pop_front(); + this->write_buffer.pop_front(); } else { @@ -172,7 +173,7 @@ bool BinarySocket::ProcessWrite() d->len -= len; } - if (this->WriteBuffer.empty()) + if (this->write_buffer.empty()) SocketEngine::Change(this, false, SF_WRITABLE); return true; @@ -180,7 +181,7 @@ bool BinarySocket::ProcessWrite() void BinarySocket::Write(const char *buffer, size_t l) { - this->WriteBuffer.push_back(new DataBlock(buffer, l)); + this->write_buffer.push_back(new DataBlock(buffer, l)); SocketEngine::Change(this, true, SF_WRITABLE); } diff --git a/src/socketengines/pipeengine_eventfd.cpp b/src/socketengines/pipeengine_eventfd.cpp index 19433d1c8..61fddd0af 100644 --- a/src/socketengines/pipeengine_eventfd.cpp +++ b/src/socketengines/pipeengine_eventfd.cpp @@ -16,7 +16,7 @@ Pipe::Pipe() : Socket(eventfd(0, EFD_NONBLOCK)) { - if (this->Sock < 0) + if (this->sock < 0) throw CoreException("Could not create pipe: " + Anope::LastError()); } diff --git a/src/sockets.cpp b/src/sockets.cpp index 861df6976..6aadb7802 100644 --- a/src/sockets.cpp +++ b/src/sockets.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -20,15 +21,18 @@ #include <fcntl.h> #endif +static const Anope::string SocketFlagStrings[] = { + "SF_DEAD", "SF_WRITABLE", "SF_CONNECTING", "SF_CONNECTED", "SF_ACCEPTING", "SF_ACCEPTED", "" +}; +template<> const Anope::string* Flags<SocketFlag>::flags_strings = SocketFlagStrings; + std::map<int, Socket *> SocketEngine::Sockets; uint32_t TotalRead = 0; uint32_t TotalWritten = 0; -SocketIO normalSocketIO; +SocketIO NormalSocketIO; -/** Construct the object, sets everything to 0 - */ sockaddrs::sockaddrs(const Anope::string &address) { this->clear(); @@ -36,16 +40,11 @@ sockaddrs::sockaddrs(const Anope::string &address) this->pton(address.find(':') != Anope::string::npos ? AF_INET6 : AF_INET, address); } -/** Memset the object to 0 - */ void sockaddrs::clear() { memset(this, 0, sizeof(*this)); } -/** Get the size of the sockaddr we represent - * @return The size - */ size_t sockaddrs::size() const { switch (sa.sa_family) @@ -61,9 +60,6 @@ size_t sockaddrs::size() const return 0; } -/** Get the port represented by this addr - * @return The port, or -1 on fail - */ int sockaddrs::port() const { switch (sa.sa_family) @@ -79,9 +75,6 @@ int sockaddrs::port() const return -1; } -/** Get the address represented by this addr - * @return The address - */ Anope::string sockaddrs::addr() const { char address[INET6_ADDRSTRLEN + 1] = ""; @@ -103,16 +96,11 @@ Anope::string sockaddrs::addr() const return address; } -/** Check if this sockaddr has data in it - */ bool sockaddrs::operator()() const { return this->sa.sa_family != 0; } -/** Compares with sockaddr with another. Compares address type, port, and address - * @return true if they are the same - */ bool sockaddrs::operator==(const sockaddrs &other) const { if (sa.sa_family != other.sa.sa_family) @@ -130,12 +118,6 @@ bool sockaddrs::operator==(const sockaddrs &other) const return false; } -/** The equivalent of inet_pton - * @param type AF_INET or AF_INET6 - * @param address The address to place in the sockaddr structures - * @param pport An option port to include in the sockaddr structures - * @throws A socket exception if given invalid IPs - */ void sockaddrs::pton(int type, const Anope::string &address, int pport) { switch (type) @@ -169,11 +151,6 @@ void sockaddrs::pton(int type, const Anope::string &address, int pport) throw CoreException("Invalid socket type"); } -/** The equivalent of inet_ntop - * @param type AF_INET or AF_INET6 - * @param address The in_addr or in_addr6 structure - * @throws A socket exception if given an invalid structure - */ void sockaddrs::ntop(int type, const void *src) { switch (type) @@ -333,12 +310,6 @@ size_t cidr::hash::operator()(const cidr &s) const } } -/** Receive something from the buffer - * @param s The socket - * @param buf The buf to read to - * @param sz How much to read - * @return Number of bytes received - */ int SocketIO::Recv(Socket *s, char *buf, size_t sz) { size_t i = recv(s->GetFD(), buf, sz, 0); @@ -346,26 +317,18 @@ int SocketIO::Recv(Socket *s, char *buf, size_t sz) return i; } -/** Write something to the socket - * @param s The socket - * @param buf The data to write - * @param size The length of the data - */ int SocketIO::Send(Socket *s, const char *buf, size_t sz) { size_t i = send(s->GetFD(), buf, sz, 0); TotalWritten += i; return i; } + int SocketIO::Send(Socket *s, const Anope::string &buf) { return this->Send(s, buf.c_str(), buf.length()); } -/** Accept a connection from a socket - * @param s The socket - * @return The new client socket - */ ClientSocket *SocketIO::Accept(ListenSocket *s) { sockaddrs conaddr; @@ -384,20 +347,11 @@ ClientSocket *SocketIO::Accept(ListenSocket *s) throw SocketException("Unable to accept connection: " + Anope::LastError()); } -/** Finished accepting a connection from a socket - * @param s The socket - * @return SF_ACCEPTED if accepted, SF_ACCEPTING if still in process, SF_DEAD on error - */ SocketFlag SocketIO::FinishAccept(ClientSocket *cs) { return SF_ACCEPTED; } -/** Bind a socket - * @param s The socket - * @param ip The IP to bind to - * @param port The optional port to bind to - */ void SocketIO::Bind(Socket *s, const Anope::string &ip, int port) { s->bindaddr.pton(s->IsIPv6() ? AF_INET6 : AF_INET, ip, port); @@ -405,11 +359,6 @@ void SocketIO::Bind(Socket *s, const Anope::string &ip, int port) throw SocketException("Unable to bind to address: " + Anope::LastError()); } -/** Connect the socket - * @param s THe socket - * @param target IP to connect to - * @param port to connect to - */ void SocketIO::Connect(ConnectionSocket *s, const Anope::string &target, int port) { s->UnsetFlag(SF_CONNECTING); @@ -433,10 +382,6 @@ void SocketIO::Connect(ConnectionSocket *s, const Anope::string &target, int por } } -/** Called to potentially finish a pending connection - * @param s The socket - * @return SF_CONNECTED on success, SF_CONNECTING if still pending, and SF_DEAD on error. - */ SocketFlag SocketIO::FinishConnect(ConnectionSocket *s) { if (s->HasFlag(SF_CONNECTED)) @@ -461,148 +406,102 @@ SocketFlag SocketIO::FinishConnect(ConnectionSocket *s) } } -/** Empty constructor, should not be called. - */ -Socket::Socket() : Flags<SocketFlag>(SocketFlagStrings) +Socket::Socket() { throw CoreException("Socket::Socket() ?"); } -/** Constructor - * @param sock The socket - * @param ipv6 IPv6? - * @param type The socket type, defaults to SOCK_STREAM - */ -Socket::Socket(int sock, bool ipv6, int type) : Flags<SocketFlag>(SocketFlagStrings) +Socket::Socket(int s, bool i, int type) { - this->IO = &normalSocketIO; - this->IPv6 = ipv6; - if (sock == -1) - this->Sock = socket(this->IPv6 ? AF_INET6 : AF_INET, type, 0); + this->io = &NormalSocketIO; + this->ipv6 = i; + if (s == -1) + this->sock = socket(this->ipv6 ? AF_INET6 : AF_INET, type, 0); else - this->Sock = sock; + this->sock = s; this->SetNonBlocking(); - SocketEngine::Sockets[this->Sock] = this; + SocketEngine::Sockets[this->sock] = this; SocketEngine::Change(this, true, SF_READABLE); } -/** Default destructor -*/ Socket::~Socket() { SocketEngine::Change(this, false, SF_READABLE); SocketEngine::Change(this, false, SF_WRITABLE); - anope_close(this->Sock); - this->IO->Destroy(); - SocketEngine::Sockets.erase(this->Sock); + anope_close(this->sock); + this->io->Destroy(); + SocketEngine::Sockets.erase(this->sock); } -/** Get the socket FD for this socket - * @return the fd - */ int Socket::GetFD() const { - return Sock; + return sock; } -/** Check if this socket is IPv6 - * @return true or false - */ bool Socket::IsIPv6() const { - return IPv6; + return ipv6; } -/** Mark a socket as blockig - * @return true if the socket is now blocking - */ bool Socket::SetBlocking() { int flags = fcntl(this->GetFD(), F_GETFL, 0); return !fcntl(this->GetFD(), F_SETFL, flags & ~O_NONBLOCK); } -/** Mark a socket as non-blocking - * @return true if the socket is now non-blocking - */ bool Socket::SetNonBlocking() { int flags = fcntl(this->GetFD(), F_GETFL, 0); return !fcntl(this->GetFD(), F_SETFL, flags | O_NONBLOCK); } -/** Bind the socket to an ip and port - * @param ip The ip - * @param port The port - */ void Socket::Bind(const Anope::string &ip, int port) { - this->IO->Bind(this, ip, port); + this->io->Bind(this, ip, port); } -/** Called when there either is a read or write event. - * @return true to continue to call ProcessRead/ProcessWrite, false to not continue - */ bool Socket::Process() { return true; } -/** Called when there is something to be received for this socket - * @return true on success, false to drop this socket - */ bool Socket::ProcessRead() { return true; } -/** Called when the socket is ready to be written to - * @return true on success, false to drop this socket - */ bool Socket::ProcessWrite() { return true; } -/** Called when there is an error for this socket - * @return true on success, false to drop this socket - */ void Socket::ProcessError() { } -/** Constructor - * @param bindip The IP to bind to - * @param port The port to listen on - * @param ipv6 true for ipv6 - */ -ListenSocket::ListenSocket(const Anope::string &bindip, int port, bool ipv6) +ListenSocket::ListenSocket(const Anope::string &bindip, int port, bool i) { this->SetNonBlocking(); const char op = 1; setsockopt(this->GetFD(), SOL_SOCKET, SO_REUSEADDR, &op, sizeof(op)); - this->bindaddr.pton(IPv6 ? AF_INET6 : AF_INET, bindip, port); - this->IO->Bind(this, bindip, port); + this->bindaddr.pton(i ? AF_INET6 : AF_INET, bindip, port); + this->io->Bind(this, bindip, port); - if (listen(Sock, SOMAXCONN) == -1) + if (listen(sock, SOMAXCONN) == -1) throw SocketException("Unable to listen: " + Anope::LastError()); } -/** Destructor - */ ListenSocket::~ListenSocket() { } -/** Accept a connection in this sockets queue - */ bool ListenSocket::ProcessRead() { try { - this->IO->Accept(this); + this->io->Accept(this); } catch (const SocketException &ex) { diff --git a/src/threadengine.cpp b/src/threadengine.cpp index c3ecdd1b5..12e14eb19 100644 --- a/src/threadengine.cpp +++ b/src/threadengine.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ #include "services.h" @@ -35,9 +36,6 @@ static inline pthread_attr_t *get_engine_attr() return &attr; } -/** Entry point used for the threads - * @param parameter A Thread* cast to a void* - */ static void *entry_point(void *parameter) { Thread *thread = static_cast<Thread *>(parameter); @@ -47,129 +45,92 @@ static void *entry_point(void *parameter) return NULL; } -/** Threads constructor - */ Thread::Thread() : exit(false) { } -/** Threads destructor - */ Thread::~Thread() { } -/** Join to the thread, sets the exit state to true - */ void Thread::Join() { this->SetExitState(); - pthread_join(Handle, NULL); + pthread_join(handle, NULL); } -/** Sets the exit state as true informing the thread we want it to shut down - */ void Thread::SetExitState() { this->Notify(); exit = true; } -/** Exit the thread. Note that the thread still must be joined to free resources! - */ void Thread::Exit() { this->SetExitState(); pthread_exit(0); } -/** Launch the thread - */ void Thread::Start() { - if (pthread_create(&this->Handle, get_engine_attr(), entry_point, this)) + if (pthread_create(&this->handle, get_engine_attr(), entry_point, this)) { this->SetFlag(SF_DEAD); throw CoreException("Unable to create thread: " + Anope::LastError()); } } -/** Returns the exit state of the thread - * @return true if we want to exit - */ bool Thread::GetExitState() const { return exit; } -/** Called when this thread should be joined to - */ void Thread::OnNotify() { this->Join(); this->SetFlag(SF_DEAD); } -/** Constructor - */ Mutex::Mutex() { pthread_mutex_init(&mutex, NULL); } -/** Destructor - */ Mutex::~Mutex() { pthread_mutex_destroy(&mutex); } -/** Attempt to lock the mutex, will hang until a lock can be achieved - */ void Mutex::Lock() { pthread_mutex_lock(&mutex); } -/** Unlock the mutex, it must be locked first - */ void Mutex::Unlock() { pthread_mutex_unlock(&mutex); } -/** Attempt to lock the mutex, will return true on success and false on fail - * Does not block - * @return true or false - */ bool Mutex::TryLock() { return pthread_mutex_trylock(&mutex) == 0; } -/** Constructor - */ Condition::Condition() : Mutex() { pthread_cond_init(&cond, NULL); } -/** Destructor - */ Condition::~Condition() { pthread_cond_destroy(&cond); } -/** Called to wakeup the waiter - */ void Condition::Wakeup() { pthread_cond_signal(&cond); } -/** Called to wait for a Wakeup() call - */ void Condition::Wait() { pthread_cond_wait(&cond, &mutex); diff --git a/src/timers.cpp b/src/timers.cpp index 267629aee..bc88afb01 100644 --- a/src/timers.cpp +++ b/src/timers.cpp @@ -4,21 +4,14 @@ * Contact us at team@anope.org * * Please read COPYING and README for further details. - * Based on the original code of Epona by Lara. - * Based on the original code of Services by Andy Church. + * */ - #include "services.h" #include "timers.h" std::vector<Timer *> TimerManager::Timers; -/** Default constructor, initializes the triggering time - * @param time_from_now The number of seconds from now to trigger the timer - * @param now The time now - * @param repeating Repeat this timer every time_from_now if this is true - */ Timer::Timer(long time_from_now, time_t now, bool repeating) { trigger = now + time_from_now; @@ -29,48 +22,31 @@ Timer::Timer(long time_from_now, time_t now, bool repeating) TimerManager::AddTimer(this); } -/** Default destructor, removes the timer from the list - */ Timer::~Timer() { TimerManager::DelTimer(this); } -/** Set the trigger time to a new value - * @param t The new time -*/ void Timer::SetTimer(time_t t) { trigger = t; } -/** Retrieve the triggering time - * @return The trigger time - */ time_t Timer::GetTimer() const { return trigger; } -/** Returns true if the timer is set to repeat - * @return Returns true if the timer is set to repeat - */ bool Timer::GetRepeat() const { return repeat; } -/** Returns the time this timer was created -* @return The time this timer was created -*/ time_t Timer::GetSetTime() const { return settime; } -/** Sets the interval between ticks - * @param t The new interval - */ void Timer::SetSecs(time_t t) { secs = t; @@ -80,37 +56,25 @@ void Timer::SetSecs(time_t t) TimerManager::AddTimer(this); } -/** Returns the interval between ticks -* @return The interval -*/ long Timer::GetSecs() const { return secs; } -/** Add a timer to the list - * @param T A Timer derived class to add - */ -void TimerManager::AddTimer(Timer *T) +void TimerManager::AddTimer(Timer *t) { - Timers.push_back(T); + Timers.push_back(t); sort(Timers.begin(), Timers.end(), TimerManager::TimerComparison); } -/** Deletes a timer - * @param T A Timer derived class to delete - */ -void TimerManager::DelTimer(Timer *T) +void TimerManager::DelTimer(Timer *t) { - std::vector<Timer *>::iterator i = std::find(Timers.begin(), Timers.end(), T); + std::vector<Timer *>::iterator i = std::find(Timers.begin(), Timers.end(), t); if (i != Timers.end()) Timers.erase(i); } -/** Tick all pending timers - * @param ctime The current time - */ void TimerManager::TickTimers(time_t ctime) { while (Timers.size() && ctime > Timers.front()->GetTimer()) @@ -129,8 +93,6 @@ void TimerManager::TickTimers(time_t ctime) } } -/** Compares two timers - */ bool TimerManager::TimerComparison(Timer *one, Timer *two) { return one->GetTimer() < two->GetTimer(); diff --git a/src/tools/CMakeLists.txt b/src/tools/CMakeLists.txt index 88fc37ffc..613e4ffc6 100644 --- a/src/tools/CMakeLists.txt +++ b/src/tools/CMakeLists.txt @@ -34,6 +34,14 @@ foreach(SRC ${TOOLS_SRCS}) endif(NOT SKIP) endforeach(SRC) +# If not on Windows, generate anoperc and install it along with mydbgen +if(NOT WIN32) + configure_file(${Anope_SOURCE_DIR}/src/tools/anoperc.in ${Anope_BINARY_DIR}/src/tools/anoperc) + install (PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/anoperc + DESTINATION ${BIN_DIR} + ) +endif(NOT WIN32) + # On non-Windows platforms, if RUNGROUP is set, change the permissions of the tools directory if(NOT WIN32 AND RUNGROUP) install(CODE "execute_process(COMMAND ${CHMOD} 2770 \"\${CMAKE_INSTALL_PREFIX}/bin\")") diff --git a/src/bin/anoperc.in b/src/tools/anoperc.in index 9a71a22c3..9a71a22c3 100644 --- a/src/bin/anoperc.in +++ b/src/tools/anoperc.in diff --git a/src/uplink.cpp b/src/uplink.cpp new file mode 100644 index 000000000..ac77672b2 --- /dev/null +++ b/src/uplink.cpp @@ -0,0 +1,204 @@ +/* + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + +#include "uplink.h" +#include "logger.h" +#include "config.h" +#include "protocol.h" +#include "servers.h" +#include "dns.h" + +UplinkSocket *UplinkSock = NULL; + +class ReconnectTimer : public Timer +{ + public: + ReconnectTimer(int wait) : Timer(wait) { } + + void Tick(time_t) + { + try + { + Uplink::Connect(); + } + catch (const SocketException &ex) + { + Log(LOG_TERMINAL) << "Unable to connect to uplink #" << (Anope::CurrentUplink + 1) << " (" << Config->Uplinks[Anope::CurrentUplink]->host << ":" << Config->Uplinks[Anope::CurrentUplink]->port << "): " << ex.GetReason(); + } + } +}; + +void Uplink::Connect() +{ + if (static_cast<unsigned>(++Anope::CurrentUplink) >= Config->Uplinks.size()) + Anope::CurrentUplink = 0; + + ServerConfig::Uplink *u = Config->Uplinks[Anope::CurrentUplink]; + + new UplinkSocket(); + if (!Config->LocalHost.empty()) + UplinkSock->Bind(Config->LocalHost); + FOREACH_MOD(I_OnPreServerConnect, OnPreServerConnect()); + DNS::Query rep = DNS::Manager::BlockingQuery(u->host, u->ipv6 ? DNS::QUERY_AAAA : DNS::QUERY_A); + Anope::string reply_ip = !rep.answers.empty() ? rep.answers.front().rdata : u->host; + Log(LOG_TERMINAL) << "Attempting to connect to uplink #" << (Anope::CurrentUplink + 1) << " " << u->host << " (" << reply_ip << "), port " << u->port; + UplinkSock->Connect(reply_ip, u->port); +} + + +UplinkSocket::UplinkSocket() : Socket(-1, Config->Uplinks[Anope::CurrentUplink]->ipv6), ConnectionSocket(), BufferedSocket() +{ + UplinkSock = this; +} + +UplinkSocket::~UplinkSocket() +{ + if (IRCD && Servers::GetUplink() && Servers::GetUplink()->IsSynced()) + { + FOREACH_MOD(I_OnServerDisconnect, OnServerDisconnect()); + + for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) + { + User *u = it->second; + + if (u->server == Me) + { + /* Don't use quitmsg here, it may contain information you don't want people to see */ + IRCD->SendQuit(u, "Shutting down"); + BotInfo* bi = BotInfo::Find(u->nick); + if (bi != NULL) + bi->introduced = false; + } + } + + IRCD->SendSquit(Me, Anope::QuitReason); + + this->ProcessWrite(); // Write out the last bit + } + + if (Me) + for (unsigned i = Me->GetLinks().size(); i > 0; --i) + if (!Me->GetLinks()[i - 1]->HasFlag(SERVER_JUPED)) + Me->GetLinks()[i - 1]->Delete(Me->GetName() + " " + Me->GetLinks()[i - 1]->GetName()); + + UplinkSock = NULL; + + Me->SetFlag(SERVER_SYNCING); + + if (Anope::AtTerm()) + { + if (static_cast<unsigned>(Anope::CurrentUplink + 1) == Config->Uplinks.size()) + { + Anope::QuitReason = "Unable to connect to any uplink"; + Anope::Quitting = true; + Anope::ReturnValue = -1; + } + else + { + new ReconnectTimer(1); + } + } + else if (!Anope::Quitting) + { + int retry = Config->RetryWait; + if (retry <= 0) + retry = 60; + + Log() << "Disconnected, retrying in " << retry << " seconds"; + new ReconnectTimer(retry); + } +} + +bool UplinkSocket::Read(const Anope::string &buf) +{ + Anope::Process(buf); + return true; +} + +void UplinkSocket::OnConnect() +{ + Log(LOG_TERMINAL) << "Successfully connected to uplink #" << (Anope::CurrentUplink + 1) << " " << Config->Uplinks[Anope::CurrentUplink]->host << ":" << Config->Uplinks[Anope::CurrentUplink]->port; + IRCD->SendConnect(); + FOREACH_MOD(I_OnServerConnect, OnServerConnect()); +} + +void UplinkSocket::OnError(const Anope::string &error) +{ + Log(LOG_TERMINAL) << "Unable to connect to uplink #" << (Anope::CurrentUplink + 1) << " (" << Config->Uplinks[Anope::CurrentUplink]->host << ":" << Config->Uplinks[Anope::CurrentUplink]->port << ")" << (!error.empty() ? (": " + error) : ""); +} + +UplinkSocket::Message::Message() : server(NULL), user(NULL) +{ +} + +UplinkSocket::Message::Message(const Server *s) : server(s), user(NULL) +{ +} + +UplinkSocket::Message::Message(const User *u) : server(NULL), user(u) +{ + if (!u) + server = Me; +} + +UplinkSocket::Message::~Message() +{ + Anope::string message_source = ""; + + if (this->server != NULL) + { + if (this->server != Me && !this->server->HasFlag(SERVER_JUPED)) + { + Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" from " << this->server->GetName() << " who is not from me?"; + return; + } + + message_source = this->server->GetSID(); + } + else if (this->user != NULL) + { + if (this->user->server != Me && !this->user->server->HasFlag(SERVER_JUPED)) + { + Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" from " << this->user->nick << " who is not from me?"; + return; + } + + const BotInfo *bi = BotInfo::Find(this->user->nick); + if (bi != NULL && bi->introduced == false) + { + Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" from " << bi->nick << " when not introduced"; + return; + } + + message_source = this->user->GetUID(); + } + + if (!UplinkSock) + { + if (!message_source.empty()) + Log(LOG_DEBUG) << "Attempted to send \"" << message_source << " " << this->buffer.str() << "\" with UplinkSock NULL"; + else + Log(LOG_DEBUG) << "Attempted to send \"" << this->buffer.str() << "\" with UplinkSock NULL"; + return; + } + + if (!message_source.empty()) + { + UplinkSock->Write(":" + message_source + " " + this->buffer.str()); + Log(LOG_RAWIO) << "Sent: :" << message_source << " " << this->buffer.str(); + } + else + { + UplinkSock->Write(this->buffer.str()); + Log(LOG_RAWIO) << "Sent: " << this->buffer.str(); + } +} diff --git a/src/users.cpp b/src/users.cpp index ea02566d4..628b0c464 100644 --- a/src/users.cpp +++ b/src/users.cpp @@ -7,6 +7,7 @@ * * Based on the original code of Epona by Lara. * Based on the original code of Services by Andy Church. + * */ @@ -20,16 +21,15 @@ #include "bots.h" #include "config.h" #include "opertype.h" -#include "extern.h" +#include "nickserv.h" +#include "operserv.h" +#include "language.h" user_map UserListByNick, UserListByUID; -int32_t opcnt = 0; -uint32_t usercnt = 0, maxusercnt = 0; -time_t maxusertime; - -/*************************************************************************/ -/*************************************************************************/ +int OperCount = 0; +unsigned MaxUserCount = 0; +time_t MaxUserTime = 0; User::User(const Anope::string &snick, const Anope::string &sident, const Anope::string &shost, const Anope::string &svhost, const Anope::string &sip, Server *sserver, const Anope::string &srealname, time_t ssignon, const Anope::string &smodes, const Anope::string &suid) { @@ -39,7 +39,7 @@ User::User(const Anope::string &snick, const Anope::string &sident, const Anope: /* we used to do this by calloc, no more. */ server = NULL; invalid_pw_count = invalid_pw_time = lastmemosend = lastnickreg = lastmail = 0; - OnAccess = false; + on_access = false; this->nick = snick; this->ident = sident; @@ -53,7 +53,7 @@ User::User(const Anope::string &snick, const Anope::string &sident, const Anope: this->timestamp = this->signon = ssignon; this->SetModesInternal("%s", smodes.c_str()); this->uid = suid; - this->SuperAdmin = false; + this->super_admin = false; size_t old = UserListByNick.size(); UserListByNick[snick] = this; @@ -66,22 +66,21 @@ User::User(const Anope::string &snick, const Anope::string &sident, const Anope: if (sserver) // Our bots are introduced on startup with no server { - ++sserver->Users; + ++sserver->users; Log(this, "connect") << (!svhost.empty() ? Anope::string("(") + svhost + ") " : "") << "(" << srealname << ") " << sip << " connected to the network (" << sserver->GetName() << ")"; } - ++usercnt; - if (usercnt > maxusercnt) + if (UserListByNick.size() > MaxUserCount) { - maxusercnt = usercnt; - maxusertime = Anope::CurTime; - Log(this, "maxusers") << "connected - new maximum user count: " << maxusercnt; + MaxUserCount = UserListByNick.size(); + MaxUserTime = Anope::CurTime; + Log(this, "maxusers") << "connected - new maximum user count: " << UserListByNick.size(); } bool exempt = false; if (server && server->IsULined()) exempt = true; - dynamic_reference<User> user = this; + Reference<User> user = this; FOREACH_MOD(I_OnUserConnect, OnUserConnect(user, exempt)); } @@ -91,7 +90,7 @@ void User::ChangeNick(const Anope::string &newnick, time_t ts) if (newnick.empty()) throw CoreException("User::ChangeNick() got a bad argument"); - this->SuperAdmin = false; + this->super_admin = false; Log(this, "nick") << "(" << this->realname << ") changed nick to " << newnick; Anope::string old = this->nick; @@ -101,7 +100,7 @@ void User::ChangeNick(const Anope::string &newnick, time_t ts) this->nick = newnick; else { - NickAlias *old_na = findnick(this->nick); + NickAlias *old_na = NickAlias::Find(this->nick); if (old_na && (this->IsIdentified(true) || this->IsRecognized())) old_na->last_seen = Anope::CurTime; @@ -109,10 +108,10 @@ void User::ChangeNick(const Anope::string &newnick, time_t ts) this->nick = newnick; UserListByNick[this->nick] = this; - OnAccess = false; - NickAlias *na = findnick(this->nick); + on_access = false; + NickAlias *na = NickAlias::Find(this->nick); if (na) - OnAccess = is_on_access(this, na->nc); + on_access = na->nc->IsOnAccess(this); if (old_na) old_na->OnCancel(this); @@ -139,9 +138,6 @@ void User::SetDisplayedHost(const Anope::string &shost) this->UpdateHost(); } -/** Get the displayed vhost of a user record. - * @return The displayed vhost of the user, where ircd-supported, or the user's real host. - */ const Anope::string &User::GetDisplayedHost() const { if (!this->vhost.empty()) @@ -152,9 +148,6 @@ const Anope::string &User::GetDisplayedHost() const return this->host; } -/** Update the cloaked host of a user - * @param host The cloaked host - */ void User::SetCloakedHost(const Anope::string &newhost) { if (newhost.empty()) @@ -167,9 +160,6 @@ void User::SetCloakedHost(const Anope::string &newhost) this->UpdateHost(); } -/** Get the cloaked host of a user - * @return The cloaked host - */ const Anope::string &User::GetCloakedHost() const { return chost; @@ -177,7 +167,7 @@ const Anope::string &User::GetCloakedHost() const const Anope::string &User::GetUID() const { - if (!this->uid.empty() && ircdproto->RequiresID) + if (!this->uid.empty() && IRCD->RequiresID) return this->uid; else return this->nick; @@ -230,7 +220,7 @@ void User::SetRealname(const Anope::string &srealname) throw CoreException("realname empty in SetRealname"); this->realname = srealname; - NickAlias *na = findnick(this->nick); + NickAlias *na = NickAlias::Find(this->nick); if (na && (this->IsIdentified(true) || this->IsRecognized())) na->last_realname = srealname; @@ -243,17 +233,15 @@ User::~User() Log(LOG_DEBUG_2) << "User::~User() called"; Log(this, "disconnect") << "(" << this->realname << ") " << "disconnected from the network (" << this->server->GetName() << ")"; - --this->server->Users; + --this->server->users; FOREACH_MOD(I_OnUserLogoff, OnUserLogoff(this)); ModeManager::StackerDel(this); this->Logout(); - --usercnt; - if (this->HasMode(UMODE_OPER)) - --opcnt; + --OperCount; while (!this->chans.empty()) this->chans.front()->chan->DeleteUser(this); @@ -262,7 +250,7 @@ User::~User() if (!this->uid.empty()) UserListByUID.erase(this->uid); - NickAlias *na = findnick(this->nick); + NickAlias *na = NickAlias::Find(this->nick); if (na) na->OnCancel(this); @@ -274,7 +262,7 @@ void User::SendMessage(const BotInfo *source, const char *fmt, ...) va_list args; char buf[BUFSIZE] = ""; - const char *translated_message = translate(this, fmt); + const char *translated_message = Language::Translate(this, fmt); va_start(args, fmt); vsnprintf(buf, BUFSIZE - 1, translated_message, args); @@ -286,7 +274,7 @@ void User::SendMessage(const BotInfo *source, const char *fmt, ...) void User::SendMessage(const BotInfo *source, const Anope::string &msg) { - const char *translated_message = translate(this, msg.c_str()); + const char *translated_message = Language::Translate(this, msg.c_str()); /* Send privmsg instead of notice if: * - UsePrivmsg is enabled @@ -298,9 +286,9 @@ void User::SendMessage(const BotInfo *source, const Anope::string &msg) while (sep.GetToken(tok)) { if (Config->UsePrivmsg && ((!this->nc && Config->NSDefFlags.HasFlag(NI_MSG)) || (this->nc && this->nc->HasFlag(NI_MSG)))) - ircdproto->SendPrivmsg(source, this->GetUID(), "%s", tok.c_str()); + IRCD->SendPrivmsg(source, this->GetUID(), "%s", tok.c_str()); else - ircdproto->SendNotice(source, this->GetUID(), "%s", tok.c_str()); + IRCD->SendNotice(source, this->GetUID(), "%s", tok.c_str()); } } @@ -362,13 +350,10 @@ void User::SendMessage(const BotInfo *source, const Anope::string &msg) */ void User::Collide(NickAlias *na) { - const BotInfo *bi = findbot(Config->NickServ); - if (!bi) - return; if (na) na->SetFlag(NS_COLLIDED); - if (ircdproto->CanSVSNick) + if (IRCD->CanSVSNick) { Anope::string guestnick; @@ -376,25 +361,21 @@ void User::Collide(NickAlias *na) do { guestnick = Config->NSGuestNickPrefix + stringify(static_cast<uint16_t>(rand())); - } while (finduser(guestnick) && i++ < 10); + } while (User::Find(guestnick) && i++ < 10); if (i == 11) this->Kill(Config->NickServ, "Services nickname-enforcer kill"); else { - this->SendMessage(bi, _("Your nickname is now being changed to \002%s\002"), guestnick.c_str()); - ircdproto->SendForceNickChange(this, guestnick, Anope::CurTime); + if (NickServ) + this->SendMessage(NickServ, _("Your nickname is now being changed to \002%s\002"), guestnick.c_str()); + IRCD->SendForceNickChange(this, guestnick, Anope::CurTime); } } else this->Kill(Config->NickServ, "Services nickname-enforcer kill"); } -/** Identify the user to the Nick - * updates last_seen, logs the user in, - * send messages, checks for mails, set vhost and more - * @param the NickAlias - */ void User::Identify(NickAlias *na) { if (!na) @@ -414,45 +395,41 @@ void User::Identify(NickAlias *na) } this->Login(na->nc); - ircdproto->SendLogin(this); + IRCD->SendLogin(this); - const NickAlias *this_na = findnick(this->nick); + const NickAlias *this_na = NickAlias::Find(this->nick); if (!Config->NoNicknameOwnership && this_na && this_na->nc == *na->nc && na->nc->HasFlag(NI_UNCONFIRMED) == false) - this->SetMode(findbot(Config->NickServ), UMODE_REGISTERED); + this->SetMode(NickServ, UMODE_REGISTERED); FOREACH_MOD(I_OnNickIdentify, OnNickIdentify(this)); if (this->IsServicesOper()) { - const BotInfo *bi = findbot(Config->OperServ); if (!this->nc->o->ot->modes.empty()) { - this->SetModes(bi, "%s", this->nc->o->ot->modes.c_str()); - if (bi != NULL) - this->SendMessage(bi, "Changing your usermodes to \002%s\002", this->nc->o->ot->modes.c_str()); + this->SetModes(OperServ, "%s", this->nc->o->ot->modes.c_str()); + if (OperServ) + this->SendMessage(OperServ, "Changing your usermodes to \002%s\002", this->nc->o->ot->modes.c_str()); UserMode *um = ModeManager::FindUserModeByName(UMODE_OPER); - if (um && !this->HasMode(UMODE_OPER) && this->nc->o->ot->modes.find(um->ModeChar) != Anope::string::npos) - ircdproto->SendOper(this); + if (um && !this->HasMode(UMODE_OPER) && this->nc->o->ot->modes.find(um->mchar) != Anope::string::npos) + IRCD->SendOper(this); } - if (ircdproto->CanSetVHost && !this->nc->o->vhost.empty()) + if (IRCD->CanSetVHost && !this->nc->o->vhost.empty()) { - if (bi != NULL) - this->SendMessage(bi, "Changing your vhost to \002%s\002", this->nc->o->vhost.c_str()); + if (OperServ) + this->SendMessage(OperServ, "Changing your vhost to \002%s\002", this->nc->o->vhost.c_str()); this->SetDisplayedHost(this->nc->o->vhost); - ircdproto->SendVhost(this, "", this->nc->o->vhost); + IRCD->SendVhost(this, "", this->nc->o->vhost); } } } -/** Login the user to a NickCore - * @param core The account the user is useing - */ void User::Login(NickCore *core) { this->Logout(); this->nc = core; - core->Users.push_back(this); + core->users.push_back(this); this->UpdateHost(); @@ -460,8 +437,6 @@ void User::Login(NickCore *core) Log(this, "account") << "is now identified as " << this->nc->display; } -/** Logout the user - */ void User::Logout() { if (!this->nc) @@ -469,30 +444,23 @@ void User::Logout() Log(this, "account") << "is no longer identified as " << this->nc->display; - std::list<User *>::iterator it = std::find(this->nc->Users.begin(), this->nc->Users.end(), this); - if (it != this->nc->Users.end()) - this->nc->Users.erase(it); + std::list<User *>::iterator it = std::find(this->nc->users.begin(), this->nc->users.end(), this); + if (it != this->nc->users.end()) + this->nc->users.erase(it); this->nc = NULL; } -/** Get the account the user is logged in using - * @reurn The account or NULL - */ NickCore *User::Account() const { return this->nc; } -/** Check if the user is identified for their nick - * @param CheckNick True to check if the user is identified to the nickname they are on too - * @return true or false - */ bool User::IsIdentified(bool CheckNick) const { if (CheckNick && this->nc) { - NickAlias *na = findnick(this->nc->display); + NickAlias *na = NickAlias::Find(this->nc->display); if (na && *na->nc == *this->nc) return true; @@ -503,26 +471,19 @@ bool User::IsIdentified(bool CheckNick) const return this->nc ? true : false; } -/** Check if the user is recognized for their nick (on the nicks access list) - * @param CheckSecure Only returns true if the user has secure off - * @return true or false - */ bool User::IsRecognized(bool CheckSecure) const { - if (CheckSecure && OnAccess) + if (CheckSecure && on_access) { - const NickAlias *na = findnick(this->nick); + const NickAlias *na = NickAlias::Find(this->nick); if (!na || na->nc->HasFlag(NI_SECURE)) return false; } - return OnAccess; + return on_access; } -/** Check if the user is a services oper - * @return true if they are an oper - */ bool User::IsServicesOper() { if (!this->nc || !this->nc->IsServicesOper()) @@ -552,10 +513,6 @@ bool User::IsServicesOper() return true; } -/** Check whether this user has access to run the given command string. - * @param cmdstr The string to check, e.g. botserv/set/private. - * @return True if this user may run the specified command, false otherwise. - */ bool User::HasCommand(const Anope::string &command) { if (this->IsServicesOper()) @@ -563,10 +520,6 @@ bool User::HasCommand(const Anope::string &command) return false; } -/** Check whether this user has access to the given special permission. - * @param privstr The priv to check for, e.g. users/auspex. - * @return True if this user has the specified priv, false otherwise. - */ bool User::HasPriv(const Anope::string &priv) { if (this->IsServicesOper()) @@ -574,17 +527,15 @@ bool User::HasPriv(const Anope::string &priv) return false; } -/** Update the last usermask stored for a user, and check to see if they are recognized - */ void User::UpdateHost() { if (this->host.empty()) return; - NickAlias *na = findnick(this->nick); - OnAccess = false; + NickAlias *na = NickAlias::Find(this->nick); + on_access = false; if (na) - OnAccess = is_on_access(this, na->nc); + on_access = na->nc->IsOnAccess(this); if (na && (this->IsIdentified(true) || this->IsRecognized())) { @@ -595,97 +546,64 @@ void User::UpdateHost() } } -/** Check if the user has a mode - * @param Name Mode name - * @return true or false - */ bool User::HasMode(UserModeName Name) const { return this->modes.HasFlag(Name); } -/** Set a mode internally on the user, the IRCd is not informed - * @param um The user mode - * @param Param The param, if there is one - */ -void User::SetModeInternal(UserMode *um, const Anope::string &Param) +void User::SetModeInternal(UserMode *um, const Anope::string ¶m) { if (!um) return; - this->modes.SetFlag(um->Name); - if (!Param.empty()) - Params.insert(std::make_pair(um->Name, Param)); + this->modes.SetFlag(um->name); + if (!param.empty()) + this->mode_params.insert(std::make_pair(um->name, param)); - FOREACH_MOD(I_OnUserModeSet, OnUserModeSet(this, um->Name)); + FOREACH_MOD(I_OnUserModeSet, OnUserModeSet(this, um->name)); } -/** Remove a mode internally on the user, the IRCd is not informed - * @param um The user mode - */ void User::RemoveModeInternal(UserMode *um) { if (!um) return; - this->modes.UnsetFlag(um->Name); - std::map<UserModeName, Anope::string>::iterator it = Params.find(um->Name); - if (it != Params.end()) - Params.erase(it); + this->modes.UnsetFlag(um->name); + std::map<UserModeName, Anope::string>::iterator it = this->mode_params.find(um->name); + if (it != this->mode_params.end()) + this->mode_params.erase(it); - FOREACH_MOD(I_OnUserModeUnset, OnUserModeUnset(this, um->Name)); + FOREACH_MOD(I_OnUserModeUnset, OnUserModeUnset(this, um->name)); } -/** Set a mode on the user - * @param bi The client setting the mode - * @param um The user mode - * @param Param Optional param for the mode - */ void User::SetMode(const BotInfo *bi, UserMode *um, const Anope::string &Param) { - if (!um || HasMode(um->Name)) + if (!um || HasMode(um->name)) return; ModeManager::StackerAdd(bi, this, um, true, Param); SetModeInternal(um, Param); } -/** Set a mode on the user - * @param bi The client setting the mode - * @param Name The mode name - * @param param Optional param for the mode - */ void User::SetMode(const BotInfo *bi, UserModeName Name, const Anope::string &Param) { SetMode(bi, ModeManager::FindUserModeByName(Name), Param); } -/** Remove a mode on the user - * @param bi The client setting the mode - * @param um The user mode - */ void User::RemoveMode(const BotInfo *bi, UserMode *um) { - if (!um || !HasMode(um->Name)) + if (!um || !HasMode(um->name)) return; ModeManager::StackerAdd(bi, this, um, false); RemoveModeInternal(um); } -/** Remove a mode from the user - * @param bi The client setting the mode - * @param Name The mode name - */ void User::RemoveMode(const BotInfo *bi, UserModeName Name) { RemoveMode(bi, ModeManager::FindUserModeByName(Name)); } -/** Set a string of modes on a user - * @param bi The client setting the mode - * @param umodes The modes - */ void User::SetModes(const BotInfo *bi, const char *umodes, ...) { char buf[BUFSIZE] = ""; @@ -720,7 +638,7 @@ void User::SetModes(const BotInfo *bi, const char *umodes, ...) if (add) { - if (um->Type == MODE_PARAM && sep.GetToken(sbuf)) + if (um->type == MODE_PARAM && sep.GetToken(sbuf)) this->SetMode(bi, um, sbuf); else this->SetMode(bi, um); @@ -766,7 +684,7 @@ void User::SetModesInternal(const char *umodes, ...) if (add) { - if (um->Type == MODE_PARAM && sep.GetToken(sbuf)) + if (um->type == MODE_PARAM && sep.GetToken(sbuf)) this->SetModeInternal(um, sbuf); else this->SetModeInternal(um); @@ -774,13 +692,13 @@ void User::SetModesInternal(const char *umodes, ...) else this->RemoveModeInternal(um); - switch (um->Name) + switch (um->name) { case UMODE_OPER: if (add) - ++opcnt; + ++OperCount; else - --opcnt; + --OperCount; break; case UMODE_CLOAK: case UMODE_VHOST: @@ -803,18 +721,12 @@ Anope::string User::GetModes() const UserMode *um = ModeManager::FindUserModeByName(static_cast<UserModeName>(i)); if (um == NULL) continue; - ret += um->ModeChar; + ret += um->mchar; } return ret; } -/** Find the channel container for Channel c that the user is on - * This is preferred over using FindUser in Channel, as there are usually more users in a channel - * than channels a user is in - * @param c The channel - * @return The channel container, or NULL - */ ChannelContainer *User::FindChannel(const Channel *c) const { for (UChannelList::const_iterator it = this->chans.begin(), it_end = this->chans.end(); it != it_end; ++it) @@ -823,9 +735,6 @@ ChannelContainer *User::FindChannel(const Channel *c) const return NULL; } -/** Check if the user is protected from kicks and negative mode changes - * @return true or false - */ bool User::IsProtected() const { if (this->HasMode(UMODE_PROTECTED) || this->HasMode(UMODE_GOD)) @@ -839,14 +748,14 @@ void User::Kill(const Anope::string &source, const Anope::string &reason) Anope::string real_source = source.empty() ? Config->ServerName : source; Anope::string real_reason = real_source + " (" + reason + ")"; - ircdproto->SendSVSKill(findbot(source), this, "%s", real_reason.c_str()); + IRCD->SendSVSKill(BotInfo::Find(source), this, "%s", real_reason.c_str()); } void User::KillInternal(const Anope::string &source, const Anope::string &reason) { Log(this, "killed") << "was killed by " << source << " (Reason: " << reason << ")"; - NickAlias *na = findnick(this->nick); + NickAlias *na = NickAlias::Find(this->nick); if (na && !na->nc->HasFlag(NI_SUSPENDED) && (this->IsRecognized() || this->IsIdentified(true))) { na->last_seen = Anope::CurTime; @@ -856,61 +765,12 @@ void User::KillInternal(const Anope::string &source, const Anope::string &reason delete this; } -User *finduser(const Anope::string &nick) -{ - if (isdigit(nick[0]) && ircdproto->RequiresID) - { - user_map::iterator it = UserListByUID.find(nick); - if (it != UserListByUID.end()) - return it->second; - } - else - { - user_map::iterator it = UserListByNick.find(nick); - if (it != UserListByNick.end()) - return it->second; - } - - return NULL; -} - -bool matches_list(Channel *c, User *user, ChannelModeName mode) -{ - if (!c || !c->HasMode(mode)) - return false; - - - std::pair<Channel::ModeList::iterator, Channel::ModeList::iterator> modes = c->GetModeList(mode); - for (; modes.first != modes.second; ++modes.first) - { - Entry e(mode, modes.first->second); - if (e.Matches(user)) - return true; - } - - return false; -} - -/*************************************************************************/ - -/* Given a user, return a mask that will most likely match any address the - * user will have from that location. For IP addresses, wildcards the - * appropriate subnet mask (e.g. 35.1.1.1 -> 35.*; 128.2.1.1 -> 128.2.*); - * for named addresses, wildcards the leftmost part of the name unless the - * name only contains two parts. If the username begins with a ~, delete - * it. - */ - -Anope::string create_mask(User *u) +Anope::string User::Mask() const { Anope::string mask; - Anope::string mident = u->GetIdent(); - Anope::string mhost = u->GetDisplayedHost(); + Anope::string mident = this->GetIdent(); + Anope::string mhost = this->GetDisplayedHost(); - /* Get us a buffer the size of the username plus hostname. The result - * will never be longer than this (and will often be shorter), thus we - * can use strcpy() and sprintf() safely. - */ if (mident[0] == '~') mask = "*" + mident + "@"; else @@ -930,6 +790,43 @@ Anope::string create_mask(User *u) else mask += mhost; } + return mask; } +bool User::BadPassword() +{ + if (!Config->BadPassLimit) + return false; + + if (Config->BadPassTimeout > 0 && this->invalid_pw_time > 0 && this->invalid_pw_time < Anope::CurTime - Config->BadPassTimeout) + this->invalid_pw_count = 0; + ++this->invalid_pw_count; + this->invalid_pw_time = Anope::CurTime; + if (this->invalid_pw_count >= Config->BadPassLimit) + { + this->Kill(Config->ServerName, "Too many invalid passwords"); + return true; + } + + return false; +} + +User* User::Find(const Anope::string &name, bool nick_only) +{ + if (!nick_only && isdigit(name[0]) && IRCD->RequiresID) + { + user_map::iterator it = UserListByUID.find(name); + if (it != UserListByUID.end()) + return it->second; + } + else + { + user_map::iterator it = UserListByNick.find(name); + if (it != UserListByNick.end()) + return it->second; + } + + return NULL; +} + diff --git a/src/win32/windows.cpp b/src/win32/windows.cpp index 785a38969..f24382f3f 100644 --- a/src/win32/windows.cpp +++ b/src/win32/windows.cpp @@ -43,7 +43,7 @@ static WSADATA wsa; void OnStartup() { if (WSAStartup(MAKEWORD(2, 0), &wsa)) - throw FatalException("Failed to initialize WinSock library"); + throw CoreException("Failed to initialize WinSock library"); } void OnShutdown() diff --git a/src/xline.cpp b/src/xline.cpp new file mode 100644 index 000000000..4ac6581a1 --- /dev/null +++ b/src/xline.cpp @@ -0,0 +1,425 @@ +/* XLine functions. + * + * (C) 2003-2012 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + +#include "services.h" +#include "modules.h" +#include "xline.h" +#include "users.h" +#include "sockets.h" +#include "regexpr.h" +#include "config.h" +#include "commands.h" + +/* List of XLine managers we check users against in XLineManager::CheckAll */ +std::list<XLineManager *> XLineManager::XLineManagers; +Serialize::Checker<std::multimap<Anope::string, XLine *, ci::less> > XLineManager::XLinesByUID("XLine"); + +void XLine::InitRegex() +{ + if (!Config->RegexEngine.empty() && this->mask.length() >= 2 && this->mask[0] == '/' && this->mask[this->mask.length() - 1] == '/') + { + Anope::string stripped_mask = this->mask.substr(1, this->mask.length() - 2); + + ServiceReference<RegexProvider> provider("Regex", Config->RegexEngine); + if (provider) + { + try + { + this->regex = provider->Compile(stripped_mask); + } + catch (const RegexException &ex) + { + Log(LOG_DEBUG) << ex.GetReason(); + } + } + } +} + +XLine::XLine(const Anope::string &ma, const Anope::string &r, const Anope::string &uid) : Serializable("XLine"), mask(ma), by(Config->OperServ), created(0), expires(0), reason(r), id(uid) +{ + regex = NULL; + manager = NULL; + + this->InitRegex(); +} + +XLine::XLine(const Anope::string &ma, const Anope::string &b, const time_t ex, const Anope::string &r, const Anope::string &uid) : Serializable("XLine"), mask(ma), by(b), created(Anope::CurTime), expires(ex), reason(r), id(uid) +{ + regex = NULL; + manager = NULL; + + this->InitRegex(); +} + +XLine::~XLine() +{ + delete regex; +} + +Anope::string XLine::GetNick() const +{ + size_t nick_t = this->mask.find('!'); + + if (nick_t == Anope::string::npos) + return ""; + + return this->mask.substr(0, nick_t); +} + +Anope::string XLine::GetUser() const +{ + size_t user_t = this->mask.find('!'), host_t = this->mask.find('@'); + + if (host_t != Anope::string::npos) + { + if (user_t != Anope::string::npos && host_t > user_t) + return this->mask.substr(user_t + 1, host_t - user_t - 1); + else + return this->mask.substr(0, host_t); + } + else + return ""; +} + +Anope::string XLine::GetHost() const +{ + size_t host_t = this->mask.find('@'), real_t = this->mask.find('#'); + + if (host_t != Anope::string::npos) + { + if (real_t != Anope::string::npos && real_t > host_t) + return this->mask.substr(host_t + 1, real_t - host_t - 1); + else + return this->mask.substr(host_t + 1); + } + else + return ""; +} + +Anope::string XLine::GetReal() const +{ + size_t real_t = this->mask.find('#'); + + if (real_t != Anope::string::npos) + return this->mask.substr(real_t + 1); + else + return ""; +} + +Anope::string XLine::GetReason() const +{ + Anope::string r = this->reason; + if (Config->AddAkiller && !this->by.empty()) + r = "[" + this->by + "] " + r; + if (!this->id.empty()) + r += " (ID: " + this->id + ")"; + return r; +} + +bool XLine::HasNickOrReal() const +{ + bool r = this->GetNick().find_first_not_of("?*") != Anope::string::npos; + r = r || this->GetReal().find_first_not_of("?*") != Anope::string::npos; + return r; +} + +bool XLine::IsRegex() const +{ + return !this->mask.empty() && this->mask[0] == '/' && this->mask[this->mask.length() - 1] == '/'; +} + +Serialize::Data XLine::Serialize() const +{ + Serialize::Data data; + + data["mask"] << this->mask; + data["by"] << this->by; + data["created"] << this->created; + data["expires"] << this->expires; + data["reason"] << this->reason; + data["uid"] << this->id; + if (this->manager) + data["manager"] << this->manager->name; + + return data; +} + +Serializable* XLine::Unserialize(Serializable *obj, Serialize::Data &data) +{ + ServiceReference<XLineManager> xlm("XLineManager", data["manager"].astr()); + if (!xlm) + return NULL; + + XLine *xl; + if (obj) + { + xl = anope_dynamic_static_cast<XLine *>(obj); + data["mask"] >> xl->mask; + data["by"] >> xl->by; + data["reason"] >> xl->reason; + data["uid"] >> xl->id; + + if (xlm != xl->manager) + { + xl->manager->DelXLine(xl); + xlm->AddXLine(xl); + } + } + else + { + time_t expires; + data["expires"] >> expires; + xl = new XLine(data["mask"].astr(), data["by"].astr(), expires, data["reason"].astr(), data["uid"].astr()); + xlm->AddXLine(xl); + } + + data["created"] >> xl->created; + xl->manager = xlm; + + return xl; +} + +void XLineManager::RegisterXLineManager(XLineManager *xlm) +{ + XLineManagers.push_back(xlm); +} + +void XLineManager::UnregisterXLineManager(XLineManager *xlm) +{ + std::list<XLineManager *>::iterator it = std::find(XLineManagers.begin(), XLineManagers.end(), xlm); + + if (it != XLineManagers.end()) + XLineManagers.erase(it); +} + +void XLineManager::CheckAll(User *u) +{ + for (std::list<XLineManager *>::iterator it = XLineManagers.begin(), it_end = XLineManagers.end(); it != it_end; ++it) + { + XLineManager *xlm = *it; + + XLine *x = xlm->CheckAllXLines(u); + + if (x) + { + xlm->OnMatch(u, x); + break; + } + } +} + +Anope::string XLineManager::GenerateUID() +{ + Anope::string id; + int count = 0; + while (id.empty() || XLinesByUID->count(id) > 0) + { + if (++count > 10) + { + id.clear(); + Log(LOG_DEBUG) << "Unable to generate XLine UID"; + break; + } + + for (int i = 0; i < 10; ++i) + { + char c; + do + c = (rand() % 75) + 48; + while (!isupper(c) && !isdigit(c)); + id += c; + } + } + + return id; +} + +XLineManager::XLineManager(Module *creator, const Anope::string &xname, char t) : Service(creator, "XLineManager", xname), type(t), xlines("XLine") +{ +} + +XLineManager::~XLineManager() +{ + this->Clear(); +} + +const char &XLineManager::Type() +{ + return this->type; +} + +size_t XLineManager::GetCount() const +{ + return this->xlines->size(); +} + +const std::vector<XLine *> &XLineManager::GetList() const +{ + return this->xlines; +} + +void XLineManager::AddXLine(XLine *x) +{ + if (!x->id.empty()) + XLinesByUID->insert(std::make_pair(x->id, x)); + this->xlines->push_back(x); + x->manager = this; +} + +bool XLineManager::DelXLine(XLine *x) +{ + std::vector<XLine *>::iterator it = std::find(this->xlines->begin(), this->xlines->end(), x); + + if (!x->id.empty()) + { + std::multimap<Anope::string, XLine *, ci::less>::iterator it2 = XLinesByUID->find(x->id), it3 = XLinesByUID->upper_bound(x->id); + for (; it2 != XLinesByUID->end() && it2 != it3; ++it2) + if (it2->second == x) + { + XLinesByUID->erase(it2); + break; + } + } + + if (it != this->xlines->end()) + { + this->SendDel(x); + + x->Destroy(); + this->xlines->erase(it); + + return true; + } + + return false; +} + +XLine* XLineManager::GetEntry(unsigned index) +{ + if (index >= this->xlines->size()) + return NULL; + + XLine *x = this->xlines->at(index); + x->QueueUpdate(); + return x; +} + +void XLineManager::Clear() +{ + for (unsigned i = 0; i < this->xlines->size(); ++i) + { + XLine *x = this->xlines->at(i); + if (!x->id.empty()) + XLinesByUID->erase(x->id); + x->Destroy(); + } + this->xlines->clear(); +} + +bool XLineManager::CanAdd(CommandSource &source, const Anope::string &mask, time_t expires, const Anope::string &reason) +{ + for (unsigned i = this->GetCount(); i > 0; --i) + { + XLine *x = this->GetEntry(i - 1); + + if (x->mask.equals_ci(mask)) + { + if (!x->expires || x->expires >= expires) + { + if (x->reason != reason) + { + x->reason = reason; + source.Reply(_("Reason for %s updated."), x->mask.c_str()); + } + else + source.Reply(_("%s already exists."), mask.c_str()); + } + else + { + x->expires = expires; + if (x->reason != reason) + { + x->reason = reason; + source.Reply(_("Expiry and reason updated for %s."), x->mask.c_str()); + } + else + source.Reply(_("Expiry for %s updated."), x->mask.c_str()); + } + + return false; + } + else if (Anope::Match(mask, x->mask) && (!x->expires || x->expires >= expires)) + { + source.Reply(_("%s is already covered by %s."), mask.c_str(), x->mask.c_str()); + return false; + } + else if (Anope::Match(x->mask, mask) && (!expires || x->expires <= expires)) + { + source.Reply(_("Removing %s because %s covers it."), x->mask.c_str(), mask.c_str()); + this->DelXLine(x); + } + } + + return true; +} + +XLine* XLineManager::HasEntry(const Anope::string &mask) +{ + std::multimap<Anope::string, XLine *, ci::less>::iterator it = XLinesByUID->find(mask); + if (it != XLinesByUID->end()) + for (std::multimap<Anope::string, XLine *, ci::less>::iterator it2 = XLinesByUID->upper_bound(mask); it != it2; ++it) + if (it->second->manager == NULL || it->second->manager == this) + { + it->second->QueueUpdate(); + return it->second; + } + for (unsigned i = 0, end = this->xlines->size(); i < end; ++i) + { + XLine *x = this->xlines->at(i); + + if (x->mask.equals_ci(mask)) + { + x->QueueUpdate(); + return x; + } + } + + return NULL; +} + +XLine *XLineManager::CheckAllXLines(User *u) +{ + for (unsigned i = this->xlines->size(); i > 0; --i) + { + XLine *x = this->xlines->at(i - 1); + + if (x->expires && x->expires < Anope::CurTime) + { + this->OnExpire(x); + this->DelXLine(x); + continue; + } + + if (this->Check(u, x)) + { + this->OnMatch(u, x); + return x; + } + } + + return NULL; +} + +void XLineManager::OnExpire(const XLine *x) +{ +} + |