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