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.
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.
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
22 * Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
27 $Date: 2010/11/08 10:11:19 $
31 // For old and dub systems
33 #include <sys/types.h>
38 #include <sys/select.h>
43 #include <sys/socket.h>
44 #include <netinet/in.h>
45 #include <arpa/inet.h>
46 #include <sys/select.h>
60 #include "stg/common.h"
62 #ifndef INET_ADDRSTRLEN
63 # define INET_ADDRSTRLEN 16
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};
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};
140 //-----------------------------------------------------------------------------
141 const char * inet_ntop(int af, const void * src, char * dst, unsigned long length)
143 struct sockaddr_in addr;
144 addr.sin_family = af;
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))
153 //-----------------------------------------------------------------------------
154 int inet_pton(int af, const char * src, void * dst)
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);
162 struct sockaddr_in addr;
163 addr.sin_family = af;
165 addr.sin_addr.s_addr = 0;
166 int length = sizeof(addr);
167 if (WSAStringToAddressA(buf, af, 0, reinterpret_cast<struct sockaddr *>(&addr), &length))
172 memcpy(dst, &addr, sizeof(addr));
177 //-----------------------------------------------------------------------------
178 int strtodouble2(const char * s, double &a)
189 //-----------------------------------------------------------------------------
191 int printfd(const char * __file__, const char * fmt, ...)
193 int printfd(const char *, const char *, ...)
199 time_t t = time(NULL);
203 vsnprintf(buff, sizeof(buff), fmt, vl);
206 printf("%18s > %s > ", __file__, LogDate(t)+11);
212 //-----------------------------------------------------------------------------
213 int strprintf(std::string * str, const char * fmt, ...)
219 int n = vsnprintf(buff, sizeof(buff), fmt, vl);
226 //-----------------------------------------------------------------------------
227 const char *IntToKMG(int64_t a, int stat)
229 static const double K = 1024;
230 static const double M = 1024 * 1024;
231 static const double G = 1024 * 1024 * 1024;
239 sprintf(str, "%Ld", a);
241 sprintf(str, "%lld", a);
245 sprintf(str, "%.2f kb", value / K);
248 sprintf(str, "%.2f Mb", value / M);
253 sprintf(str, "%.2f Gb", value / G);
258 sprintf(str, "%.2f Gb", value / G);
263 sprintf(str, "%.2f Mb", value / M);
268 sprintf(str, "%.2f Mb", value / M);
272 sprintf(str, "%.2f kb", value / K);
277 //---------------------------------------------------------------------------
278 void KOIToWin(const char * s1, char * s2, int l)
280 for (int j = 0; j < l; j++)
282 unsigned char t = s1[j];
289 //---------------------------------------------------------------------------
290 void WinToKOI(const char * s1, char * s2, int l)
292 for (int j = 0; j < l; j++)
294 unsigned char t = s1[j];
301 //---------------------------------------------------------------------------
302 void KOIToWin(const std::string & s1, std::string * s2)
304 s2->erase(s2->begin(), s2->end());
305 s2->reserve(s1.length());
306 for (size_t j = 0; j < s1.length(); j++)
308 unsigned char t = s1[j];
309 s2->push_back(koi2win[t]);
312 //---------------------------------------------------------------------------
313 void WinToKOI(const std::string & s1, std::string * s2)
315 s2->erase(s2->begin(), s2->end());
316 s2->reserve(s1.length());
317 for (size_t j = 0; j < s1.length(); j++)
319 unsigned char t = s1[j];
320 s2->push_back(win2koi[t]);
323 //---------------------------------------------------------------------------
324 void Encode12str(std::string & dst, const std::string & src)
326 dst.erase(dst.begin(), dst.end());
327 for (size_t i = 0; i < src.length(); i++)
329 dst.push_back('a' + (src[i] & 0x0f));
330 dst.push_back('a' + ((src[i] & 0xf0) >> 4));
333 //---------------------------------------------------------------------------
334 void Decode21str(std::string & dst, const std::string & src)
336 dst.erase(dst.begin(), dst.end());
337 for (size_t i = 0; i < src.length() / 2; i++)
339 char c1 = src[i * 2];
340 char c2 = src[i * 2 + 1];
345 dst.push_back(static_cast<char>(c1 + (c2 << 4)));
348 //---------------------------------------------------------------------------
349 void Encode12(char * dst, const char * src, size_t srcLen)
351 for (size_t i = 0; i <= srcLen; i++)
353 char c1 = src[i] & 0x0f;
354 char c2 = (src[i] & 0xf0) >> 4;
364 //---------------------------------------------------------------------------
365 void Decode21(char * dst, const char * src)
367 for (size_t i = 0; ; i++)
372 char c1 = src[i * 2];
373 char c2 = src[i * 2 + 1];
378 dst[i] = static_cast<char>(c1 + (c2 << 4));
380 dst[strlen(src) / 2] = 0;
382 //---------------------------------------------------------------------------
383 int ParseIPString(const char * str, uint32_t * ips, int maxIP)
386 *Function Name:ParseIPString
389 ÓÔÒÏËÁ ÄÌÑ ÒÁÚÂÏÒÁ É ÍÁÓÓÉ× ËÕÄÁ ÚÁÎÏÓÉÔØ ÐÏÌÕÞÅÎÎÙÅ ÁÄÒÅÓÁ
392 îÁ ×ÈÏÄÅ ÄÏÌÖÎÁ ÂÙÔØ ÓÔÒÏËÁ ×ÉÄÁ "ip1,ip2,ip3" ÉÌÉ "*"
393 ÷ ÐÅÒ×ÏÍ ÓÌÕÞÁÅ × ÍÁÓÓÉ× ÚÁÎÏÓÑÔÓÑ ÒÁÚÏÂÒÁÎÎÙÅ ÁÄÒÅÓÁ.
394 åÓÌÉ ÉÈ ÍÅÎØÛÅ MAX_IP?, ÔÏ ÐÏÓÌÅÄÎÉÊ ÁÄÒÅÓ ÂÕÄÅÔ 255.255.255.255
395 åÓÌÉ ÓÔÒÏËÁ * , ÔÏ ÐÅÒ×ÁÙÊ ÁÄÒÅÓ ÂÕÄÅÔ 0.0.0.0, Ô.Å. ÌÀÂÏÊ
397 *Returns: 0 ÅÓÌÉ ×ÓÅ ïë
404 strncpy(p, str, 254);
407 memset(ips, 0xFF, sizeof(unsigned long) * maxIP);
409 if (str[0] == '*' && strlen(str) == 1)
415 for (int i = 0; i < maxIP; i++)
417 char * p1 = strtok(pp, ",\n ");
420 if (p1 == NULL && n == 0)// ÕËÁÚÁÔÅÌØ ÎÕÌØ É ÐÒÏÞÉÔÁÎÏ ÁÄÒÅÓÏ× ÔÏÖÅ ÎÏÌØ
431 if (inet_pton(AF_INET, p1, &in) != 1)
433 //printf("INADDR_NONE\n");
439 /*if (ips[n] == INADDR_NONE)
451 //-----------------------------------------------------------------------------
452 int DaysInCurrentMonth()
454 time_t t = time(NULL);
456 struct tm * lt = localtime(&t);
458 return DaysInMonth(lt->tm_year, lt->tm_mon);
460 //-----------------------------------------------------------------------------
461 int DaysInMonth(unsigned year, unsigned mon)
463 assert(mon < 12 && "Month number should be 0 - 11");
466 case 0: return 31; //jan
468 if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
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
482 return -1; // We will never reach here
484 //-----------------------------------------------------------------------------
488 æÕÎËÃÉÑ ×ÏÚ×ÒÁÝÁÅÔ ÎÁÉÍÅÎØÛÅÅ ÞÉÓÌÏ ËÒÁÔÎÏÅ 8-ÍÉ ÂÏÌØÛÅÅ ÉÌÉ ÒÁ×ÎÏÅ ÚÁÄÁÎÎÏÍÕ
493 return a + (8 - a % 8);
495 //-----------------------------------------------------------------------------
496 /*char * inet_ntostr(unsigned long ip)
498 struct in_addr addr = {ip};
499 return inet_ntoa(addr);
501 //-----------------------------------------------------------------------------
502 std::string inet_ntostring(uint32_t ip)
504 char buf[INET_ADDRSTRLEN + 1];
505 return inet_ntop(AF_INET, &ip, buf, INET_ADDRSTRLEN);
507 //-----------------------------------------------------------------------------
508 uint32_t inet_strington(const std::string & value)
512 if (inet_pton(AF_INET, value.c_str(), &result) <= 0)
517 //-----------------------------------------------------------------------------
518 std::string TimeToString(time_t time)
520 struct tm brokenTime;
522 brokenTime.tm_wday = 0;
523 brokenTime.tm_yday = 0;
524 brokenTime.tm_isdst = 0;
526 gmtime_r(&time, &brokenTime);
529 strftime(buf, 32, "%Y-%m-%d %H:%M:%S", &brokenTime);
533 //-----------------------------------------------------------------------------
534 int ParseTariffTimeStr(const char * str, int &h1, int &m1, int &h2, int &m2)
536 char hs1[10], ms1[10], hs2[10], ms2[10];
541 strncpy(ss, str, 48);
543 p1 = strtok(ss, "-");
549 p2 = strtok(NULL, "-");
555 p1 = strtok(s1, ":");
561 p2 = strtok(NULL, ":");
567 p1 = strtok(s2, ":");
573 p2 = strtok(NULL, ":");
579 if (str2x(hs1, h1) != 0)
582 if (str2x(ms1, m1) != 0)
585 if (str2x(hs2, h2) != 0)
588 if (str2x(ms2, m2) != 0)
593 /*//---------------------------------------------------------------------------
596 if (c >= '0' && c <= '9')
600 //-----------------------------------------------------------------------------
603 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
607 //-----------------------------------------------------------------------------
608 const char * LogDate(time_t t)
611 struct tm * tt = localtime(&t);
613 snprintf(s, 20, "%d-%s%d-%s%d %s%d:%s%d:%s%d",
615 tt->tm_mon + 1 < 10 ? "0" : "", tt->tm_mon + 1,
616 tt->tm_mday < 10 ? "0" : "", tt->tm_mday,
617 tt->tm_hour < 10 ? "0" : "", tt->tm_hour,
618 tt->tm_min < 10 ? "0" : "", tt->tm_min,
619 tt->tm_sec < 10 ? "0" : "", tt->tm_sec);
623 //-----------------------------------------------------------------------------
624 uint32_t CalcMask(uint32_t msk)
626 if (msk >= 32) return 0xFFffFFff;
627 if (msk == 0) return 0;
628 return htonl(0xFFffFFff << (32 - msk));
630 //---------------------------------------------------------------------------
631 void TouchFile(const std::string & fileName)
633 FILE * f = fopen(fileName.c_str(), "w");
637 //---------------------------------------------------------------------------
639 void EncodeStr(char * str, unsigned long serial, int useHDD)
641 int len = strlen(str);
645 char serial_c[sizeof(serial)];
646 memcpy(serial_c, &serial, sizeof(serial));
648 for (i = 0; i < len; i++)
654 str[i] = str[i]^serial_c[j%sizeof(serial)];
659 for (i = 0; i < 2*len; i++)
663 c1 = (str[i/2] >> 4);
669 c2 = (str[i/2] & 0x0f);
677 //---------------------------------------------------------------------------
678 void DecodeStr(char * str, unsigned long serial, int useHDD)
680 size_t len = strlen(str);
682 char serial_c[sizeof(serial)];
683 memcpy(serial_c, &serial, sizeof(serial));
685 for (size_t i = 0; i < len; i += 2)
687 char c1 = (str[i] - 50);
688 char c2 = (str[i+1] - 50)<<4;
691 for (size_t i = 0; i < len/2; i++)
694 strdc[i] = strdc[i]^49;
697 strdc[i] = strdc[i]^serial_c[j%sizeof(serial)];
704 //---------------------------------------------------------------------------
706 void SwapBytes(uint16_t & value)
708 value = static_cast<uint16_t>((value >> 8) |
711 //---------------------------------------------------------------------------
712 void SwapBytes(uint32_t & value)
714 value = static_cast<uint32_t>((value >> 24) |
715 ((value << 8) & 0x00FF0000L) |
716 ((value >> 8) & 0x0000FF00L) |
719 //---------------------------------------------------------------------------
720 void SwapBytes(uint64_t & value)
722 value = static_cast<uint64_t>((value >> 56) |
723 ((value << 40) & 0x00FF000000000000LL) |
724 ((value << 24) & 0x0000FF0000000000LL) |
725 ((value << 8) & 0x000000FF00000000LL) |
726 ((value >> 8) & 0x00000000FF000000LL) |
727 ((value >> 24) & 0x0000000000FF0000LL) |
728 ((value >> 40) & 0x000000000000FF00LL) |
731 //---------------------------------------------------------------------------
732 void SwapBytes(int16_t & value)
734 uint16_t temp = value;
738 //---------------------------------------------------------------------------
739 void SwapBytes(int32_t & value)
741 uint32_t temp = value;
745 //---------------------------------------------------------------------------
746 void SwapBytes(int64_t & value)
748 uint64_t temp = value;
752 //---------------------------------------------------------------------------
753 std::string formatTime(time_t ts)
756 struct tm brokenTime;
758 brokenTime.tm_wday = 0;
759 brokenTime.tm_yday = 0;
760 brokenTime.tm_isdst = 0;
762 gmtime_r(&ts, &brokenTime);
764 strftime(buf, 32, "%Y-%m-%d %H:%M:%S", &brokenTime);
768 //---------------------------------------------------------------------------
769 time_t readTime(const std::string & ts)
771 if (ts == "0000-00-00 00:00:00")
774 struct tm brokenTime;
776 brokenTime.tm_wday = 0;
777 brokenTime.tm_yday = 0;
778 brokenTime.tm_isdst = 0;
780 stg_strptime(ts.c_str(), "%Y-%m-%d %H:%M:%S", &brokenTime);
782 return stg_timegm(&brokenTime);
784 //---------------------------------------------------------------------------
785 int str2x(const std::string & str, int32_t & x)
787 x = static_cast<int32_t>(strtol(str.c_str(), NULL, 10));
794 //---------------------------------------------------------------------------
795 int str2x(const std::string & str, uint32_t & x)
797 x = static_cast<uint32_t>(strtoul(str.c_str(), NULL, 10));
805 //---------------------------------------------------------------------------
806 int str2x(const std::string & str, int64_t & x)
808 x = strtoll(str.c_str(), NULL, 10);
815 //---------------------------------------------------------------------------
816 int str2x(const std::string & str, uint64_t & x)
818 x = strtoull(str.c_str(), NULL, 10);
826 //---------------------------------------------------------------------------
827 std::string & TrimL(std::string & val)
829 size_t pos = val.find_first_not_of(" \t");
830 if (pos == std::string::npos)
832 val.erase(val.begin(), val.end());
840 //---------------------------------------------------------------------------
841 std::string & TrimR(std::string & val)
843 size_t pos = val.find_last_not_of(" \t");
844 if (pos != std::string::npos)
850 //---------------------------------------------------------------------------
851 std::string & Trim(std::string & val)
853 return TrimR(TrimL(val));
855 //---------------------------------------------------------------------------
856 std::string Trim(const std::string & val)
858 std::string res(val);
859 return TrimR(TrimL(res));
861 //---------------------------------------------------------------------------
862 std::string ToLower(std::string value)
864 std::transform(value.begin(), value.end(), value.begin(), ::tolower);
867 //---------------------------------------------------------------------------
868 std::string ToUpper(std::string value)
870 std::transform(value.begin(), value.end(), value.begin(), ::toupper);
873 //---------------------------------------------------------------------------
875 static int is_leap(unsigned y)
878 return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
881 //---------------------------------------------------------------------------
883 time_t stg_timegm(struct tm * brokenTime)
886 static const unsigned ndays[2][12] ={
887 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
888 {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
890 for (int i = 70; i < brokenTime->tm_year; ++i)
891 res += is_leap(i) ? 366 : 365;
892 for (int i = 0; i < brokenTime->tm_mon; ++i)
893 res += ndays[is_leap(brokenTime->tm_year)][i];
894 res += brokenTime->tm_mday - 1;
896 res += brokenTime->tm_hour;
898 res += brokenTime->tm_min;
900 res += brokenTime->tm_sec;
904 return timegm(brokenTime);
911 ret = mktime(brokenTime);
918 #endif // HAVE_TIMEGM
921 //---------------------------------------------------------------------------
922 std::string IconvString(const std::string & source,
923 const std::string & from,
924 const std::string & to)
927 return std::string();
929 size_t inBytesLeft = source.length() + 1;
930 size_t outBytesLeft = source.length() * 2 + 1;
932 char * inBuf = new char[inBytesLeft];
933 char * outBuf = new char[outBytesLeft];
935 strncpy(inBuf, source.c_str(), source.length());
937 inBuf[source.length()] = 0;
939 #if defined(CONST_ICONV)
940 const char * srcPos = inBuf;
942 char * srcPos = inBuf;
944 char * dstPos = outBuf;
946 iconv_t handle = iconv_open(to.c_str(),
949 if (handle == iconv_t(-1))
953 printfd(__FILE__, "IconvString(): iconv from %s to %s failed\n", from.c_str(), to.c_str());
959 printfd(__FILE__, "IconvString(): iconv_open error\n");
966 size_t res = iconv(handle,
967 &srcPos, &inBytesLeft,
968 &dstPos, &outBytesLeft);
970 if (res == size_t(-1))
972 printfd(__FILE__, "IconvString(): '%s'\n", strerror(errno));
982 std::string dst(outBuf);
992 int ParseYesNo(const std::string & str, bool * val)
994 if (0 == strncasecmp(str.c_str(), "yes", 3))
1000 if (0 == strncasecmp(str.c_str(), "no", 2))
1009 int ParseInt(const std::string & str, int * val)
1011 if (str2x<int>(str, *val))
1016 int ParseUnsigned(const std::string & str, unsigned * val)
1018 if (str2x<unsigned>(str, *val))
1023 int ParseIntInRange(const std::string & str, int min, int max, int * val)
1025 if (ParseInt(str, val) != 0)
1028 if (*val < min || *val > max)
1034 int ParseUnsignedInRange(const std::string & str, unsigned min,
1035 unsigned max, unsigned * val)
1037 if (ParseUnsigned(str, val) != 0)
1040 if (*val < min || *val > max)
1046 bool WaitPackets(int sd)
1054 tv.tv_usec = 500000;
1056 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
1057 if (res == -1) // Error
1060 printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
1064 if (res == 0) // Timeout
1070 bool ReadAll(int sd, void * dest, size_t size)
1073 char * ptr = static_cast<char *>(dest);
1076 if (!WaitPackets(sd))
1078 ssize_t res = read(sd, ptr + done, size - done);
1088 bool WriteAll(int sd, const void * source, size_t size)
1091 const char * ptr = static_cast<const char *>(source);
1094 ssize_t res = write(sd, ptr + done, size - done);
1102 std::string ToPrintable(const std::string & src)
1106 for (size_t i = 0; i < src.size(); ++i)
1107 if (std::isprint(src[i]))
1110 dest += "\\" + std::to_string(src[i]);
1115 uid_t str2uid(const std::string& name)
1117 const passwd* res = getpwnam(name.c_str());
1123 gid_t str2gid(const std::string& name)
1125 const group* res = getgrnam(name.c_str());
1131 mode_t str2mode(const std::string& name)
1133 if (name.length() < 3 || name.length() > 4)
1136 if (name.length() == 4 && name[0] != '0')
1140 for (size_t i = 0; i < name.length(); ++i)
1142 if (name[i] > '7' || name[i] < '0')
1144 res = (res << 3) + (name[i] - '0');