diff options
Diffstat (limited to 'src/inspstring.cpp')
| -rw-r--r-- | src/inspstring.cpp | 253 |
1 files changed, 126 insertions, 127 deletions
diff --git a/src/inspstring.cpp b/src/inspstring.cpp index 534b7ce00..faf34be91 100644 --- a/src/inspstring.cpp +++ b/src/inspstring.cpp @@ -21,140 +21,18 @@ #include "inspircd.h" -/* - * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com> - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL - * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef HAS_STRLCPY -CoreExport size_t strlcat(char *dst, const char *src, size_t siz) -{ - char *d = dst; - const char *s = src; - size_t n = siz, dlen; - - while (n-- != 0 && *d != '\0') - d++; - - dlen = d - dst; - n = siz - dlen; - - if (n == 0) - return(dlen + strlen(s)); - - while (*s != '\0') - { - if (n != 1) - { - *d++ = *s; - n--; - } - - s++; - } - - *d = '\0'; - return(dlen + (s - src)); /* count does not include NUL */ -} - -CoreExport size_t strlcpy(char *dst, const char *src, size_t siz) -{ - char *d = dst; - const char *s = src; - size_t n = siz; - - /* Copy as many bytes as will fit */ - if (n != 0 && --n != 0) - { - do - { - if ((*d++ = *s++) == 0) - break; - } while (--n != 0); - } - - /* Not enough room in dst, add NUL and traverse rest of src */ - if (n == 0) - { - if (siz != 0) - *d = '\0'; /* NUL-terminate dst */ - while (*s++); - } - - return(s - src - 1); /* count does not include NUL */ -} -#endif - -CoreExport int charlcat(char* x,char y,int z) -{ - char* x__n = x; - int v = 0; - - while(*x__n++) - v++; - - if (v < z - 1) - { - *--x__n = y; - *++x__n = 0; - } - - return v; -} - -CoreExport bool charremove(char* mp, char remove) -{ - char* mptr = mp; - bool shift_down = false; - - while (*mptr) - { - if (*mptr == remove) - shift_down = true; - - if (shift_down) - *mptr = *(mptr+1); - - mptr++; - } - - return shift_down; -} - static const char hextable[] = "0123456789abcdef"; -std::string BinToHex(const std::string& data) +std::string BinToHex(const void* raw, size_t l) { - int l = data.length(); + const char* data = static_cast<const char*>(raw); std::string rv; rv.reserve(l * 2); - for(int i=0; i < l; i++) + for (size_t i = 0; i < l; i++) { unsigned char c = data[i]; - rv.append(1, hextable[c >> 4]); - rv.append(1, hextable[c & 0xF]); + rv.push_back(hextable[c >> 4]); + rv.push_back(hextable[c & 0xF]); } return rv; } @@ -230,3 +108,124 @@ std::string Base64ToBin(const std::string& data_str, const char* table) } return rv; } + +bool InspIRCd::TimingSafeCompare(const std::string& one, const std::string& two) +{ + if (one.length() != two.length()) + return false; + + unsigned int diff = 0; + for (std::string::const_iterator i = one.begin(), j = two.begin(); i != one.end(); ++i, ++j) + { + unsigned char a = static_cast<unsigned char>(*i); + unsigned char b = static_cast<unsigned char>(*j); + diff |= a ^ b; + } + + return (diff == 0); +} + +void TokenList::AddList(const std::string& tokenlist) +{ + std::string token; + irc::spacesepstream tokenstream(tokenlist); + while (tokenstream.GetToken(token)) + { + if (token[0] == '-') + Remove(token.substr(1)); + else + Add(token); + } +} +void TokenList::Add(const std::string& token) +{ + // If the token is empty or contains just whitespace it is invalid. + if (token.empty() || token.find_first_not_of(" \t") == std::string::npos) + return; + + // If the token is a wildcard entry then permissive mode has been enabled. + if (token == "*") + { + permissive = true; + tokens.clear(); + return; + } + + // If we are in permissive mode then remove the token from the token list. + // Otherwise, add it to the token list. + if (permissive) + tokens.erase(token); + else + tokens.insert(token); +} + +void TokenList::Clear() +{ + permissive = false; + tokens.clear(); +} + +bool TokenList::Contains(const std::string& token) const +{ + // If we are in permissive mode and the token is in the list + // then we don't have it. + if (permissive && tokens.find(token) != tokens.end()) + return false; + + // If we are not in permissive mode and the token is not in + // the list then we don't have it. + if (!permissive && tokens.find(token) == tokens.end()) + return false; + + // We have the token! + return true; +} + +void TokenList::Remove(const std::string& token) +{ + // If the token is empty or contains just whitespace it is invalid. + if (token.empty() || token.find_first_not_of(" \t") == std::string::npos) + return; + + // If the token is a wildcard entry then permissive mode has been disabled. + if (token == "*") + { + permissive = false; + tokens.clear(); + return; + } + + // If we are in permissive mode then add the token to the token list. + // Otherwise, remove it from the token list. + if (permissive) + tokens.insert(token); + else + tokens.erase(token); +} + +std::string TokenList::ToString() const +{ + std::string buffer(permissive ? "* " : "-* "); + buffer.append(stdalgo::string::join(tokens)); + return buffer; +} + +bool TokenList::operator==(const TokenList& other) const +{ + // Both sets must be in the same mode to be equal. + if (permissive != other.permissive) + return false; + + // Both sets must be the same size to be equal. + if (tokens.size() != other.tokens.size()) + return false; + + for (insp::flat_set<std::string>::const_iterator iter = tokens.begin(); iter != tokens.end(); ++iter) + { + // Both sets must contain the same tokens to be equal. + if (other.tokens.find(*iter) == other.tokens.end()) + return false; + } + + return true; +} |