src/Sockets/Utility.cpp

   1 /** \file Utility.cpp
   2  **     \date  2004-02-13
   3  **     \author grymse@alhem.net
   4 **/
   5 /*
   6 Copyright (C) 2004-2007  Anders Hedstrom
   7
   8 This library is made available under the terms of the GNU GPL.
   9
  10 If you would like to use this library in a closed-source application,
  11 a separate license agreement is available. For information about
  12 the closed-source license agreement for the C++ sockets library,
  13 please visit http://www.alhem.net/Sockets/license.html and/or
  14 email license@alhem.net.
  15
  16 This program is free software; you can redistribute it and/or
  17 modify it under the terms of the GNU General Public License
  18 as published by the Free Software Foundation; either version 2
  19 of the License, or (at your option) any later version.
  20
  21 This program is distributed in the hope that it will be useful,
  22 but WITHOUT ANY WARRANTY; without even the implied warranty of
  23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24 GNU General Public License for more details.
  25
  26 You should have received a copy of the GNU General Public License
  27 along with this program; if not, write to the Free Software
  28 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  29 */
  30 #include "Utility.h"
  31 #include "Parse.h"
  32 #include "Ipv4Address.h"
  33 #include "Ipv6Address.h"
  34 #include "RandomNumber.h"
  35 #include "Base64.h"
  36 #include <vector>
  37 #ifdef _WIN32
  38 #include <time.h>
  39 #else
  40 #include <netdb.h>
  41 #include <pthread.h>
  42 #endif
  43 #include <map>
  44
  45 #ifdef SOCKETS_NAMESPACE
  46 namespace SOCKETS_NAMESPACE {
  47 #endif
  48
  49
  50 // statics
  51 std::string Utility::m_host;
  52 bool Utility::m_local_resolved = false;
  53 ipaddr_t Utility::m_ip = 0;
  54 std::string Utility::m_addr;
  55 #ifdef ENABLE_IPV6
  56 #ifdef IPPROTO_IPV6
  57 struct in6_addr Utility::m_local_ip6;
  58 std::string Utility::m_local_addr6;
  59 #endif
  60 #endif
  61
  62
  63 std::string Utility::base64(const std::string& str_in)
  64 {
  65         std::string str;
  66         Base64 m_b;
  67         m_b.encode(str_in, str, false); // , false == do not add cr/lf
  68         return str;
  69 }
  70
  71
  72 std::string Utility::base64d(const std::string& str_in)
  73 {
  74         std::string str;
  75         Base64 m_b;
  76         m_b.decode(str_in, str);
  77         return str;
  78 }
  79
  80
  81 std::string Utility::l2string(long l)
  82 {
  83         std::string str;
  84         char tmp[100];
  85         sprintf(tmp,"%ld",l);
  86         str = tmp;
  87         return str;
  88 }
  89
  90
  91 std::string Utility::bigint2string(uint64_t l)
  92 {
  93         std::string str;
  94         uint64_t tmp = l;
  95         while (tmp)
  96         {
  97                 uint64_t a = tmp % 10;
  98                 str = (char)(a + 48) + str;
  99                 tmp /= 10;
 100         }
 101         if (!str.size())
 102         {
 103                 str = "0";
 104         }
 105         return str;
 106 }
 107
 108
 109 uint64_t Utility::atoi64(const std::string& str)
 110 {
 111         uint64_t l = 0;
 112         for (size_t i = 0; i < str.size(); i++)
 113         {
 114                 l = l * 10 + str[i] - 48;
 115         }
 116         return l;
 117 }
 118
 119
 120 unsigned int Utility::hex2unsigned(const std::string& str)
 121 {
 122         unsigned int r = 0;
 123         for (size_t i = 0; i < str.size(); i++)
 124         {
 125                 r = r * 16 + str[i] - 48 - ((str[i] >= 'A') ? 7 : 0) - ((str[i] >= 'a') ? 32 : 0);
 126         }
 127         return r;
 128 }
 129
 130
 131 /*
 132 * Encode string per RFC1738 URL encoding rules
 133 * tnx rstaveley
 134 */
 135 std::string Utility::rfc1738_encode(const std::string& src)
 136 {
 137 static  char hex[] = "0123456789ABCDEF";
 138         std::string dst;
 139         for (size_t i = 0; i < src.size(); i++)
 140         {
 141                 if (isalnum(src[i]))
 142                 {
 143                         dst += src[i];
 144                 }
 145                 else
 146                 if (src[i] == ' ')
 147                 {
 148                         dst += '+';
 149                 }
 150                 else
 151                 {
 152                         unsigned char c = static_cast<unsigned char>(src[i]);
 153                         dst += '%';
 154                         dst += hex[c / 16];
 155                         dst += hex[c % 16];
 156                 }
 157         }
 158         return dst;
 159 } // rfc1738_encode
 160
 161
 162 /*
 163 * Decode string per RFC1738 URL encoding rules
 164 * tnx rstaveley
 165 */
 166 std::string Utility::rfc1738_decode(const std::string& src)
 167 {
 168         std::string dst;
 169         for (size_t i = 0; i < src.size(); i++)
 170         {
 171                 if (src[i] == '%' && isxdigit(src[i + 1]) && isxdigit(src[i + 2]))
 172                 {
 173                         char c1 = src[++i];
 174                         char c2 = src[++i];
 175                         c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
 176                         c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
 177                         dst += (char)(c1 * 16 + c2);
 178                 }
 179                 else
 180                 if (src[i] == '+')
 181                 {
 182                         dst += ' ';
 183                 }
 184                 else
 185                 {
 186                         dst += src[i];
 187                 }
 188         }
 189         return dst;
 190 } // rfc1738_decode
 191
 192
 193 bool Utility::isipv4(const std::string& str)
 194 {
 195         int dots = 0;
 196         // %! ignore :port?
 197         for (size_t i = 0; i < str.size(); i++)
 198         {
 199                 if (str[i] == '.')
 200                         dots++;
 201                 else
 202                 if (!isdigit(str[i]))
 203                         return false;
 204         }
 205         if (dots != 3)
 206                 return false;
 207         return true;
 208 }
 209
 210
 211 bool Utility::isipv6(const std::string& str)
 212 {
 213         size_t qc = 0;
 214         size_t qd = 0;
 215         for (size_t i = 0; i < str.size(); i++)
 216         {
 217                 qc += (str[i] == ':') ? 1 : 0;
 218                 qd += (str[i] == '.') ? 1 : 0;
 219         }
 220         if (qc > 7)
 221         {
 222                 return false;
 223         }
 224         if (qd && qd != 3)
 225         {
 226                 return false;
 227         }
 228         Parse pa(str,":.");
 229         std::string tmp = pa.getword();
 230         while (tmp.size())
 231         {
 232                 if (tmp.size() > 4)
 233                 {
 234                         return false;
 235                 }
 236                 for (size_t i = 0; i < tmp.size(); i++)
 237                 {
 238                         if (tmp[i] < '0' || (tmp[i] > '9' && tmp[i] < 'A') ||
 239                                 (tmp[i] > 'F' && tmp[i] < 'a') || tmp[i] > 'f')
 240                         {
 241                                 return false;
 242                         }
 243                 }
 244                 //
 245                 tmp = pa.getword();
 246         }
 247         return true;
 248 }
 249
 250
 251 bool Utility::u2ip(const std::string& str, ipaddr_t& l)
 252 {
 253         struct sockaddr_in sa;
 254         bool r = Utility::u2ip(str, sa);
 255         memcpy(&l, &sa.sin_addr, sizeof(l));
 256         return r;
 257 }
 258
 259
 260 #ifdef ENABLE_IPV6
 261 #ifdef IPPROTO_IPV6
 262 bool Utility::u2ip(const std::string& str, struct in6_addr& l)
 263 {
 264         struct sockaddr_in6 sa;
 265         bool r = Utility::u2ip(str, sa);
 266         l = sa.sin6_addr;
 267         return r;
 268 }
 269 #endif
 270 #endif
 271
 272
 273 void Utility::l2ip(const ipaddr_t ip, std::string& str)
 274 {
 275         struct sockaddr_in sa;
 276         memset(&sa, 0, sizeof(sa));
 277         sa.sin_family = AF_INET;
 278         memcpy(&sa.sin_addr, &ip, sizeof(sa.sin_addr));
 279         Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
 280 }
 281
 282
 283 void Utility::l2ip(const in_addr& ip, std::string& str)
 284 {
 285         struct sockaddr_in sa;
 286         memset(&sa, 0, sizeof(sa));
 287         sa.sin_family = AF_INET;
 288         sa.sin_addr = ip;
 289         Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
 290 }
 291
 292
 293 #ifdef ENABLE_IPV6
 294 #ifdef IPPROTO_IPV6
 295 void Utility::l2ip(const struct in6_addr& ip, std::string& str,bool mixed)
 296 {
 297         char slask[100]; // l2ip temporary
 298         *slask = 0;
 299         unsigned int prev = 0;
 300         bool skipped = false;
 301         bool ok_to_skip = true;
 302         if (mixed)
 303         {
 304                 unsigned short x;
 305                 unsigned short addr16[8];
 306                 memcpy(addr16, &ip, sizeof(addr16));
 307                 for (size_t i = 0; i < 6; i++)
 308                 {
 309                         x = ntohs(addr16[i]);
 310                         if (*slask && (x || !ok_to_skip || prev))
 311                                 strcat(slask,":");
 312                         if (x || !ok_to_skip)
 313                         {
 314                                 sprintf(slask + strlen(slask),"%x", x);
 315                                 if (x && skipped)
 316                                         ok_to_skip = false;
 317                         }
 318                         else
 319                         {
 320                                 skipped = true;
 321                         }
 322                         prev = x;
 323                 }
 324                 x = ntohs(addr16[6]);
 325                 sprintf(slask + strlen(slask),":%u.%u",x / 256,x & 255);
 326                 x = ntohs(addr16[7]);
 327                 sprintf(slask + strlen(slask),".%u.%u",x / 256,x & 255);
 328         }
 329         else
 330         {
 331                 struct sockaddr_in6 sa;
 332                 memset(&sa, 0, sizeof(sa));
 333                 sa.sin6_family = AF_INET6;
 334                 sa.sin6_addr = ip;
 335                 Utility::reverse( (struct sockaddr *)&sa, sizeof(sa), str, NI_NUMERICHOST);
 336                 return;
 337         }
 338         str = slask;
 339 }
 340
 341
 342 int Utility::in6_addr_compare(in6_addr a,in6_addr b)
 343 {
 344         for (size_t i = 0; i < 16; i++)
 345         {
 346                 if (a.s6_addr[i] < b.s6_addr[i])
 347                         return -1;
 348                 if (a.s6_addr[i] > b.s6_addr[i])
 349                         return 1;
 350         }
 351         return 0;
 352 }
 353 #endif
 354 #endif
 355
 356
 357 void Utility::ResolveLocal()
 358 {
 359         char h[256];
 360
 361         // get local hostname and translate into ip-address
 362         *h = 0;
 363         gethostname(h,255);
 364         {
 365                 if (Utility::u2ip(h, m_ip))
 366                 {
 367                         Utility::l2ip(m_ip, m_addr);
 368                 }
 369         }
 370 #ifdef ENABLE_IPV6
 371 #ifdef IPPROTO_IPV6
 372         memset(&m_local_ip6, 0, sizeof(m_local_ip6));
 373         {
 374                 if (Utility::u2ip(h, m_local_ip6))
 375                 {
 376                         Utility::l2ip(m_local_ip6, m_local_addr6);
 377                 }
 378         }
 379 #endif
 380 #endif
 381         m_host = h;
 382         m_local_resolved = true;
 383 }
 384
 385
 386 const std::string& Utility::GetLocalHostname()
 387 {
 388         if (!m_local_resolved)
 389         {
 390                 ResolveLocal();
 391         }
 392         return m_host;
 393 }
 394
 395
 396 ipaddr_t Utility::GetLocalIP()
 397 {
 398         if (!m_local_resolved)
 399         {
 400                 ResolveLocal();
 401         }
 402         return m_ip;
 403 }
 404
 405
 406 const std::string& Utility::GetLocalAddress()
 407 {
 408         if (!m_local_resolved)
 409         {
 410                 ResolveLocal();
 411         }
 412         return m_addr;
 413 }
 414
 415
 416 #ifdef ENABLE_IPV6
 417 #ifdef IPPROTO_IPV6
 418 const struct in6_addr& Utility::GetLocalIP6()
 419 {
 420         if (!m_local_resolved)
 421         {
 422                 ResolveLocal();
 423         }
 424         return m_local_ip6;
 425 }
 426
 427
 428 const std::string& Utility::GetLocalAddress6()
 429 {
 430         if (!m_local_resolved)
 431         {
 432                 ResolveLocal();
 433         }
 434         return m_local_addr6;
 435 }
 436 #endif
 437 #endif
 438
 439
 440 void Utility::SetEnv(const std::string& var,const std::string& value)
 441 {
 442 #if (defined(SOLARIS8) || defined(SOLARIS))
 443         {
 444                 static std::map<std::string, char *> vmap;
 445                 if (vmap.find(var) != vmap.end())
 446                 {
 447                         delete[] vmap[var];
 448                 }
 449                 vmap[var] = new char[var.size() + 1 + value.size() + 1];
 450                 sprintf(vmap[var], "%s=%s", var.c_str(), value.c_str());
 451                 putenv( vmap[var] );
 452         }
 453 #elif defined _WIN32
 454         {
 455                 std::string slask = var + "=" + value;
 456                 _putenv( (char *)slask.c_str());
 457         }
 458 #else
 459         setenv(var.c_str(), value.c_str(), 1);
 460 #endif
 461 }
 462
 463
 464 std::string Utility::Sa2String(struct sockaddr *sa)
 465 {
 466 #ifdef ENABLE_IPV6
 467 #ifdef IPPROTO_IPV6
 468         if (sa -> sa_family == AF_INET6)
 469         {
 470                 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
 471                 std::string tmp;
 472                 Utility::l2ip(sa6 -> sin6_addr, tmp);
 473                 return tmp + ":" + Utility::l2string(ntohs(sa6 -> sin6_port));
 474         }
 475 #endif
 476 #endif
 477         if (sa -> sa_family == AF_INET)
 478         {
 479                 struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
 480                 ipaddr_t a;
 481                 memcpy(&a, &sa4 -> sin_addr, 4);
 482                 std::string tmp;
 483                 Utility::l2ip(a, tmp);
 484                 return tmp + ":" + Utility::l2string(ntohs(sa4 -> sin_port));
 485         }
 486         return "";
 487 }
 488
 489
 490 void Utility::GetTime(struct timeval *p)
 491 {
 492 #ifdef _WIN32
 493         FILETIME ft; // Contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
 494         GetSystemTimeAsFileTime(&ft);
 495         uint64_t tt;
 496         memcpy(&tt, &ft, sizeof(tt));
 497         tt /= 10; // make it usecs
 498         p->tv_sec = (long)tt / 1000000;
 499         p->tv_usec = (long)tt % 1000000;
 500 #else
 501         gettimeofday(p, NULL);
 502 #endif
 503 }
 504
 505
 506 std::auto_ptr<SocketAddress> Utility::CreateAddress(struct sockaddr *sa,socklen_t sa_len)
 507 {
 508         switch (sa -> sa_family)
 509         {
 510         case AF_INET:
 511                 if (sa_len == sizeof(struct sockaddr_in))
 512                 {
 513                         struct sockaddr_in *p = (struct sockaddr_in *)sa;
 514                         return std::auto_ptr<SocketAddress>(new Ipv4Address(*p));
 515                 }
 516                 break;
 517 #ifdef ENABLE_IPV6
 518 #ifdef IPPROTO_IPV6
 519         case AF_INET6:
 520                 if (sa_len == sizeof(struct sockaddr_in6))
 521                 {
 522                         struct sockaddr_in6 *p = (struct sockaddr_in6 *)sa;
 523                         return std::auto_ptr<SocketAddress>(new Ipv6Address(*p));
 524                 }
 525                 break;
 526 #endif
 527 #endif
 528         }
 529         return std::auto_ptr<SocketAddress>(NULL);
 530 }
 531
 532
 533 bool Utility::u2ip(const std::string& host, struct sockaddr_in& sa, int ai_flags)
 534 {
 535         memset(&sa, 0, sizeof(sa));
 536         sa.sin_family = AF_INET;
 537 #ifdef NO_GETADDRINFO
 538         if ((ai_flags & AI_NUMERICHOST) != 0 || isipv4(host))
 539         {
 540                 Parse pa((char *)host.c_str(), ".");
 541                 union {
 542                         struct {
 543                                 unsigned char b1;
 544                                 unsigned char b2;
 545                                 unsigned char b3;
 546                                 unsigned char b4;
 547                         } a;
 548                         ipaddr_t l;
 549                 } u;
 550                 u.a.b1 = static_cast<unsigned char>(pa.getvalue());
 551                 u.a.b2 = static_cast<unsigned char>(pa.getvalue());
 552                 u.a.b3 = static_cast<unsigned char>(pa.getvalue());
 553                 u.a.b4 = static_cast<unsigned char>(pa.getvalue());
 554                 memcpy(&sa.sin_addr, &u.l, sizeof(sa.sin_addr));
 555                 return true;
 556         }
 557 #ifndef LINUX
 558         struct hostent *he = gethostbyname( host.c_str() );
 559         if (!he)
 560         {
 561                 return false;
 562         }
 563         memcpy(&sa.sin_addr, he -> h_addr, sizeof(sa.sin_addr));
 564 #else
 565         struct hostent he;
 566         struct hostent *result = NULL;
 567         int myerrno = 0;
 568         char buf[2000];
 569         int n = gethostbyname_r(host.c_str(), &he, buf, sizeof(buf), &result, &myerrno);
 570         if (n || !result)
 571         {
 572                 return false;
 573         }
 574         if (he.h_addr_list && he.h_addr_list[0])
 575                 memcpy(&sa.sin_addr, he.h_addr, 4);
 576         else
 577                 return false;
 578 #endif
 579         return true;
 580 #else
 581         struct addrinfo hints;
 582         memset(&hints, 0, sizeof(hints));
 583         // AI_NUMERICHOST
 584         // AI_CANONNAME
 585         // AI_PASSIVE - server
 586         // AI_ADDRCONFIG
 587         // AI_V4MAPPED
 588         // AI_ALL
 589         // AI_NUMERICSERV
 590         hints.ai_flags = ai_flags;
 591         hints.ai_family = AF_INET;
 592         hints.ai_socktype = 0;
 593         hints.ai_protocol = 0;
 594         struct addrinfo *res;
 595         if (Utility::isipv4(host))
 596                 hints.ai_flags |= AI_NUMERICHOST;
 597         int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
 598         if (!n)
 599         {
 600                 static RandomNumber prng( true );
 601                 std::vector<struct addrinfo *> vec;
 602                 struct addrinfo *ai = res;
 603                 while (ai)
 604                 {
 605                         if (ai -> ai_addrlen == sizeof(sa))
 606                                 vec.push_back( ai );
 607                         prng.next();
 608                         //
 609                         ai = ai -> ai_next;
 610                 }
 611                 if (!vec.size())
 612                         return false;
 613                 ai = vec[prng.next() % vec.size()];
 614                 {
 615                         memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
 616                 }
 617                 freeaddrinfo(res);
 618                 return true;
 619         }
 620         std::string error = "Error: ";
 621 #ifndef __CYGWIN__
 622         error += gai_strerror(n);
 623 #endif
 624         return false;
 625 #endif // NO_GETADDRINFO
 626 }
 627
 628
 629 #ifdef ENABLE_IPV6
 630 #ifdef IPPROTO_IPV6
 631 bool Utility::u2ip(const std::string& host, struct sockaddr_in6& sa, int ai_flags)
 632 {
 633         memset(&sa, 0, sizeof(sa));
 634         sa.sin6_family = AF_INET6;
 635 #ifdef NO_GETADDRINFO
 636         if ((ai_flags & AI_NUMERICHOST) != 0 || isipv6(host))
 637         {
 638                 std::list<std::string> vec;
 639                 size_t x = 0;
 640                 for (size_t i = 0; i <= host.size(); i++)
 641                 {
 642                         if (i == host.size() || host[i] == ':')
 643                         {
 644                                 std::string s = host.substr(x, i - x);
 645                                 //
 646                                 if (strstr(s.c_str(),".")) // x.x.x.x
 647                                 {
 648                                         Parse pa(s,".");
 649                                         char slask[100]; // u2ip temporary hex2string conversion
 650                                         unsigned long b0 = static_cast<unsigned long>(pa.getvalue());
 651                                         unsigned long b1 = static_cast<unsigned long>(pa.getvalue());
 652                                         unsigned long b2 = static_cast<unsigned long>(pa.getvalue());
 653                                         unsigned long b3 = static_cast<unsigned long>(pa.getvalue());
 654                                         sprintf(slask,"%lx",b0 * 256 + b1);
 655                                         vec.push_back(slask);
 656                                         sprintf(slask,"%lx",b2 * 256 + b3);
 657                                         vec.push_back(slask);
 658                                 }
 659                                 else
 660                                 {
 661                                         vec.push_back(s);
 662                                 }
 663                                 //
 664                                 x = i + 1;
 665                         }
 666                 }
 667                 size_t sz = vec.size(); // number of byte pairs
 668                 size_t i = 0; // index in in6_addr.in6_u.u6_addr16[] ( 0 .. 7 )
 669                 unsigned short addr16[8];
 670                 for (std::list<std::string>::iterator it = vec.begin(); it != vec.end(); it++)
 671                 {
 672                         std::string bytepair = *it;
 673                         if (bytepair.size())
 674                         {
 675                                 addr16[i++] = htons(Utility::hex2unsigned(bytepair));
 676                         }
 677                         else
 678                         {
 679                                 addr16[i++] = 0;
 680                                 while (sz++ < 8)
 681                                 {
 682                                         addr16[i++] = 0;
 683                                 }
 684                         }
 685                 }
 686                 memcpy(&sa.sin6_addr, addr16, sizeof(addr16));
 687                 return true;
 688         }
 689 #ifdef SOLARIS
 690         int errnum = 0;
 691         struct hostent *he = getipnodebyname( host.c_str(), AF_INET6, 0, &errnum );
 692 #else
 693         struct hostent *he = gethostbyname2( host.c_str(), AF_INET6 );
 694 #endif
 695         if (!he)
 696         {
 697                 return false;
 698         }
 699         memcpy(&sa.sin6_addr,he -> h_addr_list[0],he -> h_length);
 700 #ifdef SOLARIS
 701         free(he);
 702 #endif
 703         return true;
 704 #else
 705         struct addrinfo hints;
 706         memset(&hints, 0, sizeof(hints));
 707         hints.ai_flags = ai_flags;
 708         hints.ai_family = AF_INET6;
 709         hints.ai_socktype = 0;
 710         hints.ai_protocol = 0;
 711         struct addrinfo *res;
 712         if (Utility::isipv6(host))
 713                 hints.ai_flags |= AI_NUMERICHOST;
 714         int n = getaddrinfo(host.c_str(), NULL, &hints, &res);
 715         if (!n)
 716         {
 717                 static RandomNumber prng( true );
 718                 std::vector<struct addrinfo *> vec;
 719                 struct addrinfo *ai = res;
 720                 while (ai)
 721                 {
 722                         if (ai -> ai_addrlen == sizeof(sa))
 723                                 vec.push_back( ai );
 724                         prng.next();
 725                         //
 726                         ai = ai -> ai_next;
 727                 }
 728                 if (!vec.size())
 729                         return false;
 730                 ai = vec[prng.next() % vec.size()];
 731                 {
 732                         memcpy(&sa, ai -> ai_addr, ai -> ai_addrlen);
 733                 }
 734                 freeaddrinfo(res);
 735                 return true;
 736         }
 737         std::string error = "Error: ";
 738 #ifndef __CYGWIN__
 739         error += gai_strerror(n);
 740 #endif
 741         return false;
 742 #endif // NO_GETADDRINFO
 743 }
 744 #endif // IPPROTO_IPV6
 745 #endif // ENABLE_IPV6
 746
 747
 748 bool Utility::reverse(struct sockaddr *sa, socklen_t sa_len, std::string& hostname, int flags)
 749 {
 750         std::string service;
 751         return Utility::reverse(sa, sa_len, hostname, service, flags);
 752 }
 753
 754
 755 bool Utility::reverse(struct sockaddr *sa, socklen_t sa_len, std::string& hostname, std::string& service, int flags)
 756 {
 757         hostname = "";
 758         service = "";
 759 #ifdef NO_GETADDRINFO
 760         switch (sa -> sa_family)
 761         {
 762         case AF_INET:
 763                 if (flags & NI_NUMERICHOST)
 764                 {
 765                         union {
 766                                 struct {
 767                                         unsigned char b1;
 768                                         unsigned char b2;
 769                                         unsigned char b3;
 770                                         unsigned char b4;
 771                                 } a;
 772                                 ipaddr_t l;
 773                         } u;
 774                         struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
 775                         memcpy(&u.l, &sa_in -> sin_addr, sizeof(u.l));
 776                         char tmp[100];
 777                         sprintf(tmp, "%u.%u.%u.%u", u.a.b1, u.a.b2, u.a.b3, u.a.b4);
 778                         hostname = tmp;
 779                         return true;
 780                 }
 781                 else
 782                 {
 783                         struct sockaddr_in *sa_in = (struct sockaddr_in *)sa;
 784                         struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin_addr, sizeof(sa_in -> sin_addr), AF_INET);
 785                         if (h)
 786                         {
 787                                 hostname = h -> h_name;
 788                                 return true;
 789                         }
 790                 }
 791                 break;
 792 #ifdef ENABLE_IPV6
 793         case AF_INET6:
 794                 if (flags & NI_NUMERICHOST)
 795                 {
 796                         char slask[100]; // l2ip temporary
 797                         *slask = 0;
 798                         unsigned int prev = 0;
 799                         bool skipped = false;
 800                         bool ok_to_skip = true;
 801                         {
 802                                 unsigned short addr16[8];
 803                                 struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)sa;
 804                                 memcpy(addr16, &sa_in6 -> sin6_addr, sizeof(addr16));
 805                                 for (size_t i = 0; i < 8; i++)
 806                                 {
 807                                         unsigned short x = ntohs(addr16[i]);
 808                                         if (*slask && (x || !ok_to_skip || prev))
 809                                                 strcat(slask,":");
 810                                         if (x || !ok_to_skip)
 811                                         {
 812                                                 sprintf(slask + strlen(slask),"%x", x);
 813                                                 if (x && skipped)
 814                                                         ok_to_skip = false;
 815                                         }
 816                                         else
 817                                         {
 818                                                 skipped = true;
 819                                         }
 820                                         prev = x;
 821                                 }
 822                         }
 823                         if (!*slask)
 824                                 strcpy(slask, "::");
 825                         hostname = slask;
 826                         return true;
 827                 }
 828                 else
 829                 {
 830                         // %! TODO: ipv6 reverse lookup
 831                         struct sockaddr_in6 *sa_in = (struct sockaddr_in6 *)sa;
 832                         struct hostent *h = gethostbyaddr( (const char *)&sa_in -> sin6_addr, sizeof(sa_in -> sin6_addr), AF_INET6);
 833                         if (h)
 834                         {
 835                                 hostname = h -> h_name;
 836                                 return true;
 837                         }
 838                 }
 839                 break;
 840 #endif
 841         }
 842         return false;
 843 #else
 844         char host[NI_MAXHOST];
 845         char serv[NI_MAXSERV];
 846         // NI_NOFQDN
 847         // NI_NUMERICHOST
 848         // NI_NAMEREQD
 849         // NI_NUMERICSERV
 850         // NI_DGRAM
 851         int n = getnameinfo(sa, sa_len, host, sizeof(host), serv, sizeof(serv), flags);
 852         if (n)
 853         {
 854                 // EAI_AGAIN
 855                 // EAI_BADFLAGS
 856                 // EAI_FAIL
 857                 // EAI_FAMILY
 858                 // EAI_MEMORY
 859                 // EAI_NONAME
 860                 // EAI_OVERFLOW
 861                 // EAI_SYSTEM
 862                 return false;
 863         }
 864         hostname = host;
 865         service = serv;
 866         return true;
 867 #endif // NO_GETADDRINFO
 868 }
 869
 870
 871 bool Utility::u2service(const std::string& name, int& service, int ai_flags)
 872 {
 873 #ifdef NO_GETADDRINFO
 874         // %!
 875         return false;
 876 #else
 877         struct addrinfo hints;
 878         service = 0;
 879         memset(&hints, 0, sizeof(hints));
 880         // AI_NUMERICHOST
 881         // AI_CANONNAME
 882         // AI_PASSIVE - server
 883         // AI_ADDRCONFIG
 884         // AI_V4MAPPED
 885         // AI_ALL
 886         // AI_NUMERICSERV
 887         hints.ai_flags = ai_flags;
 888         hints.ai_family = AF_UNSPEC;
 889         hints.ai_socktype = 0;
 890         hints.ai_protocol = 0;
 891         struct addrinfo *res;
 892         int n = getaddrinfo(NULL, name.c_str(), &hints, &res);
 893         if (!n)
 894         {
 895                 service = res -> ai_protocol;
 896                 freeaddrinfo(res);
 897                 return true;
 898         }
 899         return false;
 900 #endif // NO_GETADDRINFO
 901 }
 902
 903
 904 unsigned long Utility::ThreadID()
 905 {
 906 #ifdef _WIN32
 907         return GetCurrentThreadId();
 908 #else
 909         return (unsigned long)pthread_self();
 910 #endif
 911 }
 912
 913
 914 std::string Utility::ToLower(const std::string& str)
 915 {
 916         std::string r;
 917         for (size_t i = 0; i < str.size(); i++)
 918         {
 919                 if (str[i] >= 'A' && str[i] <= 'Z')
 920                         r += str[i] | 32;
 921                 else
 922                         r += str[i];
 923         }
 924         return r;
 925 }
 926
 927
 928 std::string Utility::ToUpper(const std::string& str)
 929 {
 930         std::string r;
 931         for (size_t i = 0; i < str.size(); i++)
 932         {
 933                 if (str[i] >= 'a' && str[i] <= 'z')
 934                         r += (char)(str[i] - 32);
 935                 else
 936                         r += str[i];
 937         }
 938         return r;
 939 }
 940
 941
 942 std::string Utility::ToString(double d)
 943 {
 944         char tmp[100];
 945         sprintf(tmp, "%f", d);
 946         return tmp;
 947 }
 948
 949
 950 #ifdef SOCKETS_NAMESPACE
 951 }
 952 #endif
 953