Utility Class Reference
[Utilities]

Conversion utilities. More...

#include <Utility.h>

List of all members.

Static Public Member Functions
static std::string	base64 (const std::string &str_in)
static std::string	base64d (const std::string &str_in)
static std::string	l2string (long l)
static std::string	bigint2string (uint64_t l)
static uint64_t	atoi64 (const std::string &str)
static unsigned int	hex2unsigned (const std::string &str)
static std::string	rfc1738_encode (const std::string &src)
static std::string	rfc1738_decode (const std::string &src)
static bool	isipv4 (const std::string &)
	Checks whether a string is a valid ipv4/ipv6 ip number.
static bool	isipv6 (const std::string &)
	Checks whether a string is a valid ipv4/ipv6 ip number.
static bool	u2ip (const std::string &, ipaddr_t &)
	Hostname to ip resolution ipv4, not asynchronous.
static bool	u2ip (const std::string &, struct sockaddr_in &sa, int ai_flags=0)
static bool	reverse (struct sockaddr *sa, socklen_t sa_len, std::string &, int flags=0)
	Reverse lookup of address to hostname.
static bool	reverse (struct sockaddr *sa, socklen_t sa_len, std::string &hostname, std::string &service, int flags=0)
static bool	u2service (const std::string &name, int &service, int ai_flags=0)
static void	l2ip (const ipaddr_t, std::string &)
	Convert binary ip address to string: ipv4.
static void	l2ip (const in_addr &, std::string &)
static void	ResolveLocal ()
	ResolveLocal (hostname) - call once before calling any GetLocal method.
static const std::string &	GetLocalHostname ()
	Returns local hostname, ResolveLocal must be called once before using.
static ipaddr_t	GetLocalIP ()
	Returns local ip, ResolveLocal must be called once before using.
static const std::string &	GetLocalAddress ()
	Returns local ip number as string.
static void	SetEnv (const std::string &var, const std::string &value)
	Set environment variable.
static std::string	Sa2String (struct sockaddr *sa)
	Convert sockaddr struct to human readable string.
static void	GetTime (struct timeval *)
	Get current time in sec/microseconds.
static std::auto_ptr < SocketAddress >	CreateAddress (struct sockaddr *, socklen_t)
static unsigned long	ThreadID ()
static std::string	ToLower (const std::string &str)
static std::string	ToUpper (const std::string &str)
static std::string	ToString (double d)
static unsigned long	Rnd ()
	Returns a random 32-bit integer.
static const std::string	Stack ()
static const std::string	FromUtf8 (const std::string &)
	Utf8 decrypt.
Static Public Attributes
static const char *	Logo
Static Private Attributes
static std::string	m_host
	local hostname
static ipaddr_t	m_ip = 0
	local ip address
static std::string	m_addr
	local ip address in string format
static bool	m_local_resolved = false
	ResolveLocal has been called if true.
Classes
class	ncmap
class	ncmap_compare
class	Rng
	The Mersenne Twister http://www.math.keio.ac.jp/~matumoto/emt.html. More...
class	Uri

---

Detailed Description

Conversion utilities.

Definition at line 51 of file Utility.h.

---

Member Function Documentation

std::string Utility::base64

(

const std::string &

str_in

)

[static]

Definition at line 181 of file Utility.cpp.

{
        std::string str;
        Base64 m_b;
        m_b.encode(str_in, str, false); // , false == do not add cr/lf
        return str;
}

std::string Utility::base64d

(

const std::string &

str_in

)

[static]

Definition at line 190 of file Utility.cpp.

References Base64::decode().

{
        std::string str;
        Base64 m_b;
        m_b.decode(str_in, str);
        return str;
}

std::string Utility::l2string

(

long

l

)

[static]

Definition at line 199 of file Utility.cpp.

Referenced by UdpSocket::Bind(), SctpSocket::Bind(), ListenSocket< X >::Bind(), Ipv4Address::Convert(), HttpPostSocket::DoMultipartPost(), HttpClientSocket::HttpClientSocket(), HttpPostSocket::HttpPostSocket(), HttpPutSocket::OnConnect(), HttpPostSocket::OnConnect(), HttpGetSocket::OnConnect(), TcpSocket::Open(), StreamWriter::operator<<(), Debug::operator<<(), Ajp13Socket::ReceiveForwardRequest(), HttpdCookies::replacevalue(), HttpBaseSocket::Respond(), Sa2String(), HttpdSocket::Send64(), HttpRequest::SetAttribute(), and HttpTransaction::SetHeader().

{
        std::string str;
        char tmp[100];
        sprintf(tmp,"%ld",l);
        str = tmp;
        return str;
}

std::string Utility::bigint2string

(

uint64_t

l

)

[static]

Definition at line 209 of file Utility.cpp.

Referenced by StreamWriter::operator<<().

{
        std::string str;
        uint64_t tmp = l;
        while (tmp)
        {
                uint64_t a = tmp % 10;
                str = (char)(a + 48) + str;
                tmp /= 10;
        }
        if (!str.size())
        {
                str = "0";
        }
        return str;
}

uint64_t Utility::atoi64

(

const std::string &

str

)

[static]

Definition at line 227 of file Utility.cpp.

{
        uint64_t l = 0;
        for (size_t i = 0; i < str.size(); i++)
        {
                l = l * 10 + str[i] - 48;
        }
        return l;
}

unsigned int Utility::hex2unsigned

(

const std::string &

str

)

[static]

Definition at line 238 of file Utility.cpp.

Referenced by HTTPSocket::OnRawData().

{
        unsigned int r = 0;
        for (size_t i = 0; i < str.size(); i++)
        {
                r = r * 16 + str[i] - 48 - ((str[i] >= 'A') ? 7 : 0) - ((str[i] >= 'a') ? 32 : 0);
        }
        return r;
}

std::string Utility::rfc1738_encode

(

const std::string &

src

)

[static]

Definition at line 253 of file Utility.cpp.

Referenced by HttpPostSocket::OnConnect().

{
static  char hex[] = "0123456789ABCDEF";
        std::string dst;
        for (size_t i = 0; i < src.size(); i++)
        {
                if (isalnum(src[i]))
                {
                        dst += src[i];
                }
                else
                if (src[i] == ' ')
                {
                        dst += '+';
                }
                else
                {
                        unsigned char c = static_cast<unsigned char>(src[i]);
                        dst += '%';
                        dst += hex[c / 16];
                        dst += hex[c % 16];
                }
        }
        return dst;
} // rfc1738_encode

std::string Utility::rfc1738_decode

(

const std::string &

src

)

[static]

Definition at line 284 of file Utility.cpp.

Referenced by HttpRequest::SetUri().

{
        std::string dst;
        for (size_t i = 0; i < src.size(); i++)
        {
                if (src[i] == '%' && isxdigit(src[i + 1]) && isxdigit(src[i + 2]))
                {
                        char c1 = src[++i];
                        char c2 = src[++i];
                        c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
                        c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
                        dst += (char)(c1 * 16 + c2);
                }
                else
                if (src[i] == '+')
                {
                        dst += ' ';
                }
                else
                {
                        dst += src[i];
                }
        }
        return dst;
} // rfc1738_decode

bool Utility::isipv4

(

const std::string &

str

)

[static]

Checks whether a string is a valid ipv4/ipv6 ip number.

Definition at line 311 of file Utility.cpp.

Referenced by ResolvSocket::OnDetached(), TcpSocket::Open(), Ipv4Address::Resolve(), and u2ip().

{
        int dots = 0;
        // %! ignore :port?
        for (size_t i = 0; i < str.size(); i++)
        {
                if (str[i] == '.')
                        dots++;
                else
                if (!isdigit(str[i]))
                        return false;
        }
        if (dots != 3)
                return false;
        return true;
}

bool Utility::isipv6

(

const std::string &

str

)

[static]

Checks whether a string is a valid ipv4/ipv6 ip number.

Definition at line 329 of file Utility.cpp.

References Parse::getword().

Referenced by ResolvSocket::OnDetached(), and TcpSocket::Open().

{
        size_t qc = 0;
        size_t qd = 0;
        for (size_t i = 0; i < str.size(); i++)
        {
                qc += (str[i] == ':') ? 1 : 0;
                qd += (str[i] == '.') ? 1 : 0;
        }
        if (qc > 7)
        {
                return false;
        }
        if (qd && qd != 3)
        {
                return false;
        }
        Parse pa(str,":.");
        std::string tmp = pa.getword();
        while (tmp.size())
        {
                if (tmp.size() > 4)
                {
                        return false;
                }
                for (size_t i = 0; i < tmp.size(); i++)
                {
                        if (tmp[i] < '0' || (tmp[i] > '9' && tmp[i] < 'A') ||
                                (tmp[i] > 'F' && tmp[i] < 'a') || tmp[i] > 'f')
                        {
                                return false;
                        }
                }
                //
                tmp = pa.getword();
        }
        return true;
}

bool Utility::u2ip	(	const std::string &	str,
		ipaddr_t &	l
	)			[static]

Hostname to ip resolution ipv4, not asynchronous.

Definition at line 369 of file Utility.cpp.

Referenced by UdpSocket::AddMulticastMembership(), UdpSocket::DropMulticastMembership(), Ipv4Address::Ipv4Address(), ResolvSocket::OnDetached(), ResolvSocket::OnLine(), TcpSocket::Open(), SocketHandler::Resolve(), Ipv4Address::Resolve(), ResolveLocal(), SocketHandler::SetSocks4Host(), and Socket::SetSocks4Host().

{
        struct sockaddr_in sa;
        bool r = Utility::u2ip(str, sa);
        memcpy(&l, &sa.sin_addr, sizeof(l));
        return r;
}

bool Utility::u2ip	(	const std::string &	host,
		struct sockaddr_in &	sa,
		int	ai_flags = 0
	)			[static]

Definition at line 651 of file Utility.cpp.

References AI_NUMERICHOST, isipv4(), and Rnd().

{
        memset(&sa, 0, sizeof(sa));
        sa.sin_family = AF_INET;
#ifdef NO_GETADDRINFO
        if ((ai_flags & AI_NUMERICHOST) != 0 || isipv4(host))
        {
                Parse pa((char *)host.c_str(), ".");
                union {
                        struct {
                                unsigned char b1;
                                unsigned char b2;
                                unsigned char b3;
                                unsigned char b4;
                        } a;
                        ipaddr_t l;
                } u;
                u.a.b1 = static_cast<unsigned char>(pa.getvalue());
                u.a.b2 = static_cast<unsigned char>(pa.getvalue());
                u.a.b3 = static_cast<unsigned char>(pa.getvalue());
                u.a.b4 = static_cast<unsigned char>(pa.getvalue());
                memcpy(&sa.sin_addr, &u.l, sizeof(sa.sin_addr));
                return true;
        }
#ifndef LINUX
        struct hostent *he = gethostbyname( host.c_str() );
        if (!he)
        {
                return false;
        }
        memcpy(&sa.sin_addr, he -> h_addr, sizeof(sa.sin_addr));
#else
        struct hostent he;
        struct hostent *result = NULL;
        int myerrno = 0;
        char buf[2000];
        int n = gethostbyname_r(host.c_str(), &he, buf, sizeof(buf), &result, &myerrno);
        if (n || !result)
        {
                return false;
        }
        if (he.h_addr_list && he.h_addr_list[0])
                memcpy(&sa.sin_addr, he.h_addr, 4);
        else
                return false;
#endif
        return true;
#else
        struct addrinfo hints;
        memset(&hints, 0, sizeof(hints));
        // AI_NUMERICHOST
        // AI_CANONNAME
        // AI_PASSIVE - server
        // AI_ADDRCONFIG
        // AI_V4MAPPED
        // AI_ALL
        // AI_NUMERICSERV
        hints.ai_flags = ai_flags;
        hints.ai_family = AF_INET;
        hints.ai_socktype = 0;
        hints.ai_protocol = 0;
        struct addrinfo *res;
        if (Utility::isipv4(host))
                hints.ai_flags |= AI_NUMERICHOST;
        int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
        if (!n)
        {
                std::vector<struct addrinfo *> vec;
                struct addrinfo *ai = res;
                while (ai)
                {
                        if (ai -> ai_addrlen == sizeof(sa))
                                vec.push_back( ai );
                        ai = ai -> ai_next;
                }
                if (!vec.size())
                        return false;
                ai = vec[Utility::Rnd() % vec.size()];
                {
                        memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
                }
                freeaddrinfo(res);
                return true;
        }
        std::string error = "Error: ";
#ifndef __CYGWIN__
        error += gai_strerror(n);
#endif
        return false;
#endif // NO_GETADDRINFO
}

bool Utility::reverse	(	struct sockaddr *	sa,
		socklen_t	sa_len,
		std::string &	hostname,
		int	flags = 0
	)			[static]

Reverse lookup of address to hostname.

Definition at line 860 of file Utility.cpp.

Referenced by Ipv4Address::Convert(), l2ip(), ResolvSocket::OnDetached(), and Ipv4Address::Reverse().

{
        std::string service;
        return Utility::reverse(sa, sa_len, hostname, service, flags);
}

bool Utility::reverse	(	struct sockaddr *	sa,
		socklen_t	sa_len,
		std::string &	hostname,
		std::string &	service,
		int	flags = 0
	)			[static]

Definition at line 867 of file Utility.cpp.

References NI_NUMERICHOST.

{
        hostname = "";
        service = "";
#ifdef NO_GETADDRINFO
        switch (sa -> sa_family)
        {
        case AF_INET:
                if (flags & NI_NUMERICHOST)
                {
                        union {
                                struct {
                                        unsigned char b1;
                                        unsigned char b2;
                                        unsigned char b3;
                                        unsigned char b4;
                                } a;
                                ipaddr_t l;
                        } u;
                        struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
                        memcpy(&u.l, &sa_in -> sin_addr, sizeof(u.l));
                        char tmp[100];
                        sprintf(tmp, "%u.%u.%u.%u", u.a.b1, u.a.b2, u.a.b3, u.a.b4);
                        hostname = tmp;
                        return true;
                }
                else
                {
                        struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
                        struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin_addr, sizeof(sa_in -> sin_addr), AF_INET);
                        if (h)
                        {
                                hostname = h -> h_name;
                                return true;
                        }
                }
                break;
#ifdef ENABLE_IPV6
        case AF_INET6:
                if (flags & NI_NUMERICHOST)
                {
                        char slask[100]; // l2ip temporary
                        *slask = 0;
                        unsigned int prev = 0;
                        bool skipped = false;
                        bool ok_to_skip = true;
                        {
                                unsigned short addr16[8];
                                struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)sa;
                                memcpy(addr16, &sa_in6 -> sin6_addr, sizeof(addr16));
                                for (size_t i = 0; i < 8; i++)
                                {
                                        unsigned short x = ntohs(addr16[i]);
                                        if (*slask && (x || !ok_to_skip || prev))
                                                strcat(slask,":");
                                        if (x || !ok_to_skip)
                                        {
                                                sprintf(slask + strlen(slask),"%x", x);
                                                if (x && skipped)
                                                        ok_to_skip = false;
                                        }
                                        else
                                        {
                                                skipped = true;
                                        }
                                        prev = x;
                                }
                        }
                        if (!*slask)
                                strcpy(slask, "::");
                        hostname = slask;
                        return true;
                }
                else
                {
                        // %! TODO: ipv6 reverse lookup
                        struct sockaddr_in6 *sa_in = (struct sockaddr_in6 *)sa;
                        struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin6_addr, sizeof(sa_in -> sin6_addr), AF_INET6);
                        if (h)
                        {
                                hostname = h -> h_name;
                                return true;
                        }
                }
                break;
#endif
        }
        return false;
#else
        char host[NI_MAXHOST];
        char serv[NI_MAXSERV];
        // NI_NOFQDN
        // NI_NUMERICHOST
        // NI_NAMEREQD
        // NI_NUMERICSERV
        // NI_DGRAM
        int n = getnameinfo(sa, sa_len, host, sizeof(host), serv, sizeof(serv), flags);
        if (n)
        {
                // EAI_AGAIN
                // EAI_BADFLAGS
                // EAI_FAIL
                // EAI_FAMILY
                // EAI_MEMORY
                // EAI_NONAME
                // EAI_OVERFLOW
                // EAI_SYSTEM
                return false;
        }
        hostname = host;
        service = serv;
        return true;
#endif // NO_GETADDRINFO
}

bool Utility::u2service	(	const std::string &	name,
		int &	service,
		int	ai_flags = 0
	)			[static]

Definition at line 983 of file Utility.cpp.

{
#ifdef NO_GETADDRINFO
        // %!
        return false;
#else
        struct addrinfo hints;
        service = 0;
        memset(&hints, 0, sizeof(hints));
        // AI_NUMERICHOST
        // AI_CANONNAME
        // AI_PASSIVE - server
        // AI_ADDRCONFIG
        // AI_V4MAPPED
        // AI_ALL
        // AI_NUMERICSERV
        hints.ai_flags = ai_flags;
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = 0;
        hints.ai_protocol = 0;
        struct addrinfo *res;
        int n = getaddrinfo(NULL, name.c_str(), &hints, &res);
        if (!n)
        {
                service = res -> ai_protocol;
                freeaddrinfo(res);
                return true;
        }
        return false;
#endif // NO_GETADDRINFO
}

void Utility::l2ip	(	const	ipaddr_t,
		std::string &	str
	)			[static]

Convert binary ip address to string: ipv4.

Definition at line 391 of file Utility.cpp.

References NI_NUMERICHOST, and reverse().

Referenced by ResolvSocket::OnConnect(), ResolvSocket::OnDetached(), TcpSocket::Open(), ResolveLocal(), and Sa2String().

{
        struct sockaddr_in sa;
        memset(&sa, 0, sizeof(sa));
        sa.sin_family = AF_INET;
        memcpy(&sa.sin_addr, &ip, sizeof(sa.sin_addr));
        Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
}

void Utility::l2ip	(	const in_addr &	ip,
		std::string &	str
	)			[static]

Definition at line 401 of file Utility.cpp.

References NI_NUMERICHOST, and reverse().

{
        struct sockaddr_in sa;
        memset(&sa, 0, sizeof(sa));
        sa.sin_family = AF_INET;
        sa.sin_addr = ip;
        Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
}

void Utility::ResolveLocal

(

)

[static]

ResolveLocal (hostname) - call once before calling any GetLocal method.

Definition at line 475 of file Utility.cpp.

References l2ip(), m_addr, m_host, m_ip, m_local_resolved, and u2ip().

Referenced by GetLocalAddress(), GetLocalHostname(), and GetLocalIP().

{
        char h[256];

        // get local hostname and translate into ip-address
        *h = 0;
        gethostname(h,255);
        {
                if (Utility::u2ip(h, m_ip))
                {
                        Utility::l2ip(m_ip, m_addr);
                }
        }
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
        memset(&m_local_ip6, 0, sizeof(m_local_ip6));
        {
                if (Utility::u2ip(h, m_local_ip6))
                {
                        Utility::l2ip(m_local_ip6, m_local_addr6);
                }
        }
#endif
#endif
        m_host = h;
        m_local_resolved = true;
}

const std::string & Utility::GetLocalHostname

(

)

[static]

Returns local hostname, ResolveLocal must be called once before using.

See also:

ResolveLocal

Definition at line 504 of file Utility.cpp.

References m_host, m_local_resolved, and ResolveLocal().

{
        if (!m_local_resolved)
        {
                ResolveLocal();
        }
        return m_host;
}

ipaddr_t Utility::GetLocalIP

(

)

[static]

Returns local ip, ResolveLocal must be called once before using.

See also:

ResolveLocal

Definition at line 514 of file Utility.cpp.

References m_ip, m_local_resolved, and ResolveLocal().

{
        if (!m_local_resolved)
        {
                ResolveLocal();
        }
        return m_ip;
}

const std::string & Utility::GetLocalAddress

(

)

[static]

Returns local ip number as string.

See also:

ResolveLocal

Definition at line 524 of file Utility.cpp.

References m_addr, m_local_resolved, and ResolveLocal().

{
        if (!m_local_resolved)
        {
                ResolveLocal();
        }
        return m_addr;
}

void Utility::SetEnv	(	const std::string &	var,
		const std::string &	value
	)			[static]

Set environment variable.

Parameters:

	var	Name of variable to set
	value	Value

Definition at line 558 of file Utility.cpp.

Referenced by HttpdSocket::OnHeaderComplete(), and SSLInitializer::SSLInitializer().

{
#if (defined(SOLARIS8) || defined(SOLARIS))
        {
                static std::map<std::string, char *> vmap;
                if (vmap.find(var) != vmap.end())
                {
                        delete[] vmap[var];
                }
                vmap[var] = new char[var.size() + 1 + value.size() + 1];
                sprintf(vmap[var], "%s=%s", var.c_str(), value.c_str());
                putenv( vmap[var] );
        }
#elif defined _WIN32
        {
                std::string slask = var + "=" + value;
                _putenv( (char *)slask.c_str());
        }
#else
        setenv(var.c_str(), value.c_str(), 1);
#endif
}

std::string Utility::Sa2String

(

struct sockaddr *

sa

)

[static]

Convert sockaddr struct to human readable string.

Parameters:

sa

Ptr to sockaddr struct

Definition at line 582 of file Utility.cpp.

References l2ip(), and l2string().

Referenced by SctpSocket::getladdrs(), and SctpSocket::getpaddrs().

{
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
        if (sa -> sa_family == AF_INET6)
        {
                struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
                std::string tmp;
                Utility::l2ip(sa6 -> sin6_addr, tmp);
                return tmp + ":" + Utility::l2string(ntohs(sa6 -> sin6_port));
        }
#endif
#endif
        if (sa -> sa_family == AF_INET)
        {
                struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
                ipaddr_t a;
                memcpy(&a, &sa4 -> sin_addr, 4);
                std::string tmp;
                Utility::l2ip(a, tmp);
                return tmp + ":" + Utility::l2string(ntohs(sa4 -> sin_port));
        }
        return "";
}

void Utility::GetTime

(

struct timeval *

p

)

[static]

Get current time in sec/microseconds.

Definition at line 608 of file Utility.cpp.

Referenced by UdpSocket::OnRead().

{
#ifdef _WIN32
        FILETIME ft; // Contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
        GetSystemTimeAsFileTime(&ft);
        uint64_t tt;
        memcpy(&tt, &ft, sizeof(tt));
        tt /= 10; // make it usecs
        p->tv_sec = (long)tt / 1000000;
        p->tv_usec = (long)tt % 1000000;
#else
        gettimeofday(p, NULL);
#endif
}

std::auto_ptr< SocketAddress > Utility::CreateAddress	(	struct sockaddr *	sa,
		socklen_t	sa_len
	)			[static]

Definition at line 624 of file Utility.cpp.

{
        switch (sa -> sa_family)
        {
        case AF_INET:
                if (sa_len == sizeof(struct sockaddr_in))
                {
                        struct sockaddr_in *p = (struct sockaddr_in *)sa;
                        return std::auto_ptr<SocketAddress>(new Ipv4Address(*p));
                }
                break;
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
        case AF_INET6:
                if (sa_len == sizeof(struct sockaddr_in6))
                {
                        struct sockaddr_in6 *p = (struct sockaddr_in6 *)sa;
                        return std::auto_ptr<SocketAddress>(new Ipv6Address(*p));
                }
                break;
#endif
#endif
        }
        return std::auto_ptr<SocketAddress>(NULL);
}

unsigned long Utility::ThreadID

(

)

[static]

Definition at line 1016 of file Utility.cpp.

Referenced by Debug::Debug(), Debug::Print(), SSLInitializer::SSL_id_function(), and Debug::~Debug().

{
#ifdef _WIN32
        return GetCurrentThreadId();
#else
        return (unsigned long)pthread_self();
#endif
}

std::string Utility::ToLower

(

const std::string &

str

)

[static]

Definition at line 1026 of file Utility.cpp.

Referenced by HttpBaseSocket::OnFirst(), HttpBaseSocket::OnHeader(), SmtpdSocket::OnLine(), HTTPSocket::OnLine(), Ajp13Socket::ReceiveForwardRequest(), and Utility::Uri::Uri().

{
        std::string r;
        for (size_t i = 0; i < str.size(); i++)
        {
                if (str[i] >= 'A' && str[i] <= 'Z')
                        r += str[i] | 32;
                else
                        r += str[i];
        }
        return r;
}

std::string Utility::ToUpper

(

const std::string &

str

)

[static]

Definition at line 1040 of file Utility.cpp.

Referenced by SmtpdSocket::OnLine().

{
        std::string r;
        for (size_t i = 0; i < str.size(); i++)
        {
                if (str[i] >= 'a' && str[i] <= 'z')
                        r += (char)(str[i] - 32);
                else
                        r += str[i];
        }
        return r;
}

std::string Utility::ToString

(

double

d

)

[static]

Definition at line 1054 of file Utility.cpp.

Referenced by StreamWriter::operator<<().

{
        char tmp[100];
        sprintf(tmp, "%f", d);
        return tmp;
}

unsigned long Utility::Rnd

(

)

[static]

Returns a random 32-bit integer.

Definition at line 1062 of file Utility.cpp.

References Utility::Rng::Get().

Referenced by u2ip().

{
static  Utility::Rng generator( (unsigned long)time(NULL) );
        return generator.Get();
}

const std::string Utility::Stack

(

)

[static]

Definition at line 1143 of file Utility.cpp.

{
#if defined LINUX
#define BFSIZE 255
        void *buffer[BFSIZE];
        int n = backtrace(buffer, BFSIZE);
        char **res = backtrace_symbols(buffer, n);
        std::string tmp;
        for (int i = 0; i < n; i++)
        {
                std::string x = res[i];
                std::string plus;
                std::string addr;
                size_t pos = x.find("(");
                if (pos != std::string::npos)
                {
                        x = x.substr(pos + 1); // skip executable name

                        pos = x.find(")");
                        if (pos != std::string::npos)
                        {
                                addr = x.substr(pos + 1);
                                x = x.substr(0, pos);
                        }

                        pos = x.find("+");
                        if (pos != std::string::npos)
                        {
                                plus = x.substr(pos);
                                x = x.substr(0, pos);
                        }
                }
                char zz[1000];
                {
                        size_t sz = 1000;
                        int status = 0;
                        abi::__cxa_demangle( x.c_str(), zz, &sz, &status);

                        if (!status)
                        {
                                tmp += zz;
                                tmp += plus;
                                tmp += addr;
                        }
                        else
                        {
                                tmp += res[i];
                        }
                        tmp += "\n";
                }
                // dladdr() test
                if (0)
                {
                        Dl_info info;
                        int n = dladdr(buffer[i], &info);
                        if (!n)
                                printf("%d: dladdr() failed\n", i);
                        else
                        {
                                size_t sz = 1000;
                                int status = 0;
                                abi::__cxa_demangle( info.dli_sname, zz, &sz, &status);

                                printf("%d: %s: %s\n", i, info.dli_fname, info.dli_sname);
                                if (!status)
                                        printf("                %s\n", zz);
                        }
                } // end of dladdr() test
        } // for (i)
        free(res);
        return tmp;
#else
        return "Not available";
#endif
}

const std::string Utility::FromUtf8

(

const std::string &

str

)

[static]

Utf8 decrypt.

Definition at line 1220 of file Utility.cpp.

{
        if (!str.size())
                return "";
        std::string r;
        for (size_t i = 0; i < str.size(); i++)
        {
                if (i < str.size() - 1 && (str[i] & 0xe0) == 0xc0 && (str[i + 1] & 0xc0) == 0x80)
                {
                        int c1 = str[i] & 0x1f;
                        int c2 = str[++i] & 0x3f;
                        int c = (c1 << 6) + c2;
                        r += (char)c;
                }
                else
                {
                        r += str[i];
                }
        }
        return r;
}

---

Member Data Documentation

const char * Utility::Logo [static]

Definition at line 183 of file Utility.h.

Referenced by HttpdSocket::OnData(), and HttpdSocket::OnHeaderComplete().

std::string Utility::m_host [static, private]

local hostname

Definition at line 191 of file Utility.h.

Referenced by GetLocalHostname(), and ResolveLocal().

ipaddr_t Utility::m_ip = 0 [static, private]

local ip address

Definition at line 192 of file Utility.h.

Referenced by GetLocalIP(), and ResolveLocal().

std::string Utility::m_addr [static, private]

local ip address in string format

Definition at line 193 of file Utility.h.

Referenced by GetLocalAddress(), and ResolveLocal().

bool Utility::m_local_resolved = false [static, private]

ResolveLocal has been called if true.

Definition at line 200 of file Utility.h.