diff options
| -rw-r--r-- | include/ctables.h | 10 | ||||
| -rw-r--r-- | include/dns.h | 42 | ||||
| -rw-r--r-- | include/dynamic.h | 4 | ||||
| -rw-r--r-- | include/filelogger.h | 3 | ||||
| -rw-r--r-- | include/hash_map.h | 4 | ||||
| -rw-r--r-- | include/hashcomp.h | 177 | ||||
| -rw-r--r-- | src/hashcomp.cpp | 126 |
7 files changed, 88 insertions, 278 deletions
diff --git a/include/ctables.h b/include/ctables.h index 2a0ce834b..37ed92ce0 100644 --- a/include/ctables.h +++ b/include/ctables.h @@ -23,6 +23,11 @@ enum CmdResult CMD_INVALID = 2 /* Command doesnt exist at all! */ }; +/** Translation types for translation of parameters to UIDs. + * This allows the core commands to not have to be aware of how UIDs + * work (making it still possible to write other linking modules which + * do not use UID (but why would you want to?) + */ enum TranslateType { TR_END, /* End of known parameters, everything after this is TR_TEXT */ @@ -81,6 +86,9 @@ class CoreExport Command : public Extensible */ std::string syntax; + /** Translation type list for possible parameters, used to tokenize + * parameters into UIDs and SIDs etc. + */ std::vector<TranslateType> translation; /** How many seconds worth of penalty does this command have? @@ -195,6 +203,8 @@ class CoreExport Command : public Extensible */ typedef nspace::hash_map<std::string,Command*> Commandtable; +/** Shortcut macros for defining translation lists + */ #define TRANSLATE1(x1) translation.push_back(x1); #define TRANSLATE2(x1,x2) translation.push_back(x1);translation.push_back(x2); #define TRANSLATE3(x1,x2,x3) translation.push_back(x1);translation.push_back(x2);translation.push_back(x3); diff --git a/include/dns.h b/include/dns.h index d4005dea8..e93672f67 100644 --- a/include/dns.h +++ b/include/dns.h @@ -143,14 +143,21 @@ struct ResourceRecord; */ enum QueryType { - DNS_QUERY_NONE = 0, /* Uninitialized Query */ - DNS_QUERY_A = 1, /* 'A' record: an ipv4 address */ - DNS_QUERY_CNAME = 5, /* 'CNAME' record: An alias */ - DNS_QUERY_PTR = 12, /* 'PTR' record: a hostname */ - DNS_QUERY_AAAA = 28, /* 'AAAA' record: an ipv6 address */ - - DNS_QUERY_PTR4 = 0xFFFD, /* Force 'PTR' to use IPV4 scemantics */ - DNS_QUERY_PTR6 = 0xFFFE /* Force 'PTR' to use IPV6 scemantics */ + /** Uninitialized Query */ + DNS_QUERY_NONE = 0, + /** 'A' record: an ipv4 address */ + DNS_QUERY_A = 1, + /** 'CNAME' record: An alias */ + DNS_QUERY_CNAME = 5, + /** 'PTR' record: a hostname */ + DNS_QUERY_PTR = 12, + /** 'AAAA' record: an ipv6 address */ + DNS_QUERY_AAAA = 28, + + /** Force 'PTR' to use IPV4 scemantics */ + DNS_QUERY_PTR4 = 0xFFFD, + /** Force 'PTR' to use IPV6 scemantics */ + DNS_QUERY_PTR6 = 0xFFFE }; #ifdef IPV6 @@ -165,8 +172,10 @@ const QueryType DNS_QUERY_REVERSE = DNS_QUERY_PTR; */ enum ForceProtocol { - PROTOCOL_IPV4 = 0, /* Forced to use ipv4 */ - PROTOCOL_IPV6 = 1 /* Forced to use ipv6 */ + /** Forced to use ipv4 */ + PROTOCOL_IPV4 = 0, + /** Forced to use ipv6 */ + PROTOCOL_IPV6 = 1 }; /** @@ -219,6 +228,7 @@ class CoreExport Resolver : public Extensible * Time left before cache expiry */ int time_left; + public: /** * Initiate DNS lookup. Your class should not attempt to delete or free these @@ -267,6 +277,7 @@ class CoreExport Resolver : public Extensible * The default destructor does nothing. */ virtual ~Resolver(); + /** * When your lookup completes, this method will be called. * @param result The resulting DNS lookup, either an IP address or a hostname. @@ -278,6 +289,7 @@ class CoreExport Resolver : public Extensible * Normally, you will only want to act on this when the result is 0. */ virtual void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum = 0) = 0; + /** * If an error occurs (such as NXDOMAIN, no domain name found) then this method * will be called. @@ -285,6 +297,7 @@ class CoreExport Resolver : public Extensible * @param errormessage The error text of the error that occured. */ virtual void OnError(ResolverError e, const std::string &errormessage); + /** * Returns the id value of this class. This is primarily used by the core * to determine where in various tables to place a pointer to your class, but it @@ -294,10 +307,12 @@ class CoreExport Resolver : public Extensible * this method will return -1. */ int GetId(); + /** * Returns the creator module, or NULL */ Module* GetCreator(); + /** * If the result is a cached result, this triggers the objects * OnLookupComplete. This is done because it is not safe to call @@ -360,9 +375,16 @@ class CoreExport DNS : public EventHandler * Server address being used currently */ int socketfamily; + #ifdef IPV6 + /** + * IPV6 server address + */ in6_addr myserver6; #endif + /** + * IPV4 server address + */ in_addr myserver4; /** diff --git a/include/dynamic.h b/include/dynamic.h index 727ed11e1..51aaaa3cd 100644 --- a/include/dynamic.h +++ b/include/dynamic.h @@ -137,6 +137,9 @@ template <typename ReturnType> class CoreExport DLLFactory : public DLLManager } } + /** Calls the 'init_module' C exported function within a module, which + * returns a pointer to a Module derived object. + */ ReturnType* CallInit() { if(init_func) @@ -157,3 +160,4 @@ template <typename ReturnType> class CoreExport DLLFactory : public DLLManager }; #endif + diff --git a/include/filelogger.h b/include/filelogger.h index 3100761d9..888975d66 100644 --- a/include/filelogger.h +++ b/include/filelogger.h @@ -31,6 +31,8 @@ enum DebugLevel /* Forward declaration -- required */ class InspIRCd; +/** A logging class which logs to a streamed file. + */ class CoreExport FileLogStream : public LogStream { private: @@ -44,3 +46,4 @@ class CoreExport FileLogStream : public LogStream }; #endif + diff --git a/include/hash_map.h b/include/hash_map.h index 3665d9b1a..dfce5d94a 100644 --- a/include/hash_map.h +++ b/include/hash_map.h @@ -15,7 +15,7 @@ #define INSPIRCD_HASHMAP_H /** Where hash_map is varies from compiler to compiler - * as it is not standard. + * as it is not standard unless we have tr1. */ #ifndef WIN32 #ifndef HASHMAP_DEPRECATED @@ -25,7 +25,9 @@ #define BEGIN_HASHMAP_NAMESPACE namespace nspace { #define END_HASHMAP_NAMESPACE } #else + /** Yay, we have tr1! */ #include <tr1/unordered_map> + /** Not so oddball linux namespace for hash_map with gcc 4.0 and above */ #define hash_map unordered_map #define nspace std::tr1 #define BEGIN_HASHMAP_NAMESPACE namespace std { namespace tr1 { diff --git a/include/hashcomp.h b/include/hashcomp.h index cc540a3af..7093fa986 100644 --- a/include/hashcomp.h +++ b/include/hashcomp.h @@ -15,8 +15,6 @@ #define _HASHCOMP_H_ #include <cstring> -//#include "inspircd_config.h" -//#include "socket.h" #include "hash_map.h" /******************************************************* @@ -56,8 +54,8 @@ unsigned const char rfc_case_insensitive_map[256] = { 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 /* 240-255 */ }; -/* - * case sensitive map. +/** + * Case sensitive map. As per rfc_case_insensitive_map, but case sensitive. duh. */ unsigned const char case_sensitive_map[256] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, @@ -158,10 +156,13 @@ namespace irc class CoreExport stringjoiner : public classbase { private: + /** Output string */ std::string joined; + public: + /** Join elements of a vector, between (and including) begin and end * @param seperator The string to seperate values with * @param sequence One or more items to seperate @@ -169,6 +170,7 @@ namespace irc * @param end The ending element in the sequence to be joined */ stringjoiner(const std::string &seperator, const std::vector<std::string> &sequence, int begin, int end); + /** Join elements of a deque, between (and including) begin and end * @param seperator The string to seperate values with * @param sequence One or more items to seperate @@ -176,6 +178,7 @@ namespace irc * @param end The ending element in the sequence to be joined */ stringjoiner(const std::string &seperator, const std::deque<std::string> &sequence, int begin, int end); + /** Join elements of an array of char arrays, between (and including) begin and end * @param seperator The string to seperate values with * @param sequence One or more items to seperate @@ -198,20 +201,24 @@ namespace irc { private: InspIRCd* ServerInstance; + /** The mode sequence and its parameters */ std::deque<std::string> sequence; + /** True if the mode sequence is initially adding * characters, false if it is initially removing * them */ bool adding; public: + /** Construct a new modestacker. * @param add True if the stack is adding modes, * false if it is removing them */ modestacker(InspIRCd* Instance, bool add); + /** Push a modeletter and its parameter onto the stack. * No checking is performed as to if this mode actually * requires a parameter. If you stack invalid mode @@ -221,6 +228,7 @@ namespace irc * @param parameter The parameter for the mode */ void Push(char modeletter, const std::string ¶meter); + /** Push a modeletter without parameter onto the stack. * No checking is performed as to if this mode actually * requires a parameter. If you stack invalid mode @@ -229,12 +237,15 @@ namespace irc * @param modeletter The mode letter to insert */ void Push(char modeletter); + /** Push a '+' symbol onto the stack. */ void PushPlus(); + /** Push a '-' symbol onto the stack. */ void PushMinus(); + /** Return zero or more elements which form the * mode line. This will be clamped to a max of * MAXMODES items (MAXMODES-1 mode parameters and @@ -269,22 +280,30 @@ namespace irc class CoreExport tokenstream : public classbase { private: + /** Original string */ std::string tokens; + /** Last position of a seperator token */ std::string::iterator last_starting_position; + /** Current string position */ std::string::iterator n; + /** True if the last value was an ending value */ bool last_pushed; public: + /** Create a tokenstream and fill it with the provided data */ tokenstream(const std::string &source); + + /** Destructor + */ ~tokenstream(); /** Fetch the next token from the stream as a std::string @@ -336,6 +355,9 @@ namespace irc /** Create a sepstream and fill it with the provided data */ sepstream(const std::string &source, char seperator); + + /** Destructor + */ virtual ~sepstream(); /** Fetch the next token from the stream @@ -390,180 +412,53 @@ namespace irc class CoreExport portparser : public classbase { private: + /** Used to split on commas */ commasepstream* sep; + /** Current position in a range of ports */ long in_range; + /** Starting port in a range of ports */ long range_begin; + /** Ending port in a range of ports */ long range_end; + /** Allow overlapped port ranges */ bool overlapped; + /** Used to determine overlapping of ports * without O(n) algorithm being used */ std::map<long, bool> overlap_set; + /** Returns true if val overlaps an existing range */ bool Overlaps(long val); public: + /** Create a portparser and fill it with the provided data * @param source The source text to parse from * @param allow_overlapped Allow overlapped ranges */ portparser(const std::string &source, bool allow_overlapped = true); + /** Frees the internal commasepstream object */ ~portparser(); + /** Fetch the next token from the stream * @return The next port number is returned, or 0 if none remain */ long GetToken(); }; - /** Used to hold a bitfield definition in dynamicbitmask. - * You must be allocated one of these by dynamicbitmask::Allocate(), - * you should not fill the values yourself! - */ - typedef std::pair<size_t, unsigned char> bitfield; - - /** The irc::dynamicbitmask class is used to maintain a bitmap of - * boolean values, which can grow to any reasonable size no matter - * how many bitfields are in it. - * - * It starts off at 32 bits in size, large enough to hold 32 boolean - * values, with a memory allocation of 8 bytes. If you allocate more - * than 32 bits, the class will grow the bitmap by 8 bytes at a time - * for each set of 8 bitfields you allocate with the Allocate() - * method. - * - * This method is designed so that multiple modules can be allocated - * bit values in a bitmap dynamically, rather than having to define - * costs in a fixed size unsigned integer and having the possibility - * of collisions of values in different third party modules. - * - * IMPORTANT NOTE: - * - * To use this class, you must derive from it. - * This is because each derived instance has its own freebits array - * which can determine what bitfields are allocated on a TYPE BY TYPE - * basis, e.g. an irc::dynamicbitmask type for Users, and one for - * Channels, etc. You should inheret it in a very simple way as follows. - * The base class will resize and maintain freebits as required, you are - * just required to make the pointer static and specific to this class - * type. - * - * \code - * class mydbitmask : public irc::dynamicbitmask - * { - * private: - * - * static unsigned char* freebits; - * - * public: - * - * mydbitmask() : irc::dynamicbitmask() - * { - * freebits = new unsigned char[this->bits_size]; - * memset(freebits, 0, this->bits_size); - * } - * - * ~mydbitmask() - * { - * delete[] freebits; - * } - * - * unsigned char* GetFreeBits() - * { - * return freebits; - * } - * - * void SetFreeBits(unsigned char* freebt) - * { - * freebits = freebt; - * } - * }; - * \endcode - */ - class CoreExport dynamicbitmask : public classbase - { - private: - /** Data bits. We start with four of these, - * and we grow the bitfield as we allocate - * more than 32 entries with Allocate(). - */ - unsigned char* bits; - protected: - /** Current set size (size of freebits and bits). - * Both freebits and bits will ALWAYS be the - * same length. - */ - unsigned char bits_size; - public: - /** Allocate the initial memory for bits and - * freebits and zero the memory. - */ - dynamicbitmask(); - - /** Free the memory used by bits and freebits - */ - virtual ~dynamicbitmask(); - - /** Allocate an irc::bitfield. - * @return An irc::bitfield which can be used - * with Get, Deallocate and Toggle methods. - * @throw Can throw std::bad_alloc if there is - * no ram left to grow the bitmask. - */ - bitfield Allocate(); - - /** Deallocate an irc::bitfield. - * @param An irc::bitfield to deallocate. - * @return True if the bitfield could be - * deallocated, false if it could not. - */ - bool Deallocate(bitfield &pos); - - /** Toggle the value of a bitfield. - * @param pos A bitfield to allocate, previously - * allocated by dyamicbitmask::Allocate(). - * @param state The state to set the field to. - */ - void Toggle(bitfield &pos, bool state); - - /** Get the value of a bitfield. - * @param pos A bitfield to retrieve, previously - * allocated by dyamicbitmask::Allocate(). - * @return The value of the bitfield. - * @throw Will throw ModuleException if the bitfield - * you provide is outside of the range - * 0 >= bitfield.first < size_bits. - */ - bool Get(bitfield &pos); - - /** Return the size in bytes allocated to the bits - * array. - * Note that the actual allocation is twice this, - * as there are an equal number of bytes allocated - * for the freebits array. - */ - unsigned char GetSize(); - - /** Get free bits mask - */ - virtual unsigned char* GetFreeBits() { return NULL; } - - /** Set free bits mask - */ - virtual void SetFreeBits(unsigned char* freebits) { freebits = freebits; } - }; - /** Turn _ characters in a string into spaces * @param n String to translate * @return The new value with _ translated to space. diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp index a9a3441b9..ed68cd941 100644 --- a/src/hashcomp.cpp +++ b/src/hashcomp.cpp @@ -501,129 +501,3 @@ long irc::portparser::GetToken() } } -irc::dynamicbitmask::dynamicbitmask() : bits_size(4) -{ - /* We start with 4 bytes allocated which is room - * for 4 items. Something makes me doubt its worth - * allocating less than 4 bytes. - */ - bits = new unsigned char[bits_size]; - memset(bits, 0, bits_size); -} - -irc::dynamicbitmask::~dynamicbitmask() -{ - /* Tidy up the entire used memory on delete */ - delete[] bits; -} - -irc::bitfield irc::dynamicbitmask::Allocate() -{ - /* Yeah, this isnt too efficient, however a module or the core - * should only be allocating bitfields on load, the Toggle and - * Get methods are O(1) as these are called much more often. - */ - unsigned char* freebits = this->GetFreeBits(); - for (unsigned char i = 0; i < bits_size; i++) - { - /* Yes, this is right. You'll notice we terminate the loop when !current_pos, - * this is because we logic shift our bit off the end of unsigned char, and its - * lost, making the loop counter 0 when we're done. - */ - for (unsigned char current_pos = 1; current_pos; current_pos = current_pos << 1) - { - if (!(freebits[i] & current_pos)) - { - freebits[i] |= current_pos; - return std::make_pair(i, current_pos); - } - } - } - /* We dont have any free space left, increase by one */ - - if (bits_size == 255) - /* Oh dear, cant grow it any further */ - throw std::bad_alloc(); - - unsigned char old_bits_size = bits_size; - bits_size++; - /* Allocate new bitfield space */ - unsigned char* temp_bits = new unsigned char[bits_size]; - unsigned char* temp_freebits = new unsigned char[bits_size]; - /* Copy the old data in */ - memcpy(temp_bits, bits, old_bits_size); - memcpy(temp_freebits, freebits, old_bits_size); - /* Delete the old data pointers */ - delete[] bits; - delete[] freebits; - /* Swap the pointers over so now the new - * pointers point to our member values - */ - bits = temp_bits; - freebits = temp_freebits; - this->SetFreeBits(freebits); - /* Initialize the new byte on the end of - * the bitfields, pre-allocate the one bit - * for this allocation - */ - bits[old_bits_size] = 0; - freebits[old_bits_size] = 1; - /* We already know where we just allocated - * the bitfield, so no loop needed - */ - return std::make_pair(old_bits_size, 1); -} - -bool irc::dynamicbitmask::Deallocate(irc::bitfield &pos) -{ - /* We dont bother to shrink the bitfield - * on deallocation, the most we could do - * is save one byte (!) and this would cost - * us a loop (ugly O(n) stuff) so we just - * clear the bit and leave the memory - * claimed -- nobody will care about one - * byte. - */ - if (pos.first < bits_size) - { - this->GetFreeBits()[pos.first] &= ~pos.second; - return true; - } - /* They gave a bitfield outside of the - * length of our array. BAD programmer. - */ - return false; -} - -void irc::dynamicbitmask::Toggle(irc::bitfield &pos, bool state) -{ - /* Range check the value */ - if (pos.first < bits_size) - { - if (state) - /* Set state, OR the state in */ - bits[pos.first] |= pos.second; - else - /* Clear state, AND the !state out */ - bits[pos.first] &= ~pos.second; - } -} - -bool irc::dynamicbitmask::Get(irc::bitfield &pos) -{ - /* Range check the value */ - if (pos.first < bits_size) - return (bits[pos.first] & pos.second); - else - /* We can't return false, otherwise we can't - * distinguish between failure and a cleared bit! - * Our only sensible choice is to throw (ew). - */ - throw ModuleException("irc::dynamicbitmask::Get(): Invalid bitfield, out of range"); -} - -unsigned char irc::dynamicbitmask::GetSize() -{ - return bits_size; -} - |