stglibs/common.lib/common.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Date: 27.10.2002
  19  */
  20
  21 /*
  22  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  23  */
  24
  25  /*
  26  $Revision: 1.42 $
  27  $Date: 2010/11/08 10:11:19 $
  28  $Author: faust $
  29  */
  30
  31 // For old and dub systems
  32 // Like FreeBSD4
  33 #include <sys/types.h>
  34 #include <sys/time.h>
  35 #include <unistd.h>
  36
  37 #include <sys/select.h>
  38
  39 #ifdef WIN32
  40 #include <winsock2.h>
  41 #else
  42 #include <sys/socket.h>
  43 #include <netinet/in.h>
  44 #include <arpa/inet.h>
  45 #include <sys/select.h>
  46 #endif
  47
  48 #include <iconv.h>
  49
  50 #include <algorithm>
  51
  52 #include <cstdlib>
  53 #include <cstdarg>
  54 #include <cstdio>
  55 #include <cstring>
  56 #include <cerrno>
  57 #include <cassert>
  58
  59 #include "stg/common.h"
  60
  61 #ifndef INET_ADDRSTRLEN
  62 #   define INET_ADDRSTRLEN 16
  63 #endif
  64
  65 namespace
  66 {
  67 //---------------------------------------------------------------------------
  68 unsigned char koi2win[] = {
  69         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  70         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  71         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  72         0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
  73         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  74         0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
  75         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  76         0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
  77         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
  78         0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
  79         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
  80         0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
  81         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  82         0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
  83         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  84         0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
  85         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  86         0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
  87         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  88         0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
  89         0xA0, 0xA1, 0xA2, 0xB8, 0xBA, 0xA5, 0xB3, 0xBF,
  90         0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xB4, 0xAE, 0xAF,
  91         0xB0, 0xB1, 0xB2, 0xA8, 0xAA, 0xB5, 0xB2, 0xAF,
  92         0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xA5, 0xBE, 0xBF,
  93         0xFE, 0xE0, 0xE1, 0xF6, 0xE4, 0xE5, 0xF4, 0xE3,
  94         0xF5, 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE,
  95         0xEF, 0xFF, 0xF0, 0xF1, 0xF2, 0xF3, 0xE6, 0xE2,
  96         0xFC, 0xFB, 0xE7, 0xF8, 0xFD, 0xF9, 0xF7, 0xFA,
  97         0xDE, 0xC0, 0xC1, 0xD6, 0xC4, 0xC5, 0xD4, 0xC3,
  98         0xD5, 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE,
  99         0xCF, 0xDF, 0xD0, 0xD1, 0xD2, 0xD3, 0xC6, 0xC2,
 100         0xDC, 0xDB, 0xC7, 0xD8, 0xDD, 0xD9, 0xD7, 0xDA};
 101
 102
 103 unsigned char win2koi[] = {
 104         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 105         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
 106         0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 107         0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
 108         0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 109         0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
 110         0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 111         0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
 112         0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 113         0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
 114         0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
 115         0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
 116         0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 117         0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
 118         0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 119         0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
 120         0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 121         0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
 122         0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
 123         0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
 124         0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xBD, 0xA6, 0xA7,
 125         0xB3, 0xA9, 0xB4, 0xAB, 0xAC, 0xAD, 0xAE, 0xB7,
 126         0xB0, 0xB1, 0xB6, 0xA6, 0xAD, 0xB5, 0xB6, 0xB7,
 127         0xA3, 0xB9, 0xA4, 0xBB, 0xBC, 0xBD, 0xBE, 0xA7,
 128         0xE1, 0xE2, 0xF7, 0xE7, 0xE4, 0xE5, 0xF6, 0xFA,
 129         0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0,
 130         0xF2, 0xF3, 0xF4, 0xF5, 0xE6, 0xE8, 0xE3, 0xFE,
 131         0xFB, 0xFD, 0xFF, 0xF9, 0xF8, 0xFC, 0xE0, 0xF1,
 132         0xC1, 0xC2, 0xD7, 0xC7, 0xC4, 0xC5, 0xD6, 0xDA,
 133         0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0,
 134         0xD2, 0xD3, 0xD4, 0xD5, 0xC6, 0xC8, 0xC3, 0xDE,
 135         0xDB, 0xDD, 0xDF, 0xD9, 0xD8, 0xDC, 0xC0, 0xD1};
 136 }
 137
 138 #ifdef WIN32
 139 //-----------------------------------------------------------------------------
 140 const char * inet_ntop(int af, const void * src, char * dst, unsigned long length)
 141 {
 142 struct sockaddr_in addr;
 143 addr.sin_family = af;
 144 addr.sin_port = 0;
 145 memcpy(&addr.sin_addr.s_addr, src, sizeof(addr.sin_addr.s_addr));
 146 if (WSAAddressToStringA(reinterpret_cast<struct sockaddr *>(&addr), sizeof(addr), 0, dst, &length))
 147     {
 148     return NULL;
 149     }
 150 return dst;
 151 }
 152 //-----------------------------------------------------------------------------
 153 int inet_pton(int af, const char * src, void * dst)
 154 {
 155 // Fuck you Microsoft!
 156 // Why the hell not to use const char *?
 157 size_t slen = strlen(src);
 158 char * buf = new char[slen + 1];
 159 strncpy(buf, src, slen + 1);
 160 buf[slen] = 0;
 161 struct sockaddr_in addr;
 162 addr.sin_family = af;
 163 addr.sin_port = 0;
 164 addr.sin_addr.s_addr = 0;
 165 int length = sizeof(addr);
 166 if (WSAStringToAddressA(buf, af, 0, reinterpret_cast<struct sockaddr *>(&addr), &length))
 167     {
 168     delete[] buf;
 169     return -1;
 170     }
 171 memcpy(dst, &addr, sizeof(addr));
 172 delete[] buf;
 173 return 1;
 174 }
 175 #endif
 176 //-----------------------------------------------------------------------------
 177 int strtodouble2(const char * s, double &a)
 178 {
 179 char *res;
 180
 181 a = strtod(s, &res);
 182
 183 if (*res != 0)
 184     return EINVAL;
 185
 186 return 0;
 187 }
 188 //-----------------------------------------------------------------------------
 189 #ifdef DEBUG
 190 int printfd(const char * __file__, const char * fmt, ...)
 191 #else
 192 int printfd(const char *, const char *, ...)
 193 #endif
 194 {
 195 #ifdef DEBUG
 196 char buff[1024];
 197
 198 time_t t = time(NULL);
 199
 200 va_list vl;
 201 va_start(vl, fmt);
 202 vsnprintf(buff, sizeof(buff), fmt, vl);
 203 va_end(vl);
 204
 205 printf("%18s > %s > ", __file__, LogDate(t)+11);
 206 printf("%s", buff);
 207
 208 #endif
 209 return 0;
 210 }
 211 //-----------------------------------------------------------------------------
 212 int strprintf(std::string * str, const char * fmt, ...)
 213 {
 214 char buff[1024];
 215
 216 va_list vl;
 217 va_start(vl, fmt);
 218 int n = vsnprintf(buff, sizeof(buff), fmt, vl);
 219 va_end(vl);
 220 buff[1023] = 0;
 221 *str = buff;
 222
 223 return n;
 224 }
 225 //-----------------------------------------------------------------------------
 226 const char *IntToKMG(int64_t a, int stat)
 227 {
 228 static const double K = 1024;
 229 static const double M = 1024 * 1024;
 230 static const double G = 1024 * 1024 * 1024;
 231 static char str[30];
 232 double value = a;
 233
 234 switch (stat)
 235     {
 236     case ST_B:
 237         #ifdef __WIN32__
 238         sprintf(str, "%Ld", a);
 239         #else
 240         sprintf(str, "%lld", a);
 241         #endif
 242         break;
 243     case ST_KB:
 244         sprintf(str, "%.2f kb", value / K);
 245         break;
 246     case ST_MB:
 247         sprintf(str, "%.2f Mb", value / M);
 248         break;
 249     default:
 250         if (a > G)
 251             {
 252             sprintf(str, "%.2f Gb", value / G);
 253             return &str[0];
 254             }
 255         if (a < -G)
 256             {
 257             sprintf(str, "%.2f Gb", value / G);
 258             return &str[0];
 259             }
 260         if (a > M)
 261             {
 262             sprintf(str, "%.2f Mb", value / M);
 263             return &str[0];
 264             }
 265         if (a < -M)
 266             {
 267             sprintf(str, "%.2f Mb", value / M);
 268             return &str[0];
 269             }
 270
 271         sprintf(str, "%.2f kb", value / K);
 272         break;
 273     }
 274 return str;
 275 }
 276 //---------------------------------------------------------------------------
 277 void KOIToWin(const char * s1, char * s2, int l)
 278 {
 279 for (int j = 0; j < l; j++)
 280     {
 281     unsigned char t = s1[j];
 282     s2[j] = koi2win[t];
 283
 284     if (s1[j] == 0)
 285         break;
 286     }
 287 }
 288 //---------------------------------------------------------------------------
 289 void WinToKOI(const char * s1, char * s2, int l)
 290 {
 291 for (int j = 0; j < l; j++)
 292     {
 293     unsigned char t = s1[j];
 294     s2[j] = win2koi[t];
 295
 296     if (s1[j] == 0)
 297         break;
 298     }
 299 }
 300 //---------------------------------------------------------------------------
 301 void KOIToWin(const std::string & s1, std::string * s2)
 302 {
 303 s2->erase(s2->begin(), s2->end());
 304 s2->reserve(s1.length());
 305 for (int j = 0; j < (int)s1.length(); j++)
 306     {
 307     unsigned char t = s1[j];
 308     s2->push_back(koi2win[t]);
 309     }
 310 }
 311 //---------------------------------------------------------------------------
 312 void WinToKOI(const std::string & s1, std::string * s2)
 313 {
 314 s2->erase(s2->begin(), s2->end());
 315 s2->reserve(s1.length());
 316 for (int j = 0; j < (int)s1.length(); j++)
 317     {
 318     unsigned char t = s1[j];
 319     s2->push_back(win2koi[t]);
 320     }
 321 }
 322 //---------------------------------------------------------------------------
 323 void Encode12str(std::string & dst, const std::string & src)
 324 {
 325 dst.erase(dst.begin(), dst.end());
 326 for (size_t i = 0; i < src.length(); i++)
 327     {
 328     dst.push_back('a' + (src[i] & 0x0f));
 329     dst.push_back('a' + ((src[i] & 0xf0) >> 4));
 330     }
 331 }
 332 //---------------------------------------------------------------------------
 333 void Decode21str(std::string & dst, const std::string & src)
 334 {
 335 dst.erase(dst.begin(), dst.end());
 336 for (size_t i = 0; i < src.length() / 2; i++)
 337     {
 338     char c1 = src[i * 2];
 339     char c2 = src[i * 2 + 1];
 340
 341     c1 -= 'a';
 342     c2 -= 'a';
 343
 344     dst.push_back(static_cast<char>(c1 + (c2 << 4)));
 345     }
 346 }
 347 //---------------------------------------------------------------------------
 348 void Encode12(char * dst, const char * src, size_t srcLen)
 349 {
 350 for (size_t i = 0; i <= srcLen; i++)
 351     {
 352     char c1 = src[i] & 0x0f;
 353     char c2 = (src[i] & 0xf0) >> 4;
 354
 355     c1 += 'a';
 356     c2 += 'a';
 357
 358     dst[i * 2] = c1;
 359     dst[i * 2 + 1] = c2;
 360     }
 361 dst[srcLen * 2] = 0;
 362 }
 363 //---------------------------------------------------------------------------
 364 void Decode21(char * dst, const char * src)
 365 {
 366 for (size_t i = 0; ; i++)
 367     {
 368     if (src[i * 2] == 0)
 369         break;
 370
 371     char c1 = src[i * 2];
 372     char c2 = src[i * 2 + 1];
 373
 374     c1 -= 'a';
 375     c2 -= 'a';
 376
 377     dst[i] = static_cast<char>(c1 + (c2 << 4));
 378     }
 379 dst[strlen(src) / 2] = 0;
 380 }
 381 //---------------------------------------------------------------------------
 382 int ParseIPString(const char * str, uint32_t * ips, int maxIP)
 383 {
 384 /*
 385  *Function Name:ParseIPString
 386  *
 387  *Parameters:
 388  ÓÔÒÏËÁ ÄÌÑ ÒÁÚÂÏÒÁ É ÍÁÓÓÉ× ËÕÄÁ ÚÁÎÏÓÉÔØ ÐÏÌÕÞÅÎÎÙÅ ÁÄÒÅÓÁ
 389  *
 390  *Description:
 391  îÁ ×ÈÏÄÅ ÄÏÌÖÎÁ ÂÙÔØ ÓÔÒÏËÁ ×ÉÄÁ "ip1,ip2,ip3" ÉÌÉ "*"
 392  ÷ ÐÅÒ×ÏÍ ÓÌÕÞÁÅ × ÍÁÓÓÉ× ÚÁÎÏÓÑÔÓÑ ÒÁÚÏÂÒÁÎÎÙÅ ÁÄÒÅÓÁ.
 393  åÓÌÉ ÉÈ ÍÅÎØÛÅ MAX_IP?, ÔÏ ÐÏÓÌÅÄÎÉÊ ÁÄÒÅÓ ÂÕÄÅÔ 255.255.255.255
 394  åÓÌÉ ÓÔÒÏËÁ * , ÔÏ ÐÅÒ×ÁÙÊ ÁÄÒÅÓ ÂÕÄÅÔ 0.0.0.0, Ô.Å. ÌÀÂÏÊ
 395  *
 396  *Returns: 0 ÅÓÌÉ ×ÓÅ ïë
 397  *
 398  */
 399
 400 char p[255];
 401 int n = 0;
 402
 403 strncpy(p, str, 254);
 404 char * pp = p;
 405
 406 memset(ips, 0xFF, sizeof(unsigned long) * maxIP);
 407
 408 if (str[0] == '*' && strlen(str) == 1)
 409     {
 410     ips[0] = 0;
 411     return 0;
 412     }
 413
 414 for (int i = 0; i < maxIP; i++)
 415     {
 416     char * p1 = strtok(pp, ",\n ");
 417     pp = NULL;
 418
 419     if (p1 == NULL && n == 0)// ÕËÁÚÁÔÅÌØ ÎÕÌØ É ÐÒÏÞÉÔÁÎÏ ÁÄÒÅÓÏ× ÔÏÖÅ ÎÏÌØ
 420         {
 421         return EINVAL;
 422         }
 423
 424     if (p1 == NULL && n)
 425         {
 426         return 0;
 427         }
 428
 429     struct in_addr in;
 430     if (inet_pton(AF_INET, p1, &in) != 1)
 431         {
 432         //printf("INADDR_NONE\n");
 433         return EINVAL;
 434         }
 435
 436     ips[n] = in.s_addr;
 437
 438     /*if (ips[n] == INADDR_NONE)
 439         return EINVAL;*/
 440
 441     n++;
 442
 443     if (n >= maxIP)
 444         return 0;
 445
 446     }
 447
 448 return 0;
 449 }
 450 //-----------------------------------------------------------------------------
 451 int DaysInCurrentMonth()
 452 {
 453 time_t t = time(NULL);
 454
 455 struct tm * lt = localtime(&t);
 456
 457 return DaysInMonth(lt->tm_year, lt->tm_mon);
 458 }
 459 //-----------------------------------------------------------------------------
 460 int DaysInMonth(unsigned year, unsigned mon)
 461 {
 462 assert(mon < 12 && "Month number should be 0 - 11");
 463 switch (mon)
 464     {
 465     case 0: return 31;  //jan
 466     case 1:
 467         if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
 468             return 29;
 469         return 28;      //feb
 470     case 2: return 31;  //mar
 471     case 3: return 30;  //apr
 472     case 4: return 31;  //may
 473     case 5: return 30;  //june
 474     case 6: return 31;  //jule
 475     case 7: return 31;  //aug
 476     case 8: return 30;  //sep
 477     case 9: return 31;  //oct
 478     case 10: return 30; //nov
 479     case 11: return 31; //dec
 480     }
 481 return -1; // We will never reach here
 482 }
 483 //-----------------------------------------------------------------------------
 484 int Min8(int a)
 485 {
 486 /*
 487 æÕÎËÃÉÑ ×ÏÚ×ÒÁÝÁÅÔ ÎÁÉÍÅÎØÛÅÅ ÞÉÓÌÏ ËÒÁÔÎÏÅ 8-ÍÉ ÂÏÌØÛÅÅ ÉÌÉ ÒÁ×ÎÏÅ ÚÁÄÁÎÎÏÍÕ
 488  * */
 489 if (a % 8 == 0)
 490     return a;
 491
 492 return a + (8 - a % 8);
 493 }
 494 //-----------------------------------------------------------------------------
 495 /*char * inet_ntostr(unsigned long ip)
 496 {
 497 struct in_addr addr = {ip};
 498 return inet_ntoa(addr);
 499 }*/
 500 //-----------------------------------------------------------------------------
 501 std::string inet_ntostring(uint32_t ip)
 502 {
 503     char buf[INET_ADDRSTRLEN + 1];
 504     return inet_ntop(AF_INET, &ip, buf, INET_ADDRSTRLEN);
 505 }
 506 //-----------------------------------------------------------------------------
 507 uint32_t inet_strington(const std::string & value)
 508 {
 509     uint32_t result;
 510
 511     if (inet_pton(AF_INET, value.c_str(), &result) <= 0)
 512         return 0;
 513
 514     return result;
 515 }
 516 //-----------------------------------------------------------------------------
 517 std::string TimeToString(time_t time)
 518 {
 519 struct tm brokenTime;
 520
 521 brokenTime.tm_wday = 0;
 522 brokenTime.tm_yday = 0;
 523 brokenTime.tm_isdst = 0;
 524
 525 gmtime_r(&time, &brokenTime);
 526
 527 char buf[32];
 528 strftime(buf, 32, "%Y-%m-%d %H:%M:%S", &brokenTime);
 529
 530 return buf;
 531 }
 532 //-----------------------------------------------------------------------------
 533 int ParseTariffTimeStr(const char * str, int &h1, int &m1, int &h2, int &m2)
 534 {
 535 char hs1[10], ms1[10], hs2[10], ms2[10];
 536 char s1[25], s2[25];
 537 char ss[49];
 538 char *p1, *p2;
 539
 540 strncpy(ss, str, 48);
 541
 542 p1 = strtok(ss, "-");
 543 if (!p1)
 544     return -1;
 545
 546 strncpy(s1, p1, 24);
 547
 548 p2 = strtok(NULL, "-");
 549 if (!p2)
 550     return -1;
 551
 552 strncpy(s2, p2, 24);
 553
 554 p1 = strtok(s1, ":");
 555 if (!p1)
 556     return -1;
 557
 558 strncpy(hs1, p1, 9);
 559
 560 p2 = strtok(NULL, ":");
 561 if (!p2)
 562     return -1;
 563
 564 strncpy(ms1, p2, 9);
 565
 566 p1 = strtok(s2, ":");
 567 if (!p1)
 568     return -1;
 569
 570 strncpy(hs2, p1, 9);
 571
 572 p2 = strtok(NULL, ":");
 573 if (!p2)
 574     return -1;
 575
 576 strncpy(ms2, p2, 9);
 577
 578 if (str2x(hs1, h1) != 0)
 579     return -1;
 580
 581 if (str2x(ms1, m1) != 0)
 582     return -1;
 583
 584 if (str2x(hs2, h2) != 0)
 585     return -1;
 586
 587 if (str2x(ms2, m2) != 0)
 588     return -1;
 589
 590 return 0;
 591 }
 592 /*//---------------------------------------------------------------------------
 593 bool IsDigit(char c)
 594 {
 595 if (c >= '0' && c <= '9')
 596     return true;
 597 return false;
 598 }
 599 //-----------------------------------------------------------------------------
 600 bool IsAlpha(char c)
 601 {
 602 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
 603     return true;
 604 return false;
 605 }*/
 606 //-----------------------------------------------------------------------------
 607 const char * LogDate(time_t t)
 608 {
 609 static char s[32];
 610 struct tm * tt = localtime(&t);
 611
 612 snprintf(s, 20, "%d-%s%d-%s%d %s%d:%s%d:%s%d",
 613          tt->tm_year + 1900,
 614          tt->tm_mon + 1 < 10 ? "0" : "", tt->tm_mon + 1,
 615          tt->tm_mday    < 10 ? "0" : "", tt->tm_mday,
 616          tt->tm_hour    < 10 ? "0" : "", tt->tm_hour,
 617          tt->tm_min     < 10 ? "0" : "", tt->tm_min,
 618          tt->tm_sec     < 10 ? "0" : "", tt->tm_sec);
 619
 620 return s;
 621 }
 622 //-----------------------------------------------------------------------------
 623 uint32_t CalcMask(uint32_t msk)
 624 {
 625 if (msk >= 32) return 0xFFffFFff;
 626 if (msk == 0) return 0;
 627 return htonl(0xFFffFFff << (32 - msk));
 628 }
 629 //---------------------------------------------------------------------------
 630 void TouchFile(const std::string & fileName)
 631 {
 632 FILE * f = fopen(fileName.c_str(), "w");
 633 if (f)
 634     fclose(f);
 635 }
 636 //---------------------------------------------------------------------------
 637 #ifdef WIN32
 638 void EncodeStr(char * str, unsigned long serial, int useHDD)
 639 {
 640 int len = strlen(str);
 641 char stren[100];
 642 int i, j = 0;
 643 char c1, c2;
 644 char serial_c[sizeof(serial)];
 645 memcpy(serial_c, &serial, sizeof(serial));
 646
 647 for (i = 0; i < len; i++)
 648     {
 649     if (!useHDD)
 650         str[i] = str[i]^49;
 651     else
 652         {
 653         str[i] = str[i]^serial_c[j%sizeof(serial)];
 654         j++;
 655         }
 656     }
 657
 658 for (i = 0; i < 2*len; i++)
 659     {
 660     if (i%2)
 661         {
 662         c1 = (str[i/2] >> 4);
 663         c1 = c1 + 50;
 664         stren[i] = c1;
 665         }
 666     else
 667         {
 668         c2 = (str[i/2] & 0x0f);
 669         c2 += 50;
 670         stren[i] = c2;
 671         }
 672     }
 673 stren[i] = 0;
 674 strcpy(str, stren);
 675 }
 676 //---------------------------------------------------------------------------
 677 void DecodeStr(char * str, unsigned long serial, int useHDD)
 678 {
 679 size_t len = strlen(str);
 680 char strdc[100];
 681 char serial_c[sizeof(serial)];
 682 memcpy(serial_c, &serial, sizeof(serial));
 683
 684 for (size_t i = 0; i < len; i += 2)
 685     {
 686     char c1 = (str[i] - 50);
 687     char c2 = (str[i+1] - 50)<<4;
 688     strdc[i/2] = c1+c2;
 689     }
 690 for (size_t i = 0; i < len/2; i++)
 691     {
 692     if (!useHDD)
 693         strdc[i] = strdc[i]^49;
 694     else
 695         {
 696         strdc[i] = strdc[i]^serial_c[j%sizeof(serial)];
 697         j++;
 698         }
 699     }
 700 strdc[i] = 0;
 701 strcpy(str, strdc);
 702 }
 703 //---------------------------------------------------------------------------
 704 #endif //WIN32
 705 void SwapBytes(uint16_t & value)
 706 {
 707     value = static_cast<uint16_t>((value >> 8) |
 708                                   (value << 8));
 709 }
 710 //---------------------------------------------------------------------------
 711 void SwapBytes(uint32_t & value)
 712 {
 713     value = static_cast<uint32_t>((value >> 24) |
 714                                   ((value << 8) &  0x00FF0000L) |
 715                                   ((value >> 8) &  0x0000FF00L) |
 716                                   (value << 24));
 717 }
 718 //---------------------------------------------------------------------------
 719 void SwapBytes(uint64_t & value)
 720 {
 721     value = static_cast<uint64_t>((value >> 56) |
 722                                   ((value << 40) & 0x00FF000000000000LL) |
 723                                   ((value << 24) & 0x0000FF0000000000LL) |
 724                                   ((value << 8)  & 0x000000FF00000000LL) |
 725                                   ((value >> 8)  & 0x00000000FF000000LL) |
 726                                   ((value >> 24) & 0x0000000000FF0000LL) |
 727                                   ((value >> 40) & 0x000000000000FF00LL) |
 728                                   (value << 56));
 729 }
 730 //---------------------------------------------------------------------------
 731 void SwapBytes(int16_t & value)
 732 {
 733     uint16_t temp = value;
 734     SwapBytes(temp);
 735     value = temp;
 736 }
 737 //---------------------------------------------------------------------------
 738 void SwapBytes(int32_t & value)
 739 {
 740     uint32_t temp = value;
 741     SwapBytes(temp);
 742     value = temp;
 743 }
 744 //---------------------------------------------------------------------------
 745 void SwapBytes(int64_t & value)
 746 {
 747     uint64_t temp = value;
 748     SwapBytes(temp);
 749     value = temp;
 750 }
 751 //---------------------------------------------------------------------------
 752 int str2x(const std::string & str, int32_t & x)
 753 {
 754 x = static_cast<int32_t>(strtol(str.c_str(), NULL, 10));
 755
 756 if (errno == ERANGE)
 757     return -1;
 758
 759 return 0;
 760 }
 761 //---------------------------------------------------------------------------
 762 int str2x(const std::string & str, uint32_t & x)
 763 {
 764 x = static_cast<uint32_t>(strtoul(str.c_str(), NULL, 10));
 765
 766 if (errno == ERANGE)
 767     return -1;
 768
 769 return 0;
 770 }
 771 #ifndef WIN32
 772 //---------------------------------------------------------------------------
 773 int str2x(const std::string & str, int64_t & x)
 774 {
 775 x = strtoll(str.c_str(), NULL, 10);
 776
 777 if (errno == ERANGE)
 778     return -1;
 779
 780 return 0;
 781 }
 782 //---------------------------------------------------------------------------
 783 int str2x(const std::string & str, uint64_t & x)
 784 {
 785 x = strtoull(str.c_str(), NULL, 10);
 786
 787 if (errno == ERANGE)
 788     return -1;
 789
 790 return 0;
 791 }
 792 #endif
 793 //---------------------------------------------------------------------------
 794 const std::string & x2str(uint32_t x, std::string & s)
 795 {
 796 return unsigned2str(x, s);
 797 }
 798 //---------------------------------------------------------------------------
 799 const std::string & x2str(uint64_t x, std::string & s)
 800 {
 801 return unsigned2str(x, s);
 802 }
 803 //---------------------------------------------------------------------------
 804 const std::string & x2str(double x, std::string & s)
 805 {
 806 char buf[256];
 807 snprintf(buf, sizeof(buf), "%f", x);
 808 s = buf;
 809 return s;
 810 }
 811 //---------------------------------------------------------------------------
 812 std::string & TrimL(std::string & val)
 813 {
 814 size_t pos = val.find_first_not_of(" \t");
 815 if (pos == std::string::npos)
 816     {
 817     val.erase(val.begin(), val.end());
 818     }
 819 else
 820     {
 821     val.erase(0, pos);
 822     }
 823 return val;
 824 }
 825 //---------------------------------------------------------------------------
 826 std::string & TrimR(std::string & val)
 827 {
 828 size_t pos = val.find_last_not_of(" \t");
 829 if (pos != std::string::npos)
 830     {
 831     val.erase(pos + 1);
 832     }
 833 return val;
 834 }
 835 //---------------------------------------------------------------------------
 836 std::string & Trim(std::string & val)
 837 {
 838 return TrimR(TrimL(val));
 839 }
 840 //---------------------------------------------------------------------------
 841 std::string Trim(const std::string & val)
 842 {
 843 std::string res(val);
 844 return TrimR(TrimL(res));
 845 }
 846 //---------------------------------------------------------------------------
 847 std::string ToLower(std::string value)
 848 {
 849     std::transform(value.begin(), value.end(), value.begin(), ::tolower);
 850     return value;
 851 }
 852 //---------------------------------------------------------------------------
 853 std::string ToUpper(std::string value)
 854 {
 855     std::transform(value.begin(), value.end(), value.begin(), ::toupper);
 856     return value;
 857 }
 858 //---------------------------------------------------------------------------
 859 #ifdef WIN32
 860 static int is_leap(unsigned y)
 861 {
 862     y += 1900;
 863     return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
 864 }
 865 #endif
 866 //---------------------------------------------------------------------------
 867
 868 time_t stg_timegm(struct tm * brokenTime)
 869 {
 870 #ifdef WIN32
 871 static const unsigned ndays[2][12] ={
 872     {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
 873     {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
 874 time_t res = 0;
 875 for (int i = 70; i < brokenTime->tm_year; ++i)
 876     res += is_leap(i) ? 366 : 365;
 877 for (int i = 0; i < brokenTime->tm_mon; ++i)
 878     res += ndays[is_leap(brokenTime->tm_year)][i];
 879 res += brokenTime->tm_mday - 1;
 880 res *= 24;
 881 res += brokenTime->tm_hour;
 882 res *= 60;
 883 res += brokenTime->tm_min;
 884 res *= 60;
 885 res += brokenTime->tm_sec;
 886 return res;
 887 #else
 888 #ifdef HAVE_TIMEGM
 889 return timegm(brokenTime);
 890 #else
 891 time_t ret;
 892 char *tz;
 893 tz = getenv("TZ");
 894 setenv("TZ", "", 1);
 895 tzset();
 896 ret = mktime(brokenTime);
 897 if (tz)
 898     setenv("TZ", tz, 1);
 899 else
 900     unsetenv("TZ");
 901 tzset();
 902 return ret;
 903 #endif // HAVE_TIMEGM
 904 #endif // WIN32
 905 }
 906 //---------------------------------------------------------------------------
 907 std::string IconvString(const std::string & source,
 908                         const std::string & from,
 909                         const std::string & to)
 910 {
 911 if (source.empty())
 912     return std::string();
 913
 914 size_t inBytesLeft = source.length() + 1;
 915 size_t outBytesLeft = source.length() * 2 + 1;
 916
 917 char * inBuf = new char[inBytesLeft];
 918 char * outBuf = new char[outBytesLeft];
 919
 920 strncpy(inBuf, source.c_str(), source.length());
 921
 922 inBuf[source.length()] = 0;
 923
 924 #if defined(CONST_ICONV)
 925 const char * srcPos = inBuf;
 926 #else
 927 char * srcPos = inBuf;
 928 #endif
 929 char * dstPos = outBuf;
 930
 931 iconv_t handle = iconv_open(to.c_str(),
 932                             from.c_str());
 933
 934 if (handle == iconv_t(-1))
 935     {
 936     if (errno == EINVAL)
 937         {
 938         printfd(__FILE__, "IconvString(): iconv from %s to %s failed\n", from.c_str(), to.c_str());
 939         delete[] outBuf;
 940         delete[] inBuf;
 941         return source;
 942         }
 943     else
 944         printfd(__FILE__, "IconvString(): iconv_open error\n");
 945
 946     delete[] outBuf;
 947     delete[] inBuf;
 948     return source;
 949     }
 950
 951 size_t res = iconv(handle,
 952                    &srcPos, &inBytesLeft,
 953                    &dstPos, &outBytesLeft);
 954
 955 if (res == size_t(-1))
 956     {
 957     printfd(__FILE__, "IconvString(): '%s'\n", strerror(errno));
 958
 959     iconv_close(handle);
 960     delete[] outBuf;
 961     delete[] inBuf;
 962     return source;
 963     }
 964
 965 dstPos = 0;
 966
 967 std::string dst(outBuf);
 968
 969 iconv_close(handle);
 970
 971 delete[] outBuf;
 972 delete[] inBuf;
 973
 974 return dst;
 975 }
 976
 977 int ParseYesNo(const std::string & str, bool * val)
 978 {
 979 if (0 == strncasecmp(str.c_str(), "yes", 3))
 980     {
 981     *val = true;
 982     return 0;
 983     }
 984
 985 if (0 == strncasecmp(str.c_str(), "no", 2))
 986     {
 987     *val = false;
 988     return 0;
 989     }
 990
 991 return -1;
 992 }
 993
 994 int ParseInt(const std::string & str, int * val)
 995 {
 996 if (str2x<int>(str, *val))
 997     return -1;
 998 return 0;
 999 }
1000
1001 int ParseUnsigned(const std::string & str, unsigned * val)
1002 {
1003 if (str2x<unsigned>(str, *val))
1004     return -1;
1005 return 0;
1006 }
1007
1008 int ParseIntInRange(const std::string & str, int min, int max, int * val)
1009 {
1010 if (ParseInt(str, val) != 0)
1011     return -1;
1012
1013 if (*val < min || *val > max)
1014     return -1;
1015
1016 return 0;
1017 }
1018
1019 int ParseUnsignedInRange(const std::string & str, unsigned min,
1020                          unsigned max, unsigned * val)
1021 {
1022 if (ParseUnsigned(str, val) != 0)
1023     return -1;
1024
1025 if (*val < min || *val > max)
1026     return -1;
1027
1028 return 0;
1029 }
1030
1031 bool WaitPackets(int sd)
1032 {
1033 fd_set rfds;
1034 FD_ZERO(&rfds);
1035 FD_SET(sd, &rfds);
1036
1037 struct timeval tv;
1038 tv.tv_sec = 0;
1039 tv.tv_usec = 500000;
1040
1041 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
1042 if (res == -1) // Error
1043     {
1044     if (errno != EINTR)
1045         printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
1046     return false;
1047     }
1048
1049 if (res == 0) // Timeout
1050     return false;
1051
1052 return true;
1053 }
1054
1055 bool ReadAll(int sd, void * dest, size_t size)
1056 {
1057 size_t done = 0;
1058 char * ptr = static_cast<char *>(dest);
1059 while (done < size)
1060     {
1061     if (!WaitPackets(sd))
1062         return false;
1063     ssize_t res = read(sd, ptr + done, size - done);
1064     if (res < 0)
1065         return false;
1066     if (res == 0)
1067         return true;
1068     done += res;
1069     }
1070 return true;
1071 }
1072
1073 bool WriteAll(int sd, const void * source, size_t size)
1074 {
1075 size_t done = 0;
1076 const char * ptr = static_cast<const char *>(source);
1077 while (done < size)
1078     {
1079     ssize_t res = write(sd, ptr + done, size - done);
1080     if (res <= 0)
1081         return false;
1082     done += res;
1083     }
1084 return true;
1085 }
1086
1087 std::string ToPrintable(const std::string & src)
1088 {
1089     std::string dest;
1090
1091     for (size_t i = 0; i < src.size(); ++i)
1092         if (std::isprint(src[i]))
1093             dest += src[i];
1094         else
1095             dest += "\\" + x2str(src[i]);
1096
1097     return dest;
1098 }