Changes to migrate to 32 bit arch (armv7l)
[anna.git] / source / core / functions.cpp
1 // ANNA - Anna is Not Nothingness Anymore                                                         //
2 //                                                                                                //
3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
4 //                                                                                                //
5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
7
8
9 #include <stdarg.h>
10 #include <ctype.h>
11 #include <poll.h>
12 #include <time.h>
13 #include <sys/time.h>
14 #include <pthread.h>
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <sys/types.h>
18 #include <regex.h>
19 #include <sys/utsname.h>
20 #include <arpa/inet.h>
21 #include <sys/socket.h> // extraccion de IP del hostname
22 #include <netinet/in.h> // extraccion de IP del hostname
23 #include <netdb.h> // extraccion de IP del hostname
24 #include <unistd.h> // gethostname
25
26 #include <anna/core/functions.hpp>
27 #include <anna/core/DataBlock.hpp>
28 #include <anna/core/tracing/Logger.hpp>
29 #include <anna/core/util/Second.hpp>
30 #include <anna/core/util/Tokenizer.hpp>
31
32 #include <algorithm>
33
34
35 using namespace anna;
36 using namespace std;
37
38 #define PAGE_WIDTH_LENGTH      80
39
40 string functions::getVersion() throw() {
41   static const int version = ANNA_VERSION;
42   string result;
43   int mainVersion = (version & 0xff00) >> 8;
44   int subVersion = (version & 0xff);
45   char aux [32];
46   sprintf(aux, "%d.%d", mainVersion, subVersion);
47   result = aux;
48   return result += getArchitecture();
49 }
50
51 /*
52 (1) Solo coge los dos primeros digitos del numero de release
53 */
54 string functions::getArchitecture() throw() {
55   string result;
56   WHEN_MULTITHREAD(result = "/MT");
57   WHEN_SINGLETHREAD(result = "/ST");
58 #ifdef _DEBUG
59   result += "/D";
60 #else
61   result += "/O";
62 #endif
63 #ifdef _PROFILE
64   result += 'P';
65 #endif
66   struct utsname un;
67   uname(&un);
68   result += '/';
69   result += un.sysname;
70   result += ' ';
71   char* release = anna_strchr(un.release, '.');               // (1)
72
73   if(release != NULL)
74     if((release = anna_strchr(release + 1, '.')) != NULL)
75       * release = 0;
76
77   result += un.release;
78   result += " (";
79   result += un.machine;
80   result += ")";
81   return result;
82 }
83
84 string functions::asString(const int number)
85 throw() {
86   char aux [16];
87   sprintf(aux, "%d", number);
88   return string(aux);
89 }
90
91 string functions::asString(const S64 number)
92 throw() {
93   char aux [24];
94   //sprintf(aux, "%lld", number);
95   #ifdef __anna64__
96      sprintf (aux, "%ld", number);
97   #else
98      sprintf (aux, "%lld", number);
99   #endif
100   return string(aux);
101 }
102
103 string functions::asString(const unsigned int number)
104 throw() {
105   char aux [16];
106   sprintf(aux, "%u", number);
107   return string(aux);
108 }
109
110 string functions::asString(const U64 number)
111 throw() {
112   char aux [16];
113   //sprintf(aux, "%llu", number);
114   #ifdef __anna64__
115      sprintf (aux, "%lu", number);
116   #else
117      sprintf (aux, "%llu", number);
118   #endif
119   return string(aux);
120 }
121
122 string functions::asString(const float number, const char* format)
123 throw() {
124   char aux [64];
125   sprintf(aux, format, number);
126   return string(aux);
127 }
128
129 string functions::asString(const double number, const char* format)
130 throw() {
131   char aux [64];
132   sprintf(aux, format, number);
133   return string(aux);
134 }
135
136 string functions::asDateTime(const Second &second)
137 throw() {
138   char aux [DateTimeSizeString];
139   return std::string(asDateTime(second, aux));
140 }
141
142 const char* functions::asDateTime(const Second &second, char* result)
143 throw() {
144   struct tm* tt = localtime((time_t*) & second);
145   sprintf(
146     result, "%02d/%02d/%4d %02d:%02d:%02d",
147     tt->tm_mday, tt->tm_mon + 1, tt->tm_year + 1900,
148     tt->tm_hour, tt->tm_min, tt->tm_sec
149   );
150   return result;
151 }
152
153 std::string functions::asString(const DataBlock& dataBlock, const int characterByLine)
154 throw() {
155   return dataBlock.asString(characterByLine);
156 }
157
158 string functions::asHexString(const int number)
159 throw() {
160   char aux [16];
161   sprintf(aux, "0x%x", number);
162   return string(aux);
163 }
164
165 string functions::asHexString(const S64 number)
166 throw() {
167   char aux [32];
168   //sprintf(aux, "0x%llx", number);
169   #ifdef __anna64__
170      sprintf (aux, "0x%lx", number);
171   #else
172      sprintf (aux, "0x%llx", number);
173   #endif
174   return string(aux);
175 }
176
177 // from a version by Allen Holub (see Andrew Binstock, "Hashing Revisited"
178 // Dr. Dobb's Journal, April 1996)
179 S64 functions::hash(const char* p)
180 throw() {
181   static const int long_bits = sizeof(S64) << 3;
182   static const int one_eighth = long_bits >> 3;
183   static const int three_fourths = long_bits * 3 / 4;
184   static const S64 high_bits = ((S64)(~0L)) << (long_bits - one_eighth);
185   S64 result = 0;
186   S64 temp;
187
188   while(*p != 0) {
189     result = (result << one_eighth) + *p ++;
190
191     if((temp = result & high_bits) != 0)
192       result = (result ^(temp >> three_fourths)) &~ high_bits;
193   }
194
195   return result;
196 }
197
198 //static
199 std::string functions::asHexString(const DataBlock& dataBlock)
200 throw() {
201   const char* buffer = dataBlock.getData();
202   const int size = dataBlock.getSize();
203   string result;
204   int byte;
205
206   for(int ii = 0; ii < size; ii ++) {
207     byte = (buffer [ii] & 0xf0) >> 4;
208     result += (byte >= 0 && byte <= 9) ? (byte + '0') : ((byte - 0xa) + 'a');
209     byte = (buffer [ii] & 0x0f);
210     result += (byte >= 0 && byte <= 9) ? (byte + '0') : ((byte - 0xa) + 'a');
211   }
212
213   return result;
214 }
215
216 /**
217  * Gets the original value obtained with #asHexString (const DataBlock&).
218  * \param hexString String which contains the buffer. The format is an hexadecimal octet sequence representation (i.e. 'af012fb3', with even number of digits).
219  * The input shall be preprocessed to comply with that format (e.g. colon or any other non-hex digit must be removed).
220  * \param target DataBlock for string decode.
221  * \return DataBlock corresponding to the provided string.
222  */
223 //static
224 DataBlock& functions::fromHexString(const std::string& hexString, DataBlock& target)
225 throw(RuntimeException) {
226
227   if((hexString.length() % 2) != 0)
228     throw RuntimeException("functions::fromHexString | Invalid string length", ANNA_FILE_LOCATION);
229
230   target.clear();
231   const char* src = hexString.data();
232   unsigned char hex;
233   int aux;
234
235   for(int ii = 1, maxii = hexString.length(); ii < maxii; ii += 2) {
236     if(isxdigit(aux = src [ii - 1]) == 0)
237       throw RuntimeException("Invalid HexString", ANNA_FILE_LOCATION);
238
239     hex = ((aux >= '0' && aux <= '9') ? (aux - '0') : ((aux - 'a') + 0x0a)) << 4;
240
241     if(isxdigit(aux = src [ii]) == 0)
242       throw RuntimeException("Invalid HexString", ANNA_FILE_LOCATION);
243
244     hex |= (aux >= '0' && aux <= '9') ? (aux - '0') : ((aux - 'a') + 0x0a);
245     target += hex;
246   }
247
248   return target;
249 }
250
251 string functions::asString(const char* format, ...)
252 throw() {
253   va_list ap;
254   char aux [1024];
255   va_start(ap, format);
256   vsnprintf(aux, sizeof(aux), format, ap);
257   va_end(ap);
258   return string(aux);
259 }
260
261 void functions::sleep(const Millisecond &millisecond)
262 throw() {
263   timespec req;
264   timespec rem;
265   req.tv_sec = millisecond.getValue() / 1000;                          // segundos
266   req.tv_nsec = (millisecond.getValue() % 1000);                       // milisegundos
267   req.tv_nsec *= 1000000;                                   // mili = 10e-3, nano=10-9
268   int r;
269
270   while((r = nanosleep(&req, &rem)) != 0) {
271     if(errno == EINTR)
272       req = rem;
273     else {
274       string msg(asText("functions::sleep | timespec { sec: ", (int) req.tv_sec));
275       msg += functions::asText("| nsec: ", (int) req.tv_nsec);
276       msg += " }";
277       RuntimeException ex(msg, errno, ANNA_FILE_LOCATION);
278       ex.trace();
279       break;
280     }
281   }
282 }
283
284 bool functions::asBool(const char* str)
285 throw(RuntimeException) {
286   if(str == NULL)
287     return false;
288
289   if(strcasecmp(str, "true") == 0 || anna_strcmp(str, "1") == 0)
290     return true;
291
292   if(strcasecmp(str, "false") == 0 || anna_strcmp(str, "0") == 0)
293     return false;
294
295   string msg("anna::funcions::asBool | Cannot interpret '");
296   msg += str;
297   msg += "' as boolean";
298   throw RuntimeException(msg, ANNA_FILE_LOCATION);
299 }
300
301 S64 functions::asInteger64(const char* str)
302 throw() {
303   S64 number = 0;
304   //sscanf(str, "%lld", &number);
305   #ifdef __anna64__
306     sscanf (str, "%ld", &number);
307   #else
308      sscanf (str, "%lld", &number);
309   #endif
310   return number;
311 }
312
313 pthread_t functions::getCurrentThread()
314 throw() {
315   WHEN_MULTITHREAD(return pthread_self());
316   WHEN_SINGLETHREAD(return 0);
317 }
318
319 bool functions::isLike(const char* pattern, const std::string& _value)
320 throw(RuntimeException) {
321   const char* value = _value.c_str();
322   regex_t preg;
323   int ret;
324
325   if((ret = regcomp(&preg, pattern, REG_EXTENDED)) != 0) {
326     char err[256];
327     string msg("anna::functions::isLike | ");
328     msg += " | Pattern: ";
329     msg += pattern;
330     msg += " | Value: ";
331     msg += value;
332     msg += " | ";
333
334     if(regerror(ret, &preg, err, sizeof(err)))
335       msg += err;
336     else
337       msg += "Invalid pattern";
338
339     throw RuntimeException(msg, ANNA_FILE_LOCATION);
340   }
341
342   const bool result = (regexec(&preg, value, 0, NULL, 0) == 0) ? true : false;
343
344   regfree(&preg);
345   return result;
346 }
347
348 /*static*/
349 S64 functions::merge(const char* whatis, const int n1, const int n2, const int bitShift)
350 throw(RuntimeException) {
351   if(bitShift > intBitSize) {
352     string msg(functions::asString("%s | N1: 0x%x | N2: 0x%x | bitShift: %d | bitShift must be less than %d", whatis, n1, n2, bitShift, intBitSize));
353     throw RuntimeException(msg, ANNA_FILE_LOCATION);
354   }
355
356   if((bitsize(n1) + bitShift) > int64BitSize) {
357     string msg(functions::asString("%s | N1: 0x%x | N2: 0x%x | bitShift: %d | N1 overload", whatis, n1, n2, bitShift));
358     throw RuntimeException(msg, ANNA_FILE_LOCATION);
359   }
360
361   if(bitsize(n2) > bitShift) {
362     string msg(functions::asString("%s | N1: 0x%x | N2: 0x%x | bitShift: %d | N2 overload", whatis, n1, n2, bitShift));
363     throw RuntimeException(msg, ANNA_FILE_LOCATION);
364   }
365
366   S64 result = n1;
367   result <<= bitShift;
368   result |= n2;
369
370   if(bitShift == intBitSize) {
371     LOGINFORMATION(
372       string msg(functions::asString("%s | N1: 0x%x | N2: 0x%x | bitShift: %d | ", whatis, n1, n2, bitShift));
373       msg += functions::asHexString(result);
374       Logger::information(msg, ANNA_FILE_LOCATION);
375     );
376   }
377
378   return result;
379 }
380
381 /*static*/
382 /*
383  * Basado en el algoritmo de http://www-graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup
384  */
385 int functions::log2(const unsigned int v)
386 throw() {
387   static const signed char LogTable256[] = {
388     -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
389     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
390     5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
391     5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
392     6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
393     6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
394     6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
395     6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
396     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
397     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
398     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
399     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
400     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
401     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
402     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
403     7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
404   };
405   int r = -1;     // r will be lg(v)
406   unsigned int t, tt; // temporaries
407
408   if((tt = v >> 16)) {
409     r = ((t = tt >> 8)) ? 24 + LogTable256[t] : 16 + LogTable256[tt];
410   } else {
411     r = (t = v >> 8) ? 8 + LogTable256[t] : LogTable256[v];
412   }
413
414   return r;
415 }
416
417 std::string functions::entriesAsString(int number, const char * wordForSingular, const char * wordForPlural) throw() {
418   std::string result;
419   std::string singular = (wordForSingular ? wordForSingular : "entry");
420   std::string plural = (wordForPlural ? wordForPlural : "entries");
421
422   if(wordForSingular && !wordForPlural)
423     plural = singular + "s";
424
425   result += ((number != 0) ? anna::functions::asString(number) : "no");
426   result += " ";
427   result += ((number != 1) ? plural : singular);
428   return result;
429 }
430
431
432 std::string functions::justify(const std::string & title, TextJustifyMode::_v mode, char filler) throw() {
433   std::string result;
434   int d_size = title.size();
435   int repeat = PAGE_WIDTH_LENGTH - d_size - 1;
436   bool adjust = false;
437
438   if(mode == TextJustifyMode::Center) {
439     repeat = (repeat - 1) / 2;
440     adjust = (2 * (repeat + 1) + d_size != PAGE_WIDTH_LENGTH);
441   }
442
443   if((mode == TextJustifyMode::Right) || (mode == TextJustifyMode::Center)) {
444     for(int k = 0; k < (repeat + (adjust ? 1 : 0)); k++) result += filler;
445
446     result += " ";
447   }
448
449   result += title;
450
451   if((mode == TextJustifyMode::Left) || (mode == TextJustifyMode::Center)) {
452     result += " ";
453
454     for(int k = 0; k < repeat; k++) result += filler;
455   }
456
457   return result;
458 }
459
460
461 std::string functions::highlight(const std::string & title, TextHighlightMode::_v mode, char filler, bool appendCR) throw() {
462   std::string result;
463   int ou_repeat = title.size();
464   int lr_repeat = PAGE_WIDTH_LENGTH - ou_repeat - 1;
465   bool adjust = false;
466
467   if(mode == TextHighlightMode::LeftAndRightline) {
468     lr_repeat = (lr_repeat - 1) / 2;
469     adjust = (2 * (lr_repeat + 1) + ou_repeat != PAGE_WIDTH_LENGTH);
470   }
471
472   if((mode == TextHighlightMode::Leftline) || (mode == TextHighlightMode::LeftAndRightline)) {
473     for(int k = 0; k < (lr_repeat + (adjust ? 1 : 0)); k++) result += filler;
474
475     result += " ";
476   }
477
478   if((mode == TextHighlightMode::Overline) || (mode == TextHighlightMode::OverAndUnderline)) {
479     for(int k = 0; k < ou_repeat; k++) result += filler;
480
481     result += "\n";
482   }
483
484   result += title;
485
486   if((mode == TextHighlightMode::Underline) || (mode == TextHighlightMode::OverAndUnderline)) {
487     result += "\n";
488
489     for(int k = 0; k < ou_repeat; k++) result += filler;
490   }
491
492   if((mode == TextHighlightMode::Rightline) || (mode == TextHighlightMode::LeftAndRightline)) {
493     result += " ";
494
495     for(int k = 0; k < lr_repeat; k++) result += filler;
496   }
497
498   if(appendCR) result += "\n";
499
500   return result;
501 }
502
503
504 std::string functions::tab(const std::string & text, int tabSpaces) throw() {
505   std::string result;
506   size_t pos, from = 0;
507   std::string tab, crTab = "\n";
508
509   for(int k = 0; k < tabSpaces; k++) tab += " ";
510
511   crTab += tab;
512   result = tab;
513   result += text;
514
515   while(((pos = result.find('\n', from)) != std::string::npos) && (pos != (result.size() - 1)/*exclude last CR if exists*/)) {
516     result.replace(pos, 1, crTab);
517     from = pos + 1;
518   }
519
520   return result;
521 }
522
523
524 bool functions::endsWith(const std::string & pattern, const std::string & suffix, std::string & preffix) throw() {
525   preffix = "";
526
527   if(pattern.size() < suffix.size()) return false;
528
529   size_t pos = pattern.rfind(suffix);
530
531   if(pos == std::string::npos) return false;
532
533   preffix.assign(pattern.c_str(), pos);
534   return (pos == (pattern.size() - suffix.size()));
535 }
536
537
538 bool functions::startsWith(const std::string & pattern, const std::string & preffix, std::string & suffix) throw() {
539   suffix = "";
540
541   if(pattern.size() < preffix.size()) return false;
542
543   if(pattern.find(preffix) != 0) return false;
544
545   suffix.assign(pattern.c_str(), preffix.size(), pattern.size() - preffix.size());
546   return true;
547 }
548
549
550 std::string functions::replace(const std::string & text, const char *item, const char *target, bool all) throw() {
551   std::string result = text;
552
553   if(!item || !target) return result;  // protection for NULL strings provided
554
555   size_t lengthReplaced = strlen(item);
556   size_t pos = result.find(item);
557
558   while(pos != std::string::npos) {
559     result.replace(pos, lengthReplaced, target);
560
561     if(!all) break;
562
563     pos = result.find(item);
564   }
565
566   return result;
567 }
568
569
570 std::string functions::addQuotationMarks(const std::string & str) throw() {
571   std::string result = "'";
572   result += str;
573   result += "'";
574   return (result);
575 }
576
577
578 std::string functions::addQuotationMarks(const char * str) throw() {
579   std::string result = "'";
580   result += (str ? str : "<null>");
581   result += "'";
582   return (result);
583 }
584
585
586 std::string functions::addQuotationMarks(const int & integer) throw() {
587   std::string result = "'";
588   result += anna::functions::asString(integer);
589   result += "'";
590   return (result);
591 }
592
593
594 std::string functions::vectorToStringRepresentation(const std::vector<int> & v, const char separator) throw() {
595   std::string result = "";
596
597   if(v.size() != 0) {
598     std::vector<int>::const_iterator iter;
599     std::vector<int>::const_iterator iter_min(v.begin());
600     std::vector<int>::const_iterator iter_max(v.end());
601
602     for(iter = iter_min; iter != iter_max; iter++) {
603       result += anna::functions::asString(*iter);
604       result += separator;
605     }
606
607     // Delete the last space: starts at 'size()-1', take 1 caracter:
608     result.erase(result.size() - 1, 1);
609   }
610
611   return (result);
612 }
613
614
615 std::string functions::vectorToStringRepresentation(const std::vector<std::string> & v, const char separator) throw() {
616   std::string result = "";
617
618   if(v.size() != 0) {
619     std::vector<std::string>::const_iterator iter;
620     std::vector<std::string>::const_iterator iter_min(v.begin());
621     std::vector<std::string>::const_iterator iter_max(v.end());
622
623     for(iter = iter_min; iter != iter_max; iter++) {
624       result += (*iter);
625       result += separator;
626     }
627
628     // Delete the last space: starts at 'size()-1', take 1 caracter:
629     result.erase(result.size() - 1, 1);
630   }
631
632   return (result);
633 }
634
635
636 std::string functions::socketLiteralAsString(const std::string & address, int port) throw() {
637   std::string result = address;
638   result += ":";
639   result += anna::functions::asString(port);
640   return result;
641 }
642
643
644 std::string functions::asAsciiString(const char * buffer, int size, bool & isFullyPrintable) throw() {
645   std::string result;
646   // Supposed printable by default:
647   isFullyPrintable = true;
648
649   if(size == 0 || !buffer) {
650     result = "<null>";
651     isFullyPrintable = false;
652     return result;
653   }
654
655   for(int k = 0; k < size; k ++) {
656     unsigned char c = (unsigned char) buffer [k];
657     int printable = isprint(c);
658     result += (printable ? (char) c : '.');
659
660     if(!printable) isFullyPrintable = false;
661   }
662
663   return result;
664 }
665
666
667 std::string functions::getHostname() throw() {
668   char aux[255];
669   std::string result = "<hostname>";
670
671   if(gethostname(aux, sizeof aux) == 0 /*success*/)
672     result = aux;
673
674   return result;
675 }
676
677 std::string functions::getDomainname() throw() {
678   char aux[256];
679   std::string result = "<domainname>";
680
681   if(getdomainname(aux, sizeof aux) == 0 /*success*/)
682     result = aux;
683
684   return result;
685 }
686
687 std::string functions::getFQDN(const char *hostname, const char *domainname) throw() {
688   std::string hn = hostname ? hostname : (functions::getHostname());
689   std::string dn = domainname ? domainname : (functions::getDomainname());
690   // FQDN is limited to 255 bytes, with aditional restriction: 63 bytes label within a domain name.
691
692   if(hn == "") return dn;
693
694   if(dn == "") return hn;
695
696   std::string label(hn, 0, 63);
697   std::string fqdn(label + "." + dn, 0, 255);
698   return fqdn;
699 }
700
701 std::string functions::getHostnameIP() throw() {
702   std::string result = "";
703   struct hostent *he;
704   struct in_addr **addr_list;
705   char hostname[128];
706   gethostname(hostname, sizeof hostname);
707
708   if((he = gethostbyname(hostname)) != NULL) {
709     // Official name: he->h_name
710     // IP addresses:
711     addr_list = (struct in_addr **)he->h_addr_list;
712
713     for(int i = 0; addr_list[i] != NULL; i++) {
714       //printf("%s ", inet_ntoa(*addr_list[i]));
715       result = inet_ntoa(*addr_list[i]);
716       return result;
717     }
718   }
719
720   return result;
721 }
722
723
724 anna::DataBlock functions::rawIpPresentationAsRaw(const std::string & rawPresentation) throw(anna::RuntimeException) {
725   int length = rawPresentation.size();
726
727   if(length != 8 && length != 32)
728     throw anna::RuntimeException("functions::rawIpPresentationAsRaw | Expected 8 or 32-sized raw IP presentation provided", ANNA_FILE_LOCATION);
729
730   anna::DataBlock result(true);
731   int byte;
732   char rByte[3]; // readable byte
733   rByte[2] = 0;
734
735   for(int k = 0; k < length; k += 2) {
736     rByte[0] =  rawPresentation[k];
737     rByte[1] = rawPresentation[k + 1];
738     sscanf(rByte, "%x", &byte);
739     result += byte;
740   }
741
742   return result;
743 }
744
745
746 std::string functions::rawIpAsRawIpPresentation(const anna::DataBlock & db) throw(anna::RuntimeException) {
747   int length = db.getSize();
748
749   if(length != 4 && length != 16)
750     throw anna::RuntimeException("functions::rawIpAsRawIpPresentation | Expected 4 or 16-sized raw IP DataBlock provided", ANNA_FILE_LOCATION);
751
752   std::string result = "";
753   int byte;
754   char rByte[3]; // readable byte
755   rByte[2] = 0;
756
757   for(int k = 0; k < length; k++) {
758     byte = (unsigned char)db[k];
759     sprintf(rByte, "%.2X", byte);
760     result += rByte;
761   }
762
763   return result;
764 }
765
766
767
768 ////////////////////
769 // Address Format //
770 ////////////////////
771 //   IPv6 addresses have two logical parts: a 64-bit network prefix, and a 64-bit host address part. (The host address is often automatically generated from the interface MAC address.[34]) An IPv6 address is represented by 8 groups of 16-bit hexadecimal values separated by colons (:) shown as follows:
772 //   A typical example of an IPv6 address is
773 //   2001:0db8:85a3:0000:0000:8a2e:0370:7334
774 //   The hexadecimal digits are case-insensitive.
775 //
776 //   The 128-bit IPv6 address can be abbreviated with the following rules:
777 //   -Rule one: Leading zeroes within a 16-bit value may be omitted. For example, the address fe80:0000:0000:0000:0202:b3ff:fe1e:8329 may be written as fe80:0:0:0:202:b3ff:fe1e:8329
778 //   -Rule two: A single occurrence of consecutive groups of zeroes within an address may be replaced by a double colon. For example, fe80:0:0:0:202:b3ff:fe1e:8329 becomes fe80::202:b3ff:fe1e:8329
779 //   A single IPv6 address can be represented in several different ways, such as 2001:db8::1:0:0:1 and 2001:0DB8:0:0:1::1. RFC 5952 recommends a canonical textual representation.
780
781 //      Si la dirección tiene más de una serie de grupos nulos consecutivos la compresión sólo se permite en uno de ellos.
782 //      Así, las siguientes son representaciones posibles de una misma dirección:
783 //
784 //      2001:0DB8:0000:0000:0000:0000:1428:57ab
785 //      2001:0DB8:0000:0000:0000::1428:57ab
786 //      2001:0DB8:0:0:0:0:1428:57ab
787 //      2001:0DB8:0::0:1428:57ab
788 //      2001:0DB8::1428:57ab
789 //      son todas válidas y significan lo mismo, pero
790 //      2001::25de::cade
791 //          --    --
792 //      no es válida porque no queda claro cuántos grupos nulos hay en cada lado.
793 //
794 //      Los ceros iniciales en un grupo también se pueden omitir:
795 //      2001:0DB8:02de::0e13
796 //      2001:DB8:2de::e13
797 //
798 //      Si la dirección es una dirección IPv4 empotrada (mapped), los Ãºltimos 32 bits pueden escribirse en base decimal, así:
799 //      ::ffff:192.168.89.9
800 //      ::ffff:c0a8:5909
801 //
802 //      No se debe confundir con:
803 //      ::192.168.89.9
804 //      ::c0a8:5909
805 //
806 //      El formato ::ffff:1.2.3.4 se denomina dirección IPv4 mapeada, y el formato ::1.2.3.4 dirección IPv4 compatible.
807 //      Las direcciones IPv4 pueden ser transformadas fácilmente al formato IPv6. Por ejemplo, si la dirección decimal IPv4 es 135.75.43.52
808 //       (en hexadecimal, 0x874B2B34), puede ser convertida a 0000:0000:0000:0000:0000:0000:874B:2B34 o ::874B:2B34. Entonces, uno puede usar
809 //       la notación mixta dirección IPv4 compatible, en cuyo caso la dirección debería ser ::135.75.43.52. Este tipo de dirección IPv4 compatible
810 //       casi no está siendo utilizada en la práctica, aunque los estándares no la han declarado obsoleta.
811 //
812 // http://tools.ietf.org/html/rfc5952: canonical text representation recommendation
813
814 bool functions::isIPv4(const std::string & ip, IPv4Type::_v ipv4Type) throw() {
815   if(ipv4Type == IPv4Type::Estrict) {
816     // La expresión regular no controla si hay mas de 3 puntos:
817     int n_dot = 0;
818
819     for(int k = 0; k < ip.length(); k++)
820       if(ip[k] == '.') n_dot++;
821
822     if(n_dot > 3)
823       return (false);
824
825     bool ipv4 = anna::functions::isLike(s_REGEXP_IPv4_ADDRESSES, ip);
826     bool colon = (ip.find(":") != std::string::npos);
827     return (ipv4 && !colon);
828   }
829
830   if(ipv4Type == IPv4Type::Compatible) {
831     std::string pureIPv4 = ip;
832     bool firstDoubleColon = (ip.find("::") == 0);
833
834     if(firstDoubleColon) {
835       pureIPv4.erase(0, 2);
836       bool anotherColon = (pureIPv4.find(":") != std::string::npos);
837
838       if(anotherColon) return (false);
839
840       return (anna::functions::isLike(s_REGEXP_IPv4_ADDRESSES, pureIPv4));
841     }
842   }
843
844   if(ipv4Type == IPv4Type::Mapped) {
845     size_t posLastColon = ip.rfind(":");
846
847     if(posLastColon == std::string::npos)
848       return (false);
849
850     if(!isIPv4(ip.substr(posLastColon + 1)))
851       return (false);
852
853     unsigned char buf[sizeof(struct in6_addr)];
854     int s = inet_pton(AF_INET6, ip.c_str(), buf);
855
856     if(s > 0)
857       return (true);
858   }
859
860   return false;
861 }
862
863
864 bool functions::isIPv6(const std::string & ip) throw() {
865   // Chequeo de digitos permitidos:
866   for(int k = 0; k < ip.length(); k++) {
867     bool digit = isdigit(ip[k]);
868     bool hex = ((ip[k] == 'a') ||
869                 (ip[k] == 'b') ||
870                 (ip[k] == 'c') ||
871                 (ip[k] == 'd') ||
872                 (ip[k] == 'e') ||
873                 (ip[k] == 'f') ||
874                 (ip[k] == 'A') ||
875                 (ip[k] == 'B') ||
876                 (ip[k] == 'C') ||
877                 (ip[k] == 'D') ||
878                 (ip[k] == 'E') ||
879                 (ip[k] == 'F'));
880     bool colon = (ip[k] == ':');
881
882     if(!digit && !hex && !colon)
883       return false;
884   }
885
886   return (anna::functions::isLike(s_REGEXP_IPv6_ADDRESSES, ip));
887 }
888
889
890 std::string functions::IPv4To6(const std::string & ip) throw(anna::RuntimeException) {
891   if(!isIPv4(ip, IPv4Type::Estrict) && !isIPv4(ip, IPv4Type::Compatible) && !isIPv4(ip, IPv4Type::Mapped))
892     throw anna::RuntimeException("functions::IPv4To6 | Expected IPv4, IPv4-compatible or IPv4-mapped address format", ANNA_FILE_LOCATION);
893
894   std::string result, pureIPv4;
895   bool firstDoubleColon = (ip.find("::") == 0);
896
897   if(firstDoubleColon) {
898     // Clean '::'
899     size_t ipv4_pos = ip.rfind(":") /* last ocurrence */ + 1;
900     pureIPv4 = ip.substr(ipv4_pos);
901   } else {
902     if(!isIPv4(ip)) {
903       size_t posColon = ip.find(":");
904
905       if(posColon == 0)  // first colon
906         throw anna::RuntimeException("functions::IPv4To6 | Invalid IPv4 address format", ANNA_FILE_LOCATION);
907
908       if(posColon != std::string::npos)  // any colon
909         return ip; // seems to be IPv6 already?
910
911       throw anna::RuntimeException("functions::IPv4To6 | Unreconized IPv4 address format", ANNA_FILE_LOCATION);
912     }
913
914     pureIPv4 = ip;
915   }
916
917   // Number of ocurrences for '.'
918   int n_dot = 0;
919
920   for(int k = 0; k < pureIPv4.length(); k++)
921     if(pureIPv4[k] == '.') n_dot++;
922
923   if(n_dot > 3)
924     throw anna::RuntimeException("functions::IPv4To6 | Wrong IPv4 address format (more than three dots!)", ANNA_FILE_LOCATION);
925
926   anna::Tokenizer tok;
927   anna::Tokenizer::const_iterator tok_it;
928   std::string token;
929   tok.apply(pureIPv4, ".");
930   int v[4];
931   int cnt = 0;
932
933   for(tok_it = tok.begin(); tok_it != tok.end(); tok_it ++) {
934     token = anna::Tokenizer::data(tok_it);
935     v[cnt] = atoi(anna::Tokenizer::data(tok_it));
936
937     if(v[cnt] < 0 || v[cnt] > 255)
938       throw anna::RuntimeException("functions::IPv4To6 | Wrong IPv4 address format (any value out of range 0-255)", ANNA_FILE_LOCATION);
939
940     cnt++;
941   }
942
943   if(isIPv4(ip, IPv4Type::Compatible))
944     result = anna::functions::asString("::%04x:%04x", v[0] * 256 + v[1], v[2] * 256 + v[3]);
945   else
946     result = anna::functions::asString("::ffff:%04x:%04x", v[0] * 256 + v[1], v[2] * 256 + v[3]);
947
948   return result;
949 }
950
951
952 std::string functions::normalizeIP(const std::string & ip) throw(anna::RuntimeException) {
953   std::string result = ip;
954 //   std::transform(result.begin(), result.end(), result.begin(), (int (*)(int))std::tolower);
955   std::transform(result.begin(), result.end(), result.begin(), ::tolower);
956
957   if(isIPv4(ip, IPv4Type::Estrict) || isIPv4(ip, IPv4Type::Compatible) || isIPv4(ip, IPv4Type::Mapped))
958     result = IPv4To6(result);
959
960   size_t pos = result.find("::"); // zeroes simplification group
961   size_t rpos = result.rfind("::"); // zeroes simplification group
962
963   if(pos != rpos)
964     throw anna::RuntimeException("functions::normalizeIP | Wrong IPv6 address format (more than one simplification group '::')", ANNA_FILE_LOCATION);
965
966   if(pos != std::string::npos) {  // zeroes exists
967     // string ( size_t n, char c ) -> content is initialized as a string formed by a repetition of character c, n times.
968     // Number of ocurrences for ':'
969     int n_colon = 0;
970
971     for(int k = 0; k < result.length(); k++)
972       if(result[k] == ':') n_colon++;
973
974     // Generate equivalent to '::'
975     std::string equiv_str;
976
977     for(int k = 0; k < (8 - n_colon); k++)
978       equiv_str += ":0";
979
980     equiv_str += ":";
981     // Replace with equivalent:
982     result.replace(pos, 2, equiv_str);
983
984     // Special case: IP began with '::'
985     if(result[0] == ':') {
986       result.insert(0, "0");
987     }
988
989     // Special case: IP was only '::'
990     if(result[result.length() - 1] == ':') {
991       result += "0";
992     }
993   }
994
995   // Protection: it must be seven colons:
996   int n_colon = 0;
997
998   for(int k = 0; k < result.length(); k++)
999     if(result[k] == ':') n_colon++;
1000
1001   if(n_colon != 7)
1002     throw anna::RuntimeException("functions::normalizeIP | Wrong IPv6 address format (missing any 16-bit group)", ANNA_FILE_LOCATION);
1003
1004   // Padding with zeroes at left
1005   anna::Tokenizer ipStr;
1006   anna::Tokenizer::const_iterator ipStr_it;
1007   std::string token;
1008   ipStr.apply(result, ":");
1009   result = "";
1010
1011   for(ipStr_it = ipStr.begin(); ipStr_it != ipStr.end(); ipStr_it ++) {
1012     token = anna::Tokenizer::data(ipStr_it);
1013
1014     while(token.length() < 4) token.insert(0, "0");
1015
1016     result += token;
1017     result += ":";
1018   }
1019
1020   // Remove last ':'
1021   size_t lastPos = result.length() - 1;
1022   result.erase(lastPos, 1);
1023
1024   // Chequeo de digitos permitidos:
1025   for(int k = 0; k < result.length(); k++) {
1026     bool digit = isdigit(result[k]);
1027     bool hex = ((result[k] == 'a') ||
1028                 (result[k] == 'b') ||
1029                 (result[k] == 'c') ||
1030                 (result[k] == 'd') ||
1031                 (result[k] == 'e') ||
1032                 (result[k] == 'f'));
1033     bool colon = (result[k] == ':');
1034
1035     if(!digit && !hex && !colon) {
1036       throw anna::RuntimeException("functions::normalizeIP | Invalid address format (only digits (0-9) and hex digits are allowed)", ANNA_FILE_LOCATION);
1037     }
1038   }
1039
1040   return result;
1041 }
1042
1043
1044 bool functions::sameIP(const std::string & ip1, const std::string & ip2) throw(anna::RuntimeException) {
1045   //if (ip1 == ip2) return true; it should validate wrong-format addresses
1046   return (normalizeIP(ip1) == normalizeIP(ip2));
1047 }
1048
1049
1050 bool functions::matchIPv6(const std::string & _ipv6, const std::string & preffixedIpv6) throw(anna::RuntimeException) {
1051   size_t preffixPos = preffixedIpv6.find("/");
1052
1053   if(preffixPos == std::string::npos)
1054     return (sameIP(_ipv6, preffixedIpv6));
1055
1056   std::string ipv6 = _ipv6;
1057
1058   if(isIPv4(_ipv6, IPv4Type::Estrict) || isIPv4(_ipv6, IPv4Type::Compatible) || isIPv4(_ipv6, IPv4Type::Mapped)) ipv6 = IPv4To6(_ipv6);
1059
1060   std::string _ipv6_2 = preffixedIpv6.substr(0, preffixPos);
1061   std::string ipv6_2 = _ipv6_2;
1062
1063   if(isIPv4(_ipv6_2, IPv4Type::Estrict) || isIPv4(_ipv6_2, IPv4Type::Compatible) || isIPv4(_ipv6_2, IPv4Type::Mapped)) ipv6_2 = IPv4To6(_ipv6_2);
1064
1065   std::string preffix = preffixedIpv6.substr(preffixPos + 1);
1066   int ipv6_2_preffixLength = atoi(preffix.c_str());
1067
1068   if(ipv6_2_preffixLength < 0 || ipv6_2_preffixLength > 128)
1069     throw anna::RuntimeException("functions::matchIPv6 | Invalid Ipv6 preffix length: out of range [0,128]", ANNA_FILE_LOCATION);
1070
1071   // No restriction, all ipv6_2 ignored (special and not usual case)
1072   if(ipv6_2_preffixLength == 0) return true;
1073
1074   // Auxiliary data:
1075   int spare = ipv6_2_preffixLength /* bits */ % 8; // bytes
1076   int incompletedRestrictionBytes = ipv6_2_preffixLength / 8;
1077   int completedRestrictionBytes = incompletedRestrictionBytes + ((spare != 0) ? 1 : 0);
1078   char mask = 0xFF << (8 - spare);
1079   // Limit ipv6
1080   anna::DataBlock rawIP1 = ipAsRaw(ipv6);
1081   anna::DataBlock restrictedIP1(true);
1082   restrictedIP1.assign(rawIP1.getData(), incompletedRestrictionBytes);
1083
1084   if(spare != 0) restrictedIP1 += rawIP1[incompletedRestrictionBytes] & mask;
1085
1086   // Limit ipv6_2
1087   anna::DataBlock rawIP2 = ipAsRaw(ipv6_2);
1088   anna::DataBlock realIP2(true);
1089   realIP2.assign(rawIP2.getData(), incompletedRestrictionBytes);
1090
1091   if(spare != 0) realIP2 += rawIP2[incompletedRestrictionBytes] & mask;
1092
1093   // Comparison
1094   int n = memcmp(restrictedIP1.getData(), realIP2.getData(), completedRestrictionBytes);
1095   return (n == 0);
1096 }
1097
1098
1099 anna::DataBlock functions::ipAsRaw(const std::string & ip) throw(anna::RuntimeException) {
1100   anna::DataBlock result(true);
1101
1102   if(isIPv4(ip)) {
1103     unsigned char buf[sizeof(struct in6_addr)];
1104     int s = inet_pton(AF_INET, ip.c_str(), buf);
1105
1106     if(s > 0) {
1107       result += (S8)buf[0];
1108       result += (S8)buf[1];
1109       result += (S8)buf[2];
1110       result += (S8)buf[3];
1111     } else {
1112       if(s < 0) perror("inet_pton");
1113
1114       throw anna::RuntimeException("functions::ipAsRaw | Wrong IPv4 address format", ANNA_FILE_LOCATION);
1115     }
1116   } else {
1117     unsigned char buf[sizeof(struct in6_addr)];
1118     int s = inet_pton(AF_INET6, ip.c_str(), buf);
1119
1120     if(s > 0) {
1121       result += (S8)buf[0];
1122       result += (S8)buf[1];
1123       result += (S8)buf[2];
1124       result += (S8)buf[3];
1125       result += (S8)buf[4];
1126       result += (S8)buf[5];
1127       result += (S8)buf[6];
1128       result += (S8)buf[7];
1129       result += (S8)buf[8];
1130       result += (S8)buf[9];
1131       result += (S8)buf[10];
1132       result += (S8)buf[11];
1133       result += (S8)buf[12];
1134       result += (S8)buf[13];
1135       result += (S8)buf[14];
1136       result += (S8)buf[15];
1137     } else {
1138       if(s < 0) perror("inet_pton");
1139
1140       throw anna::RuntimeException("functions::ipAsRaw | Wrong IPv6 address format", ANNA_FILE_LOCATION);
1141     }
1142   }
1143
1144   return result;
1145   // Alternativa
1146   //   anna::DataBlock result(true);
1147   //
1148   //
1149   //   if (isIPv4(ip)) {
1150   //
1151   //      int dec1, dec2, dec3, dec4; // U32 type is valid, 'int' better: argument for %d must be 'int *' (http://www.cplusplus.com/reference/clibrary/cstdio/sscanf/)
1152   //      sscanf(ip.c_str(), "%d.%d.%d.%d", &dec1, &dec2, &dec3, &dec4);
1153   //      result += (S8)dec1;
1154   //      result += (S8)dec2;
1155   //      result += (S8)dec3;
1156   //      result += (S8)dec4;
1157   //   }
1158   //   else {
1159   //
1160   //      int hex1, hex2, hex3, hex4, hex5, hex6, hex7, hex8; // U16 type is not valid: argument for %X must be 'int *' (http://www.cplusplus.com/reference/clibrary/cstdio/sscanf/)
1161   //      sscanf(normalizeIP(ip).c_str(), "%X:%X:%X:%X:%X:%X:%X:%X", &hex1, &hex2, &hex3, &hex4, &hex5, &hex6, &hex7, &hex8);
1162   //      result += ((S8)(hex1 >> 8));
1163   //      result += ((S8)(hex1 & 0x00FF));
1164   //      result += ((S8)(hex2 >> 8));
1165   //      result += ((S8)(hex2 & 0x00FF));
1166   //      result += ((S8)(hex3 >> 8));
1167   //      result += ((S8)(hex3 & 0x00FF));
1168   //      result += ((S8)(hex4 >> 8));
1169   //      result += ((S8)(hex4 & 0x00FF));
1170   //      result += ((S8)(hex5 >> 8));
1171   //      result += ((S8)(hex5 & 0x00FF));
1172   //      result += ((S8)(hex6 >> 8));
1173   //      result += ((S8)(hex6 & 0x00FF));
1174   //      result += ((S8)(hex7 >> 8));
1175   //      result += ((S8)(hex7 & 0x00FF));
1176   //      result += ((S8)(hex8 >> 8));
1177   //      result += ((S8)(hex8 & 0x00FF));
1178   //   }
1179   //
1180   //
1181   //   return result;
1182 }
1183
1184
1185 std::string functions::rawIpAsString(const char *buffer, int bufferLength, bool normalize) throw(anna::RuntimeException) {
1186   std::string result = "";
1187   char str[INET6_ADDRSTRLEN];
1188
1189   if(bufferLength == 4) {
1190     if(inet_ntop(AF_INET, buffer, str, INET_ADDRSTRLEN) != NULL)
1191       result = str;
1192   } else if(bufferLength == 16) {
1193     if(inet_ntop(AF_INET6, buffer, str, INET6_ADDRSTRLEN) != NULL)
1194       result = str;
1195   } else
1196     throw anna::RuntimeException("functions::rawIpAsString | Unreconized IP address format (only 4-byte for IPv4, and 16-byte for IPv6 are allowed)", ANNA_FILE_LOCATION);
1197
1198   if(result == "")
1199     throw anna::RuntimeException("functions::rawIpAsString | Wrong IP address serialization (check range value)", ANNA_FILE_LOCATION);
1200
1201   return (normalize ? normalizeIP(result) : result);
1202   // Alternativa:
1203   //   std::string result;
1204   //
1205   //
1206   //   if (bufferLength == 4) { // IPv4
1207   //      result = anna::functions::asString("%d.%d.%d.%d", (U8)buffer[0], (U8)buffer[1], (U8)buffer[2], (U8)buffer[3]);
1208   //   }
1209   //   else if (bufferLength == 16) { // IPv6
1210   //      result = anna::functions::asString("%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
1211   //                       ((((U8)buffer[0]) << 8) & 0xFF00 /* same as (U16 cast)*/) +
1212   //                       (((U8)buffer[1])        & 0x00FF),
1213   //                       ((((U8)buffer[2]) << 8) & 0xFF00) +
1214   //                       (((U8)buffer[3])        & 0x00FF),
1215   //                       ((((U8)buffer[4]) << 8) & 0xFF00) +
1216   //                       (((U8)buffer[5])        & 0x00FF),
1217   //                       ((((U8)buffer[6]) << 8) & 0xFF00) +
1218   //                       (((U8)buffer[7])        & 0x00FF),
1219   //                       ((((U8)buffer[8]) << 8) & 0xFF00) +
1220   //                       (((U8)buffer[9])        & 0x00FF),
1221   //                       ((((U8)buffer[10]) << 8) & 0xFF00) +
1222   //                       (((U8)buffer[11])        & 0x00FF),
1223   //                       ((((U8)buffer[12]) << 8) & 0xFF00) +
1224   //                       (((U8)buffer[13])        & 0x00FF),
1225   //                       ((((U8)buffer[14]) << 8) & 0xFF00) +
1226   //                       (((U8)buffer[15])        & 0x00FF));
1227   //   }
1228   //   else
1229   //      throw anna::RuntimeException("functions::rawIpAsString | Unreconized IP address format (only 4-byte for IPv4, and 16-byte for IPv6 are allowed)", ANNA_FILE_LOCATION);
1230   //
1231   //
1232   //   return (normalize ? normalizeIP(result):result);
1233 }
1234
1235
1236 void functions::getAddressAndPortFromSocketLiteral(const std::string &literal, std::string &address, int &port) throw() {
1237   size_t pos = literal.find_last_of(":");
1238   size_t lastPos = literal.size() - 1;
1239   address = ""; port = -1; // assume error
1240
1241   if((pos != std::string::npos) && (pos != lastPos)) {
1242     address = literal.substr(0, pos);
1243     port = atoi(literal.substr(pos + 1, lastPos).c_str());
1244   }
1245 }
1246
1247
1248 socket_v functions::getSocketVectorFromString(const std::string & list) throw() {
1249   socket_v result;
1250   std::string address;
1251   int port;
1252   anna::Tokenizer lst;
1253   lst.apply(list, ",");
1254
1255   if(lst.size() < 1) return result;
1256
1257   anna::Tokenizer::const_iterator tok_min(lst.begin());
1258   anna::Tokenizer::const_iterator tok_max(lst.end());
1259   anna::Tokenizer::const_iterator tok_iter;
1260
1261   for(tok_iter = tok_min; tok_iter != tok_max; tok_iter++) {
1262     getAddressAndPortFromSocketLiteral(anna::Tokenizer::data(tok_iter), address, port);
1263
1264     if(port == -1) { result.clear(); return result; }
1265
1266     result.push_back(socket_t(address, port));
1267   }
1268
1269   return result;
1270 }
1271
1272 std::string functions::socketVectorAsString(const socket_v & socketVector) throw() {
1273   std::string result;
1274   socket_v_it it;
1275   socket_v_it it_min(socketVector.begin());
1276   socket_v_it it_max(socketVector.end());
1277
1278   for(it = it_min; it != it_max; it++) {
1279     result += anna::functions::asString("%s:%d,", (*it).first.c_str(), (*it).second);
1280   }
1281
1282   result.erase(result.size() - 1, 1);  // remove last comma
1283   return result;
1284 }
1285
1286 bool functions::littleEndian()
1287 throw() {
1288   int i = 1;
1289   char *p = (char *) &i;
1290   if (p[0] == 1) return true;
1291   return false;
1292 }
1293
1294 const char* functions::codeInteger(char* result, const int n)
1295 throw() {
1296   int aux(htonl(n));
1297   char* w((char*) &aux);
1298   *result = *w;
1299   *(result + 1) = *(w + 1);
1300   *(result + 2) = *(w + 2);
1301   *(result + 3) = *(w + 3);
1302   return result;
1303 }
1304
1305 const char* functions::codeShort(char* result, const short int n)
1306 throw() {
1307   short int aux(htons(n));
1308   char* w((char*) &aux);
1309   *result = *w;
1310   *(result + 1) = *(w + 1);
1311   return result;
1312 }
1313
1314 const char* functions::codeInteger64(char* result, const S64 n)
1315 throw() {
1316   S64 aux(0xffffffff);
1317   int n2;
1318   aux <<= 32;
1319   aux &= n;
1320   n2 = (aux >> 32) & 0xffffffff;
1321   codeInteger(result, n2);
1322   n2 = n & 0xffffffff;
1323   codeInteger(result + sizeof(int), n2);
1324   return result;
1325 }
1326
1327 /*static*/
1328 const char* functions::codeFloat(char* result, const float n)
1329 throw() {
1330   int ii;
1331   anna_memcpy(&ii, &n, sizeof(n));
1332   return functions::codeInteger(result, ii);
1333 }
1334
1335 /*static*/
1336 const char* functions::codeDouble(char* result, const double n)
1337 throw() {
1338   S64 ii;
1339   anna_memcpy(&ii, &n, sizeof(n));
1340   return functions::codeInteger64(result, ii);
1341 }
1342
1343 int functions::decodeInteger(const char* data)
1344 throw() {
1345   int result;
1346   char* w((char*) &result);
1347   *w  = *data;
1348   *(w + 1) = *(data + 1);
1349   *(w + 2) = *(data + 2);
1350   *(w + 3) = *(data + 3);
1351   return ntohl(result);
1352 }
1353
1354 short int functions::decodeShort(const char* data)
1355 throw() {
1356   short int result;
1357   char* w((char*) &result);
1358   *w  = *data;
1359   *(w + 1) = *(data + 1);
1360   return ntohs(result);
1361 }
1362
1363 S64 functions::decodeInteger64(const char* data)
1364 throw() {
1365   S64 result(decodeInteger(data));
1366   result <<= 32;
1367   return result |= (decodeInteger(data + sizeof(int)) & 0xffffffff);
1368 }
1369
1370 /*static*/
1371 float functions::decodeFloat(const char* data)
1372 throw() {
1373   float result;
1374   int ii = functions::decodeInteger(data);
1375   anna_memcpy(&result, &ii, sizeof(result));
1376   return result;
1377 }
1378
1379 /*static*/
1380 double functions::decodeDouble(const char* data)
1381 throw() {
1382   double result;
1383   S64 ii = functions::decodeInteger64(data);
1384   anna_memcpy(&result, &ii, sizeof(result));
1385   return result;
1386 }
1387
1388
1389
1390 void functions::decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) throw(anna::RuntimeException) {
1391 #define DECODE2BYTES_INDX_VALUETYPE(buffer,indx,value_type) ((((value_type)buffer[indx] << 8) & 0xFF00) + ((value_type)buffer[indx+1] & 0x00FF))
1392   isupNumber.reset();
1393   isupNumber.OddEven = (short)((buffer[0] >> 7) & 0x01);
1394   bool filler = isupNumber.OddEven;
1395
1396   if(filler && ((buffer [length - 1] & 0xf0) != 0x00))
1397     throw anna::RuntimeException("functions::decodeIsupNumber | Isup number filler must be '0000'", ANNA_FILE_LOCATION);
1398
1399   isupNumber.NatureOfAddress = (short)(buffer[0] & 0x7F);
1400   isupNumber.NumberingPlan = (short)((buffer[1] >> 4) & 0x07);
1401
1402   if(calledOrCalling) {
1403     isupNumber.InternalNetworkNumber = (short)((buffer[1] >> 7) & 0x01);
1404   } else {
1405     isupNumber.NumberIncomplete = (short)((buffer[1] >> 7) & 0x01);
1406     isupNumber.AddressPresentationRestricted = (short)((buffer[1] >> 2) & 0x03);
1407     isupNumber.Screening = (short)(buffer[1] & 0x03);
1408   }
1409
1410   // Digits:
1411   isupNumber.Digits = "";
1412   int byte;
1413
1414   for(int k = 2; k < length; k ++) {
1415     byte = (buffer [k] & 0x0f);
1416     isupNumber.Digits += (byte >= 0 && byte <= 9) ? (byte + '0') : ((byte - 0xa) + 'a');
1417     byte = (buffer [k] & 0xf0) >> 4;
1418     isupNumber.Digits += (byte >= 0 && byte <= 9) ? (byte + '0') : ((byte - 0xa) + 'a');
1419   }
1420
1421   if(filler) isupNumber.Digits.erase(isupNumber.Digits.size() - 1, 1);   // remove filler
1422 }
1423
1424
1425 void functions::codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, std::string & target) throw(anna::RuntimeException) {
1426   // Checkings:
1427   if(isupNumber.OddEven < 0 || isupNumber.OddEven > 1)
1428     throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'OddEven' field out of range [0,1]", ANNA_FILE_LOCATION);
1429
1430   bool odd = isupNumber.OddEven;
1431   bool oddDigits = (isupNumber.Digits.size() % 2);
1432
1433   if(odd != oddDigits)
1434     throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'OddEven' field doesn't correspond to the number of digits on 'Digits' field", ANNA_FILE_LOCATION);
1435
1436   if(isupNumber.NatureOfAddress < 0 || isupNumber.NatureOfAddress > 127)
1437     throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'NatureOfAddress' field out of range [0,127]", ANNA_FILE_LOCATION);
1438
1439   if(isupNumber.NumberingPlan < 0 || isupNumber.NumberingPlan > 7)
1440     throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'NumberingPlan' field out of range [0,7]", ANNA_FILE_LOCATION);
1441
1442   if(calledOrCalling) {
1443     if(isupNumber.NumberIncomplete != 0)
1444       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'NumberIncomplete' field present on Called Party Number !", ANNA_FILE_LOCATION);
1445
1446     if(isupNumber.AddressPresentationRestricted != 0)
1447       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'AddressPresentationRestricted' field present on Called Party Number !", ANNA_FILE_LOCATION);
1448
1449     if(isupNumber.Screening != 0)
1450       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'Screening' field present on Called Party Number !", ANNA_FILE_LOCATION);
1451
1452     if(isupNumber.InternalNetworkNumber < 0 || isupNumber.InternalNetworkNumber > 1)
1453       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'InternalNetworkNumber' field out of range [0,1]", ANNA_FILE_LOCATION);
1454   } else {
1455     if(isupNumber.InternalNetworkNumber != 0)
1456       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'InternalNetworkNumber' field present on Calling Party Number !", ANNA_FILE_LOCATION);
1457
1458     if(isupNumber.NumberIncomplete < 0 || isupNumber.NumberIncomplete > 1)
1459       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'NumberIncomplete' field out of range [0,1]", ANNA_FILE_LOCATION);
1460
1461     if(isupNumber.AddressPresentationRestricted < 0 || isupNumber.AddressPresentationRestricted > 3)
1462       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'AddressPresentationRestricted' field out of range [0,3]", ANNA_FILE_LOCATION);
1463
1464     if(isupNumber.Screening < 0 || isupNumber.Screening > 3)
1465       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'Screening' field out of range [0,3]", ANNA_FILE_LOCATION);
1466   }
1467
1468   char byte;
1469   target = "";
1470   bool filler = isupNumber.OddEven;
1471   bool hasDigits = (isupNumber.Digits.size() > 0);
1472   byte = filler ? 0x80 : 0x00;
1473   byte |= isupNumber.NatureOfAddress;
1474   target += byte;
1475
1476   if(calledOrCalling) {
1477     byte = isupNumber.InternalNetworkNumber << 7;
1478     byte |= (isupNumber.NumberingPlan << 4);
1479   } else {
1480     byte = isupNumber.NumberIncomplete << 7;
1481     byte |= (isupNumber.NumberingPlan << 4);
1482     byte |= (isupNumber.AddressPresentationRestricted << 2);
1483     byte |= isupNumber.Screening;
1484   }
1485
1486   target += byte;
1487   //int byte;
1488   unsigned char hex;
1489   std::string dtlc = isupNumber.Digits; // digits to lower case
1490   //std::transform(dtlc.begin(), dtlc.end(), dtlc.begin(), std::tolower);
1491   const char *digits = dtlc.c_str();
1492
1493   for(int k = 1; k < isupNumber.Digits.size(); k += 2) {
1494     if(isxdigit(byte = digits [k - 1]) == 0)
1495       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'Digits' field contains invalid digits (non hexadecimal)", ANNA_FILE_LOCATION);
1496
1497     hex = (byte >= '0' && byte <= '9') ? (byte - '0') : ((byte - 'a') + 0x0a);
1498
1499     if(isxdigit(byte = digits [k]) == 0)
1500       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'Digits' field contains invalid digits (non hexadecimal)", ANNA_FILE_LOCATION);
1501
1502     hex |= ((byte >= '0' && byte <= '9') ? (byte - '0') : ((byte - 'a') + 0x0a)) << 4;
1503     target += hex;
1504   }
1505
1506   if(hasDigits && filler) {
1507     if(isxdigit(byte = digits [isupNumber.Digits.size() - 1]) == 0)
1508       throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'Digits' field contains invalid digits (non hexadecimal)", ANNA_FILE_LOCATION);
1509
1510     target += ((byte >= '0' && byte <= '9') ? (byte - '0') : ((byte - 'a') + 0x0a));
1511   }
1512 }
1513
1514
1515 void functions::codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, char * buffer, int & length) throw(anna::RuntimeException) {
1516   std::string target;
1517   codeIsupNumber(isupNumber, calledOrCalling, target);
1518   length = target.size();
1519   memcpy(buffer, target.c_str(), length);
1520 }
1521