2014-07-21 05:22:06 +02:00
|
|
|
// OpenVPN -- An application to securely tunnel IP networks
|
|
|
|
// over a single port, with support for SSL/TLS-based
|
|
|
|
// session authentication and key exchange,
|
|
|
|
// packet encryption, packet authentication, and
|
|
|
|
// packet compression.
|
2012-08-24 23:13:42 +02:00
|
|
|
//
|
2015-01-06 20:56:21 +01:00
|
|
|
// Copyright (C) 2012-2015 OpenVPN Technologies, Inc.
|
2012-08-24 23:13:42 +02:00
|
|
|
//
|
2014-07-21 05:22:06 +02:00
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU Affero General Public License Version 3
|
|
|
|
// as published by the Free Software Foundation.
|
2012-08-24 23:13:42 +02:00
|
|
|
//
|
2014-07-21 05:22:06 +02:00
|
|
|
// 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 Affero General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
|
|
// along with this program in the COPYING file.
|
|
|
|
// If not, see <http://www.gnu.org/licenses/>.
|
2012-08-24 23:13:42 +02:00
|
|
|
|
2012-11-23 07:18:43 +01:00
|
|
|
// General purpose string-manipulation functions.
|
|
|
|
|
2011-11-21 23:39:33 +01:00
|
|
|
#ifndef OPENVPN_COMMON_STRING_H
|
|
|
|
#define OPENVPN_COMMON_STRING_H
|
|
|
|
|
2012-03-05 00:05:26 +01:00
|
|
|
#include <string>
|
2015-09-02 12:10:12 +02:00
|
|
|
#include <vector>
|
2011-11-21 23:39:33 +01:00
|
|
|
#include <cstring>
|
2015-06-05 03:22:59 +02:00
|
|
|
#include <cctype>
|
2011-11-21 23:39:33 +01:00
|
|
|
|
2015-06-05 03:22:59 +02:00
|
|
|
#include <openvpn/common/platform.hpp>
|
2015-05-17 21:27:34 +02:00
|
|
|
#include <openvpn/common/size.hpp>
|
2012-01-11 07:15:32 +01:00
|
|
|
|
2011-11-21 23:39:33 +01:00
|
|
|
namespace openvpn {
|
|
|
|
namespace string {
|
2012-11-23 07:18:43 +01:00
|
|
|
// case insensitive compare functions
|
|
|
|
|
2011-11-21 23:39:33 +01:00
|
|
|
inline int strcasecmp(const char *s1, const char *s2)
|
|
|
|
{
|
2012-04-21 06:47:30 +02:00
|
|
|
#ifdef OPENVPN_PLATFORM_WIN
|
|
|
|
return ::_stricmp(s1, s2);
|
|
|
|
#else
|
2011-11-21 23:39:33 +01:00
|
|
|
return ::strcasecmp(s1, s2);
|
2012-04-21 06:47:30 +02:00
|
|
|
#endif
|
2011-11-21 23:39:33 +01:00
|
|
|
}
|
2012-01-11 07:15:32 +01:00
|
|
|
|
2012-10-18 08:17:46 +02:00
|
|
|
inline int strcasecmp(const std::string& s1, const char *s2)
|
|
|
|
{
|
|
|
|
return strcasecmp(s1.c_str(), s2);
|
|
|
|
}
|
|
|
|
|
2012-10-24 08:38:20 +02:00
|
|
|
inline int strcasecmp(const char *s1, const std::string& s2)
|
|
|
|
{
|
|
|
|
return strcasecmp(s1, s2.c_str());
|
|
|
|
}
|
|
|
|
|
2012-10-18 08:17:46 +02:00
|
|
|
inline int strcasecmp(const std::string& s1, const std::string& s2)
|
|
|
|
{
|
|
|
|
return strcasecmp(s1.c_str(), s2.c_str());
|
|
|
|
}
|
|
|
|
|
2012-11-23 07:18:43 +01:00
|
|
|
// Like strncpy but makes sure dest is always null terminated
|
2012-01-11 07:15:32 +01:00
|
|
|
inline void strncpynt (char *dest, const char *src, size_t maxlen)
|
|
|
|
{
|
|
|
|
strncpy (dest, src, maxlen);
|
|
|
|
if (maxlen > 0)
|
|
|
|
dest[maxlen - 1] = 0;
|
|
|
|
}
|
2012-03-05 00:05:26 +01:00
|
|
|
|
|
|
|
inline bool is_true(const std::string& str)
|
|
|
|
{
|
|
|
|
return str == "1" || !strcasecmp(str.c_str(), "true");
|
|
|
|
}
|
2012-10-18 14:24:14 +02:00
|
|
|
|
|
|
|
// make sure that string ends with char c, if not append it
|
|
|
|
inline std::string add_trailing(const std::string& str, const char c)
|
|
|
|
{
|
|
|
|
const size_t len = str.length();
|
|
|
|
if (len > 0 && str[len-1] == c)
|
|
|
|
return str;
|
|
|
|
else
|
|
|
|
return str + c;
|
|
|
|
}
|
|
|
|
|
|
|
|
// make sure that string ends with char c, if not append it
|
|
|
|
inline void add_trailing_in_place(std::string& str, const char c)
|
|
|
|
{
|
|
|
|
const size_t len = str.length();
|
|
|
|
if (!(len > 0 && str[len-1] == c))
|
|
|
|
str += c;
|
|
|
|
}
|
|
|
|
|
|
|
|
// remove trailing \r or \n chars
|
|
|
|
inline void trim_crlf(std::string& str)
|
|
|
|
{
|
|
|
|
static const char crlf[] = "\r\n";
|
|
|
|
const size_t pos = str.find_last_not_of(crlf);
|
|
|
|
if (pos == std::string::npos)
|
|
|
|
str = "";
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const size_t p = pos + 1;
|
|
|
|
if (p < str.length())
|
|
|
|
str = str.substr(0, p);
|
|
|
|
}
|
|
|
|
}
|
2013-01-20 09:44:49 +01:00
|
|
|
|
2015-09-02 12:10:12 +02:00
|
|
|
// remove trailing \r or \n chars
|
|
|
|
inline std::string trim_crlf_copy(std::string str)
|
|
|
|
{
|
|
|
|
trim_crlf(str);
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
2013-01-20 09:44:49 +01:00
|
|
|
// return true if str of size len contains an embedded null
|
|
|
|
inline bool embedded_null(const char *str, size_t len)
|
|
|
|
{
|
|
|
|
while (len--)
|
|
|
|
if (!*str++)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2013-12-29 04:20:21 +01:00
|
|
|
|
2015-02-10 23:57:42 +01:00
|
|
|
// return the length of a string, omitting trailing nulls
|
|
|
|
inline size_t len_without_trailing_nulls(const char *str, size_t len)
|
|
|
|
{
|
|
|
|
while (len > 0 && str[len-1] == '\0')
|
|
|
|
--len;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2015-06-11 20:14:24 +02:00
|
|
|
// return true if string contains at least one newline
|
|
|
|
inline bool is_multiline(const std::string& str)
|
|
|
|
{
|
|
|
|
return str.find_first_of('\n') != std::string::npos;
|
|
|
|
}
|
|
|
|
|
2013-12-29 04:20:21 +01:00
|
|
|
// Define a common interpretation of what constitutes a space character.
|
|
|
|
// Return true if c is a space char.
|
2015-04-22 09:51:07 +02:00
|
|
|
inline bool is_space(const char c)
|
2013-12-29 04:20:21 +01:00
|
|
|
{
|
2015-06-05 03:22:59 +02:00
|
|
|
return std::isspace(static_cast<unsigned char>(c)) != 0;
|
2013-12-29 04:20:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// return true if str contains at least one space char
|
|
|
|
inline bool contains_space(const std::string& str)
|
|
|
|
{
|
|
|
|
for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
|
|
|
|
if (is_space(*i))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-04-09 23:22:38 +02:00
|
|
|
// replace all spaces in string with rep
|
|
|
|
inline std::string replace_spaces(const std::string& str, const char rep)
|
|
|
|
{
|
|
|
|
std::string ret;
|
|
|
|
for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
|
|
|
|
{
|
|
|
|
char c = *i;
|
|
|
|
if (is_space(c))
|
|
|
|
c = rep;
|
|
|
|
ret += c;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-04-22 09:51:57 +02:00
|
|
|
// convert \n to \r\n
|
|
|
|
inline std::string unix2dos(const std::string& str)
|
|
|
|
{
|
|
|
|
std::string ret;
|
|
|
|
bool last_char_was_cr = false;
|
|
|
|
|
|
|
|
ret.reserve(str.length() + str.length() / 8);
|
|
|
|
for (std::string::const_iterator i = str.begin(); i != str.end(); ++i)
|
|
|
|
{
|
|
|
|
const char c = *i;
|
|
|
|
if (c == '\n' && !last_char_was_cr)
|
|
|
|
ret += '\r';
|
|
|
|
ret += c;
|
|
|
|
last_char_was_cr = (c == '\r');
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-09-02 12:10:12 +02:00
|
|
|
// Split a string on sep delimiter. The size of the
|
|
|
|
// returned string list will be at most maxsplit + 1.
|
|
|
|
inline std::vector<std::string> split(const std::string& str,
|
|
|
|
const char sep,
|
|
|
|
const int maxsplit = -1)
|
|
|
|
{
|
|
|
|
std::vector<std::string> ret;
|
|
|
|
int nterms = 0;
|
|
|
|
std::string term;
|
|
|
|
|
|
|
|
for (auto &c : str)
|
|
|
|
{
|
|
|
|
if (c == sep && (maxsplit < 0 || nterms < maxsplit))
|
|
|
|
{
|
|
|
|
ret.push_back(std::move(term));
|
|
|
|
++nterms;
|
|
|
|
term = "";
|
|
|
|
}
|
|
|
|
else
|
|
|
|
term += c;
|
|
|
|
}
|
|
|
|
ret.push_back(std::move(term));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-06-05 03:22:59 +02:00
|
|
|
inline bool starts_with(const std::string& str, const std::string& prefix)
|
|
|
|
{
|
|
|
|
const size_t len = str.length();
|
|
|
|
const size_t plen = prefix.length();
|
|
|
|
if (plen <= len)
|
|
|
|
return std::memcmp(str.c_str(), prefix.c_str(), plen) == 0;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool starts_with(const std::string& str, const char *prefix)
|
|
|
|
{
|
|
|
|
const size_t len = str.length();
|
|
|
|
const size_t plen = std::strlen(prefix);
|
|
|
|
if (plen <= len)
|
|
|
|
return std::memcmp(str.c_str(), prefix, plen) == 0;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool ends_with(const std::string& str, const std::string& suffix)
|
|
|
|
{
|
|
|
|
const size_t len = str.length();
|
|
|
|
const size_t slen = suffix.length();
|
|
|
|
if (slen <= len)
|
|
|
|
return std::memcmp(str.c_str() + (len-slen), suffix.c_str(), slen) == 0;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
2012-10-26 14:36:40 +02:00
|
|
|
|
2015-06-05 03:22:59 +02:00
|
|
|
inline bool ends_with(const std::string& str, const char *suffix)
|
|
|
|
{
|
|
|
|
const size_t len = str.length();
|
|
|
|
const size_t slen = std::strlen(suffix);
|
|
|
|
if (slen <= len)
|
|
|
|
return std::memcmp(str.c_str() + (len-slen), suffix, slen) == 0;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline std::string trim_left_copy(const std::string& str)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < str.length(); ++i)
|
|
|
|
{
|
|
|
|
if (!is_space(str[i]))
|
|
|
|
return str.substr(i);
|
|
|
|
}
|
|
|
|
return std::string();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline std::string trim_copy(const std::string& str)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < str.length(); ++i)
|
|
|
|
{
|
|
|
|
if (!is_space(str[i]))
|
|
|
|
{
|
|
|
|
size_t last_nonspace = i;
|
|
|
|
for (size_t j = i + 1; j < str.length(); ++j)
|
|
|
|
{
|
|
|
|
if (!is_space(str[j]))
|
|
|
|
last_nonspace = j;
|
|
|
|
}
|
|
|
|
return str.substr(i, last_nonspace - i + 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return std::string();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline std::string to_upper_copy(const std::string& str)
|
|
|
|
{
|
|
|
|
std::string ret;
|
|
|
|
ret.reserve(str.length()+1);
|
|
|
|
for (const auto &c : str)
|
|
|
|
ret.push_back(std::toupper(static_cast<unsigned char>(c)));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline std::string to_lower_copy(const std::string& str)
|
|
|
|
{
|
|
|
|
std::string ret;
|
|
|
|
ret.reserve(str.length()+1);
|
|
|
|
for (const auto &c : str)
|
|
|
|
ret.push_back(std::tolower(static_cast<unsigned char>(c)));
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void trim(std::string& str)
|
|
|
|
{
|
|
|
|
str = trim_copy(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void trim_left(std::string& str)
|
|
|
|
{
|
|
|
|
str = trim_left_copy(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void to_lower(std::string& str)
|
|
|
|
{
|
|
|
|
str = to_lower_copy(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void to_upper(std::string& str)
|
|
|
|
{
|
|
|
|
str = to_upper_copy(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace string
|
2012-10-26 14:36:40 +02:00
|
|
|
|
2011-11-21 23:39:33 +01:00
|
|
|
} // namespace openvpn
|
|
|
|
|
|
|
|
#endif // OPENVPN_COMMON_STRING_H
|