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>
37 #include <sys/select.h>
42 #include <sys/socket.h>
43 #include <netinet/in.h>
44 #include <arpa/inet.h>
45 #include <sys/select.h>
59 #include "stg/common.h"
61 #ifndef INET_ADDRSTRLEN
62 # define INET_ADDRSTRLEN 16
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};
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};
139 //-----------------------------------------------------------------------------
140 const char * inet_ntop(int af, const void * src, char * dst, unsigned long length)
142 struct sockaddr_in addr;
143 addr.sin_family = af;
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))
152 //-----------------------------------------------------------------------------
153 int inet_pton(int af, const char * src, void * dst)
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);
161 struct sockaddr_in addr;
162 addr.sin_family = af;
164 addr.sin_addr.s_addr = 0;
165 int length = sizeof(addr);
166 if (WSAStringToAddressA(buf, af, 0, reinterpret_cast<struct sockaddr *>(&addr), &length))
171 memcpy(dst, &addr, sizeof(addr));
176 //-----------------------------------------------------------------------------
177 int strtodouble2(const char * s, double &a)
188 //-----------------------------------------------------------------------------
190 int printfd(const char * __file__, const char * fmt, ...)
192 int printfd(const char *, const char *, ...)
198 time_t t = time(NULL);
202 vsnprintf(buff, sizeof(buff), fmt, vl);
205 printf("%18s > %s > ", __file__, LogDate(t)+11);
211 //-----------------------------------------------------------------------------
212 int strprintf(std::string * str, const char * fmt, ...)
218 int n = vsnprintf(buff, sizeof(buff), fmt, vl);
225 //-----------------------------------------------------------------------------
226 const char *IntToKMG(int64_t a, int stat)
228 static const double K = 1024;
229 static const double M = 1024 * 1024;
230 static const double G = 1024 * 1024 * 1024;
238 sprintf(str, "%Ld", a);
240 sprintf(str, "%lld", a);
244 sprintf(str, "%.2f kb", value / K);
247 sprintf(str, "%.2f Mb", value / M);
252 sprintf(str, "%.2f Gb", value / G);
257 sprintf(str, "%.2f Gb", value / G);
262 sprintf(str, "%.2f Mb", value / M);
267 sprintf(str, "%.2f Mb", value / M);
271 sprintf(str, "%.2f kb", value / K);
276 //---------------------------------------------------------------------------
277 void KOIToWin(const char * s1, char * s2, int l)
279 for (int j = 0; j < l; j++)
281 unsigned char t = s1[j];
288 //---------------------------------------------------------------------------
289 void WinToKOI(const char * s1, char * s2, int l)
291 for (int j = 0; j < l; j++)
293 unsigned char t = s1[j];
300 //---------------------------------------------------------------------------
301 void KOIToWin(const std::string & s1, std::string * s2)
303 s2->erase(s2->begin(), s2->end());
304 s2->reserve(s1.length());
305 for (int j = 0; j < (int)s1.length(); j++)
307 unsigned char t = s1[j];
308 s2->push_back(koi2win[t]);
311 //---------------------------------------------------------------------------
312 void WinToKOI(const std::string & s1, std::string * s2)
314 s2->erase(s2->begin(), s2->end());
315 s2->reserve(s1.length());
316 for (int j = 0; j < (int)s1.length(); j++)
318 unsigned char t = s1[j];
319 s2->push_back(win2koi[t]);
322 //---------------------------------------------------------------------------
323 void Encode12str(std::string & dst, const std::string & src)
325 dst.erase(dst.begin(), dst.end());
326 for (size_t i = 0; i < src.length(); i++)
328 dst.push_back('a' + (src[i] & 0x0f));
329 dst.push_back('a' + ((src[i] & 0xf0) >> 4));
332 //---------------------------------------------------------------------------
333 void Decode21str(std::string & dst, const std::string & src)
335 dst.erase(dst.begin(), dst.end());
336 for (size_t i = 0; i < src.length() / 2; i++)
338 char c1 = src[i * 2];
339 char c2 = src[i * 2 + 1];
344 dst.push_back(static_cast<char>(c1 + (c2 << 4)));
347 //---------------------------------------------------------------------------
348 void Encode12(char * dst, const char * src, size_t srcLen)
350 for (size_t i = 0; i <= srcLen; i++)
352 char c1 = src[i] & 0x0f;
353 char c2 = (src[i] & 0xf0) >> 4;
363 //---------------------------------------------------------------------------
364 void Decode21(char * dst, const char * src)
366 for (size_t i = 0; ; i++)
371 char c1 = src[i * 2];
372 char c2 = src[i * 2 + 1];
377 dst[i] = static_cast<char>(c1 + (c2 << 4));
379 dst[strlen(src) / 2] = 0;
381 //---------------------------------------------------------------------------
382 int ParseIPString(const char * str, uint32_t * ips, int maxIP)
385 *Function Name:ParseIPString
388 ÓÔÒÏËÁ ÄÌÑ ÒÁÚÂÏÒÁ É ÍÁÓÓÉ× ËÕÄÁ ÚÁÎÏÓÉÔØ ÐÏÌÕÞÅÎÎÙÅ ÁÄÒÅÓÁ
391 îÁ ×ÈÏÄÅ ÄÏÌÖÎÁ ÂÙÔØ ÓÔÒÏËÁ ×ÉÄÁ "ip1,ip2,ip3" ÉÌÉ "*"
392 ÷ ÐÅÒ×ÏÍ ÓÌÕÞÁÅ × ÍÁÓÓÉ× ÚÁÎÏÓÑÔÓÑ ÒÁÚÏÂÒÁÎÎÙÅ ÁÄÒÅÓÁ.
393 åÓÌÉ ÉÈ ÍÅÎØÛÅ MAX_IP?, ÔÏ ÐÏÓÌÅÄÎÉÊ ÁÄÒÅÓ ÂÕÄÅÔ 255.255.255.255
394 åÓÌÉ ÓÔÒÏËÁ * , ÔÏ ÐÅÒ×ÁÙÊ ÁÄÒÅÓ ÂÕÄÅÔ 0.0.0.0, Ô.Å. ÌÀÂÏÊ
396 *Returns: 0 ÅÓÌÉ ×ÓÅ ïë
403 strncpy(p, str, 254);
406 memset(ips, 0xFF, sizeof(unsigned long) * maxIP);
408 if (str[0] == '*' && strlen(str) == 1)
414 for (int i = 0; i < maxIP; i++)
416 char * p1 = strtok(pp, ",\n ");
419 if (p1 == NULL && n == 0)// ÕËÁÚÁÔÅÌØ ÎÕÌØ É ÐÒÏÞÉÔÁÎÏ ÁÄÒÅÓÏ× ÔÏÖÅ ÎÏÌØ
430 if (inet_pton(AF_INET, p1, &in) != 1)
432 //printf("INADDR_NONE\n");
438 /*if (ips[n] == INADDR_NONE)
450 //-----------------------------------------------------------------------------
451 int DaysInCurrentMonth()
453 time_t t = time(NULL);
455 struct tm * lt = localtime(&t);
457 return DaysInMonth(lt->tm_year, lt->tm_mon);
459 //-----------------------------------------------------------------------------
460 int DaysInMonth(unsigned year, unsigned mon)
462 assert(mon < 12 && "Month number should be 0 - 11");
465 case 0: return 31; //jan
467 if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
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
481 return -1; // We will never reach here
483 //-----------------------------------------------------------------------------
487 æÕÎËÃÉÑ ×ÏÚ×ÒÁÝÁÅÔ ÎÁÉÍÅÎØÛÅÅ ÞÉÓÌÏ ËÒÁÔÎÏÅ 8-ÍÉ ÂÏÌØÛÅÅ ÉÌÉ ÒÁ×ÎÏÅ ÚÁÄÁÎÎÏÍÕ
492 return a + (8 - a % 8);
494 //-----------------------------------------------------------------------------
495 /*char * inet_ntostr(unsigned long ip)
497 struct in_addr addr = {ip};
498 return inet_ntoa(addr);
500 //-----------------------------------------------------------------------------
501 std::string inet_ntostring(uint32_t ip)
503 char buf[INET_ADDRSTRLEN + 1];
504 return inet_ntop(AF_INET, &ip, buf, INET_ADDRSTRLEN);
506 //-----------------------------------------------------------------------------
507 uint32_t inet_strington(const std::string & value)
511 if (inet_pton(AF_INET, value.c_str(), &result) <= 0)
516 //-----------------------------------------------------------------------------
517 std::string TimeToString(time_t time)
519 struct tm brokenTime;
521 brokenTime.tm_wday = 0;
522 brokenTime.tm_yday = 0;
523 brokenTime.tm_isdst = 0;
525 gmtime_r(&time, &brokenTime);
528 strftime(buf, 32, "%Y-%m-%d %H:%M:%S", &brokenTime);
532 //-----------------------------------------------------------------------------
533 int ParseTariffTimeStr(const char * str, int &h1, int &m1, int &h2, int &m2)
535 char hs1[10], ms1[10], hs2[10], ms2[10];
540 strncpy(ss, str, 48);
542 p1 = strtok(ss, "-");
548 p2 = strtok(NULL, "-");
554 p1 = strtok(s1, ":");
560 p2 = strtok(NULL, ":");
566 p1 = strtok(s2, ":");
572 p2 = strtok(NULL, ":");
578 if (str2x(hs1, h1) != 0)
581 if (str2x(ms1, m1) != 0)
584 if (str2x(hs2, h2) != 0)
587 if (str2x(ms2, m2) != 0)
592 /*//---------------------------------------------------------------------------
595 if (c >= '0' && c <= '9')
599 //-----------------------------------------------------------------------------
602 if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'))
606 //-----------------------------------------------------------------------------
607 const char * LogDate(time_t t)
610 struct tm * tt = localtime(&t);
612 snprintf(s, 20, "%d-%s%d-%s%d %s%d:%s%d:%s%d",
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);
622 //-----------------------------------------------------------------------------
623 uint32_t CalcMask(uint32_t msk)
625 if (msk >= 32) return 0xFFffFFff;
626 if (msk == 0) return 0;
627 return htonl(0xFFffFFff << (32 - msk));
629 //---------------------------------------------------------------------------
630 void TouchFile(const std::string & fileName)
632 FILE * f = fopen(fileName.c_str(), "w");
636 //---------------------------------------------------------------------------
638 void EncodeStr(char * str, unsigned long serial, int useHDD)
640 int len = strlen(str);
644 char serial_c[sizeof(serial)];
645 memcpy(serial_c, &serial, sizeof(serial));
647 for (i = 0; i < len; i++)
653 str[i] = str[i]^serial_c[j%sizeof(serial)];
658 for (i = 0; i < 2*len; i++)
662 c1 = (str[i/2] >> 4);
668 c2 = (str[i/2] & 0x0f);
676 //---------------------------------------------------------------------------
677 void DecodeStr(char * str, unsigned long serial, int useHDD)
679 size_t len = strlen(str);
681 char serial_c[sizeof(serial)];
682 memcpy(serial_c, &serial, sizeof(serial));
684 for (size_t i = 0; i < len; i += 2)
686 char c1 = (str[i] - 50);
687 char c2 = (str[i+1] - 50)<<4;
690 for (size_t i = 0; i < len/2; i++)
693 strdc[i] = strdc[i]^49;
696 strdc[i] = strdc[i]^serial_c[j%sizeof(serial)];
703 //---------------------------------------------------------------------------
705 void SwapBytes(uint16_t & value)
707 value = static_cast<uint16_t>((value >> 8) |
710 //---------------------------------------------------------------------------
711 void SwapBytes(uint32_t & value)
713 value = static_cast<uint32_t>((value >> 24) |
714 ((value << 8) & 0x00FF0000L) |
715 ((value >> 8) & 0x0000FF00L) |
718 //---------------------------------------------------------------------------
719 void SwapBytes(uint64_t & value)
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) |
730 //---------------------------------------------------------------------------
731 void SwapBytes(int16_t & value)
733 uint16_t temp = value;
737 //---------------------------------------------------------------------------
738 void SwapBytes(int32_t & value)
740 uint32_t temp = value;
744 //---------------------------------------------------------------------------
745 void SwapBytes(int64_t & value)
747 uint64_t temp = value;
751 //---------------------------------------------------------------------------
752 std::string formatTime(time_t ts)
755 struct tm brokenTime;
757 brokenTime.tm_wday = 0;
758 brokenTime.tm_yday = 0;
759 brokenTime.tm_isdst = 0;
761 gmtime_r(&ts, &brokenTime);
763 strftime(buf, 32, "%Y-%m-%d %H:%M:%S", &brokenTime);
767 //---------------------------------------------------------------------------
768 time_t readTime(const std::string & ts)
770 if (ts == "0000-00-00 00:00:00")
773 struct tm brokenTime;
775 brokenTime.tm_wday = 0;
776 brokenTime.tm_yday = 0;
777 brokenTime.tm_isdst = 0;
779 stg_strptime(ts.c_str(), "%Y-%m-%d %H:%M:%S", &brokenTime);
781 return stg_timegm(&brokenTime);
783 //---------------------------------------------------------------------------
784 int str2x(const std::string & str, int32_t & x)
786 x = static_cast<int32_t>(strtol(str.c_str(), NULL, 10));
793 //---------------------------------------------------------------------------
794 int str2x(const std::string & str, uint32_t & x)
796 x = static_cast<uint32_t>(strtoul(str.c_str(), NULL, 10));
804 //---------------------------------------------------------------------------
805 int str2x(const std::string & str, int64_t & x)
807 x = strtoll(str.c_str(), NULL, 10);
814 //---------------------------------------------------------------------------
815 int str2x(const std::string & str, uint64_t & x)
817 x = strtoull(str.c_str(), NULL, 10);
825 //---------------------------------------------------------------------------
826 const std::string & x2str(uint32_t x, std::string & s)
828 return unsigned2str(x, s);
830 //---------------------------------------------------------------------------
831 const std::string & x2str(uint64_t x, std::string & s)
833 return unsigned2str(x, s);
835 //---------------------------------------------------------------------------
836 const std::string & x2str(double x, std::string & s)
839 snprintf(buf, sizeof(buf), "%f", x);
843 //---------------------------------------------------------------------------
844 std::string & TrimL(std::string & val)
846 size_t pos = val.find_first_not_of(" \t");
847 if (pos == std::string::npos)
849 val.erase(val.begin(), val.end());
857 //---------------------------------------------------------------------------
858 std::string & TrimR(std::string & val)
860 size_t pos = val.find_last_not_of(" \t");
861 if (pos != std::string::npos)
867 //---------------------------------------------------------------------------
868 std::string & Trim(std::string & val)
870 return TrimR(TrimL(val));
872 //---------------------------------------------------------------------------
873 std::string Trim(const std::string & val)
875 std::string res(val);
876 return TrimR(TrimL(res));
878 //---------------------------------------------------------------------------
879 std::string ToLower(std::string value)
881 std::transform(value.begin(), value.end(), value.begin(), ::tolower);
884 //---------------------------------------------------------------------------
885 std::string ToUpper(std::string value)
887 std::transform(value.begin(), value.end(), value.begin(), ::toupper);
890 //---------------------------------------------------------------------------
892 static int is_leap(unsigned y)
895 return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
898 //---------------------------------------------------------------------------
900 time_t stg_timegm(struct tm * brokenTime)
903 static const unsigned ndays[2][12] ={
904 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
905 {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
907 for (int i = 70; i < brokenTime->tm_year; ++i)
908 res += is_leap(i) ? 366 : 365;
909 for (int i = 0; i < brokenTime->tm_mon; ++i)
910 res += ndays[is_leap(brokenTime->tm_year)][i];
911 res += brokenTime->tm_mday - 1;
913 res += brokenTime->tm_hour;
915 res += brokenTime->tm_min;
917 res += brokenTime->tm_sec;
921 return timegm(brokenTime);
928 ret = mktime(brokenTime);
935 #endif // HAVE_TIMEGM
938 //---------------------------------------------------------------------------
939 std::string IconvString(const std::string & source,
940 const std::string & from,
941 const std::string & to)
944 return std::string();
946 size_t inBytesLeft = source.length() + 1;
947 size_t outBytesLeft = source.length() * 2 + 1;
949 char * inBuf = new char[inBytesLeft];
950 char * outBuf = new char[outBytesLeft];
952 strncpy(inBuf, source.c_str(), source.length());
954 inBuf[source.length()] = 0;
956 #if defined(CONST_ICONV)
957 const char * srcPos = inBuf;
959 char * srcPos = inBuf;
961 char * dstPos = outBuf;
963 iconv_t handle = iconv_open(to.c_str(),
966 if (handle == iconv_t(-1))
970 printfd(__FILE__, "IconvString(): iconv from %s to %s failed\n", from.c_str(), to.c_str());
976 printfd(__FILE__, "IconvString(): iconv_open error\n");
983 size_t res = iconv(handle,
984 &srcPos, &inBytesLeft,
985 &dstPos, &outBytesLeft);
987 if (res == size_t(-1))
989 printfd(__FILE__, "IconvString(): '%s'\n", strerror(errno));
999 std::string dst(outBuf);
1001 iconv_close(handle);
1009 int ParseYesNo(const std::string & str, bool * val)
1011 if (0 == strncasecmp(str.c_str(), "yes", 3))
1017 if (0 == strncasecmp(str.c_str(), "no", 2))
1026 int ParseInt(const std::string & str, int * val)
1028 if (str2x<int>(str, *val))
1033 int ParseUnsigned(const std::string & str, unsigned * val)
1035 if (str2x<unsigned>(str, *val))
1040 int ParseIntInRange(const std::string & str, int min, int max, int * val)
1042 if (ParseInt(str, val) != 0)
1045 if (*val < min || *val > max)
1051 int ParseUnsignedInRange(const std::string & str, unsigned min,
1052 unsigned max, unsigned * val)
1054 if (ParseUnsigned(str, val) != 0)
1057 if (*val < min || *val > max)
1063 bool WaitPackets(int sd)
1071 tv.tv_usec = 500000;
1073 int res = select(sd + 1, &rfds, NULL, NULL, &tv);
1074 if (res == -1) // Error
1077 printfd(__FILE__, "Error on select: '%s'\n", strerror(errno));
1081 if (res == 0) // Timeout
1087 bool ReadAll(int sd, void * dest, size_t size)
1090 char * ptr = static_cast<char *>(dest);
1093 if (!WaitPackets(sd))
1095 ssize_t res = read(sd, ptr + done, size - done);
1105 bool WriteAll(int sd, const void * source, size_t size)
1108 const char * ptr = static_cast<const char *>(source);
1111 ssize_t res = write(sd, ptr + done, size - done);
1119 std::string ToPrintable(const std::string & src)
1123 for (size_t i = 0; i < src.size(); ++i)
1124 if (std::isprint(src[i]))
1127 dest += "\\" + x2str(src[i]);