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