bug in RC
[anna.git] / include / anna / core / util / defines.hpp
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 #ifndef anna_core_util_defines_hpp
10 #define anna_core_util_defines_hpp
11
12 // STL
13 #include <algorithm>
14 #include <string>
15 #include <vector>
16
17 #include <stdio.h>
18
19 #include <stdint.h>
20 // For cstd0x compatibility we will use stdint.h types instead of std:: ones on cstdint:
21 //#include <cstdint>  when C++11 available
22
23
24 // Decoding helpers
25 #define DECODE2BYTES_INDX_VALUETYPE(buffer,indx,value_type) ((((value_type)buffer[indx] << 8) & 0xFF00) + ((value_type)buffer[indx+1] & 0x00FF))
26 #define DECODE3BYTES_INDX_VALUETYPE(buffer,indx,value_type) ((((value_type)buffer[indx] << 16) & 0xFF0000) + (((value_type)buffer[indx+1] << 8) & 0x00FF00) + ((value_type)buffer[indx+2] & 0x0000FF))
27 #define DECODE4BYTES_INDX_VALUETYPE(buffer,indx,value_type) ((((value_type)buffer[indx] << 24) & 0xFF000000) + (((value_type)buffer[indx+1] << 16) & 0x00FF0000) + (((value_type)buffer[indx+2] << 8) & 0x0000FF00) + ((value_type)buffer[indx+3] & 0x000000FF))
28
29 //#define DECODE2BYTES_VALUETYPE(buffer,value_type) DECODE2BYTES_INDX_VALUETYPE(buffer,0,value_type)
30 //#define DECODE3BYTES_VALUETYPE(buffer,value_type) DECODE3BYTES_INDX_VALUETYPE(buffer,0,value_type)
31 //#define DECODE4BYTES_VALUETYPE(buffer,value_type) DECODE4BYTES_INDX_VALUETYPE(buffer,0,value_type)
32
33
34 namespace anna {
35
36 #ifndef __x86_64__
37 #undef  __anna64__
38 #else
39 #define __anna64__
40 #endif
41
42 //      TYPE                    BITS (bytes)       Format
43 //      ----------------------- ------------------ ---------------------------
44 //      unsigned long int       32/64 (4/8)        lu
45 //      long int                32/64 (4/8)        ld
46 //
47 //      unsigned long long int  64 (8)             llu
48 //      long long int           64 (8)             lld
49 //
50 //      float                   32 (4)             f
51 //      double                  64 (8)             lf
52 //      long double             80 (10)            Lf
53 //
54 //      pointer = S.O. word     32/64              p
55
56
57 /** Alias for unsigned integer with 8 bits */
58 //typedef uint8_t U8;
59 typedef unsigned char U8;
60
61 /** Alias for signed integer with 8 bits */
62 //typedef int8_t S8;
63 typedef char S8;
64
65 /** Alias for unsigned integer with 16 bits */
66 typedef uint16_t U16;
67
68 /** Alias for signed integer with 16 bits */
69 typedef int16_t S16;
70
71 /** Alias for unsigned integer with 32 bits */
72 typedef uint32_t U32;
73
74 /** Alias for signed integer with 32 bits */
75 typedef int32_t S32;
76
77 /** Alias for unsigned integer with 64 bits */
78 typedef uint64_t U64;
79
80 /** Alias for signed integer with 64 bits */
81 typedef int64_t S64;
82
83 /** Alias for float: floating number with 32 bits (1-8-23) */
84 typedef float F32;
85
86 /** Alias for double: floating number with 64 bits (1-11-52) */
87 typedef double F64;
88
89 /** Alias for long double: floating number with 80 bits (1-15-64) */
90 typedef long double F80;
91
92 /** Alias for unsigned integer with 32 bits used to contain 24 bits */
93 typedef U32 U24;
94
95
96 // Communication
97
98 /**
99 * Typedef for socket literal representation: <ip|hostname>:<port>
100 */
101 typedef std::pair <std::string, int> socket_t;
102
103 /**
104 * Typedef for sockets (socket_t) vector
105 */
106 typedef std::vector<socket_t> socket_v;
107 typedef std::vector<socket_t>::const_iterator socket_v_it;
108
109
110
111
112 /**
113    Struct for called and calling party number from Q763 Signalling System No. 7 \96 ISDN user part formats and codes
114
115    <pre>
116
117    Called Party Number
118               8         7         6         5         4         3         2         1
119          |---------|---------|---------|---------|---------|---------|---------|---------|
120    1     |   O/E   |              Nature of address indicator                            |
121          |---------|---------|---------|---------|---------|---------|---------|---------|
122    2     |   INN   |   Numbering plan indicator  |                 spare                 |
123          |---------|---------|---------|---------|---------|---------|---------|---------|
124    3     |          2nd address signal           |           1st address signal          |
125          |---------|---------|---------|---------|---------|---------|---------|---------|
126         ...       ...       ...       ...       ...       ...       ...       ...       ...
127          |---------|---------|---------|---------|---------|---------|---------|---------|
128    m     |         Filler (if necessary)         |           nth address signal          |
129          |---------|---------|---------|---------|---------|---------|---------|---------|
130
131
132
133    Calling Party Number
134               8         7         6         5         4         3         2         1
135          |---------|---------|---------|---------|---------|---------|---------|---------|
136    1     |   O/E   |              Nature of address indicator                            |
137          |---------|---------|---------|---------|---------|---------|---------|---------|
138    2     |   NI    |   Numbering plan indicator  |Add.Pres.Restr.Ind |   Screening Ind   |
139          |---------|---------|---------|---------|---------|---------|---------|---------|
140    3     |          2nd address signal           |           1st address signal          |
141          |---------|---------|---------|---------|---------|---------|---------|---------|
142         ...       ...       ...       ...       ...       ...       ...       ...       ...
143          |---------|---------|---------|---------|---------|---------|---------|---------|
144    m     |         Filler (if necessary)         |           nth address signal          |
145          |---------|---------|---------|---------|---------|---------|---------|---------|
146
147    </pre>
148 */
149 typedef struct {
150   /**  odd/even (1/0) indicator */
151   short OddEven;
152
153   /** Return true when have odd number of digits */
154   bool isOdd() { return OddEven; }
155   /** Return true when have even number of digits */
156   bool isEven() { return !isOdd(); }
157
158
159   /** <pre>
160      Nature of address indicator
161      0 0 0 0 0 0 0 spare
162      0 0 0 0 0 0 1 subscriber number (national use)
163      0 0 0 0 0 1 0 unknown (national use)
164      0 0 0 0 0 1 1 national (significant) number (national use)
165      0 0 0 0 1 0 0 international number
166
167    Called:
168      0 0 0 0 1 0 1 network-specific number (national use) ITU-T Q.763 (12/1999) 23
169      0 0 0 0 1 1 0 network routing number in national (significant) number format (national use)
170      0 0 0 0 1 1 1 network routing number in network-specific number format (national use)
171      0 0 0 1 0 0 0 network routing number concatenated with Called Directory Number (national use)
172      1 1 0 1 1 1 1 to 0 0 0 1 0 0 1 spare
173      1 1 1 1 1 1 0 to 1 1 1 0 0 0 0 reserved for national use
174      1 1 1 1 1 1 1 spare
175
176    Calling:
177      0 0 0 0 1 1 0 to 1 1 0 1 1 1 1 spare
178      1 1 1 0 0 0 0 to 1 1 1 1 1 1 0 reserved for national use
179      1 1 1 1 1 1 1 spare
180      </pre>
181    */
182   short NatureOfAddress;
183
184   /** Return true when Nature Of Address is 'subscriber number (national use)' */
185   bool NatureOfAddress_SubscriberNumber() { return (NatureOfAddress == 1); }
186   /** Return true when Nature Of Address is 'unknown (national use)' */
187   bool NatureOfAddress_Unknown() { return (NatureOfAddress == 2); }
188   /** Return true when Nature Of Address is 'national (significant) number (national use)' */
189   bool NatureOfAddress_NationalNumber() { return (NatureOfAddress == 3); }
190   /** Return true when Nature Of Address is 'international number' */
191   bool NatureOfAddress_InternationalNumber() { return (NatureOfAddress == 4); }
192
193
194   /** <pre>
195      Internal Network Number indicator (INN) (only for called party number)
196      0 routing to internal network number allowed
197      1 routing to internal network number not allowed
198      </pre>
199    */
200   short InternalNetworkNumber;
201
202   /** Return true when Internal Network Number Indicator is 'routing to internal network number allowed' */
203   bool InternalNetworkNumber_RoutingToInternalNetworkNumberAllowed() { return (InternalNetworkNumber == 0); }
204   /** Return true when Internal Network Number Indicator is 'routing to internal network number not allowed' */
205   bool InternalNetworkNumber_RoutingToInternalNetworkNumberNotAllowed() { return (InternalNetworkNumber == 1); }
206
207
208   /** <pre>
209      Number Incomplete indicator (NI) (only for calling party number)
210      0 complete
211      1 incomplete
212      </pre>
213    */
214   short NumberIncomplete;
215
216   /** Return true when Number Incomplete Indicator is 'complete' */
217   bool NumberIncomplete_Complete() { return (NumberIncomplete == 0); }
218   /** Return true when Number Incomplete Indicator is 'incomplete' */
219   bool NumberIncomplete_Incomplete() { return (NumberIncomplete == 1); }
220
221
222   /** <pre>
223      Numbering plan indicator
224      0 0 0 spare
225      0 0 1 ISDN (Telephony) numbering plan (ITU-T Recommendation E.164)
226      0 1 0 spare
227      0 1 1 Data numbering plan (ITU-T Recommendation X.121) (national use)
228      1 0 0 Telex numbering plan (ITU-T Recommendation F.69) (national use)
229      1 0 1 reserved for national use
230      1 1 0 reserved for national use
231      1 1 1 spare
232      </pre>
233    */
234   short NumberingPlan;
235
236   /** Return true when Numbering Plan is 'ISDN (Telephony) numbering plan (ITU-T Recommendation E.164)' */
237   bool NumberingPlan_ISDN() { return (NumberingPlan == 1); }
238   /** Return true when Numbering Plan is 'Data numbering plan (ITU-T Recommendation X.121) (national use)' */
239   bool NumberingPlan_Data() { return (NumberingPlan == 3); }
240   /** Return true when Numbering Plan is 'Telex numbering plan (ITU-T Recommendation F.69) (national use)' */
241   bool NumberingPlan_Telex() { return (NumberingPlan == 4); }
242
243
244   /** <pre>
245      Address presentation restricted indicator (only for calling party number)
246      0 0 presentation allowed
247      0 1 presentation restricted
248      1 0 address not available (Note 1) (national use)
249      1 1 reserved for restriction by the network
250      NOTE 1 \96 If the parameter is included and the address presentation restricted indicator indicates
251      address not available, octets 3 to n are omitted, the subfields in items 'OddEven', 'NatureOfAddress',
252      'NumberIncomplete' and 'NumberingPlan' are coded with 0's, and the subfield 'Screening' is coded with 11.
253      </pre>
254    */
255   short AddressPresentationRestricted;
256
257   /** Return true when Address Presentation Restricted is 'presentation allowed' */
258   bool AddressPresentationRestricted_PresentationAllowed() { return (AddressPresentationRestricted == 0); }
259   /** Return true when Address Presentation Restricted is 'presentation restricted' */
260   bool AddressPresentationRestricted_PresentationRestricted() { return (AddressPresentationRestricted == 1); }
261   /** Return true when Address Presentation Restricted is 'address not available (Note 1) (national use)' */
262   bool AddressPresentationRestricted_AddressNotAvailable() { return (AddressPresentationRestricted == 2); }
263   /** Return true when Address Presentation Restricted is 'reserved for restriction by the network' */
264   bool AddressPresentationRestricted_ReservedForRestrictionByTheNetwork() { return (AddressPresentationRestricted == 3); }
265
266
267   /** <pre>
268      Screening indicator (only for calling party number)
269      0 0 reserved (Note 2)
270      0 1 user provided, verified and passed
271      1 0 reserved (Note 2)
272      1 1 network provided
273      NOTE 2 \96 Code 00 and 10 are reserved for "user provided, not verified" and "user provided, verified
274      and failed" respectively. Codes 00 and 10 are for national use.
275      </pre>
276    */
277   short Screening;
278
279   /** Return true when Screening is 'user provided, verified and passed' */
280   bool Screening_UserProvidedVerifiedAndPassed() { return (Screening == 1); }
281   /** Return true when Screening is 'network provided' */
282   bool Screening_NetworkProvided() { return (Screening == 3); }
283
284
285   /** <pre>
286      BCD digit
287      Address signal
288      0 0 0 0 digit 0
289      0 0 0 1 digit 1
290      0 0 1 0 digit 2
291      0 0 1 1 digit 3
292      0 1 0 0 digit 4
293      0 1 0 1 digit 5
294      0 1 1 0 digit 6
295      0 1 1 1 digit 7
296      1 0 0 0 digit 8
297      1 0 0 1 digit 9
298      1 0 1 0 spare
299      1 0 1 1 code 11
300      1 1 0 0 code 12
301      1 1 0 1 spare
302      1 1 1 0 spare
303      1 1 1 1 ST (for called party number, spare in calling party number)
304      The most significant address signal is sent first. Subsequent address signals are sent in
305      successive 4-bit fields.
306
307      Filler: In case of an odd number of address signals, the filler code 0000 is inserted after the last
308              address signal.
309      </pre>
310    */
311   std::string Digits;
312
313   void reset() {
314     OddEven = 0;
315     NatureOfAddress = 0;
316     InternalNetworkNumber = 0;
317     NumberIncomplete = 0;
318     NumberingPlan = 0;
319     AddressPresentationRestricted = 0;
320     Screening = 0;
321     Digits = "";
322   }
323
324   /**
325   * Class string representation
326   *
327   * @param calledOrCalling Boolean about being called party number or calling one
328   *
329   * @return String with class content
330   */
331   std::string asString(bool calledOrCalling) {
332     std::string result;
333     char aux [16];
334     result = "OddEven: ";
335     sprintf(aux, "%d", OddEven); result += std::string(aux);
336     result += " | NatureOfAddress: ";
337
338     if(calledOrCalling) {
339       sprintf(aux, "%d", NatureOfAddress); result += std::string(aux);
340       result += " | InternalNetworkNumber: ";
341     } else {
342       sprintf(aux, "%d", InternalNetworkNumber); result += std::string(aux);
343       result += " | NumberIncomplete: ";
344     }
345
346     sprintf(aux, "%d", NumberIncomplete); result += std::string(aux);
347     result += " | NumberingPlan: ";
348     sprintf(aux, "%d", NumberingPlan); result += std::string(aux);
349
350     if(!calledOrCalling) {
351       result += " | AddressPresentationRestricted: ";
352       sprintf(aux, "%d", AddressPresentationRestricted); result += std::string(aux);
353       result += " | Screening: ";
354       sprintf(aux, "%d", Screening); result += std::string(aux);
355     }
356
357     result += " | Digits: ";
358     result += (Digits != "") ? Digits : "<null>";
359     return result;
360   }
361
362 //   int getEncodedLength() {
363 //
364 //      bool filler = OddEven;
365 //      bool hasDigits = (Digits.size() > 0);
366 //      return (2 + Digits.size()/2 + ((hasDigits && filler) ? 1:0));
367 //   }
368
369 } isup_number_t; // ISDN user part parameters
370
371
372 /**
373 * IANA Address Family Numbers
374 * @see http://www.iana.org/assignments/address-family-numbers/address-family-numbers.xml
375 */
376 typedef struct {
377   enum _v {
378     //Number    Description                                          Reference
379     //------    ---------------------------------------------------- ---------
380     //     0    Reserved
381     IPv4 = 1, //IP (IP version 4)
382     IPv6 = 2, //IP6 (IP version 6)
383     //     3    NSAP
384     //     4    HDLC (8-bit multidrop)
385     //     5    BBN 1822
386     //     6    802 (includes all 802 media plus Ethernet "canonical format")
387     //     7    E.163
388     E164 = 8  //E.164 (SMDS, Frame Relay, ATM)
389     //     9    F.69 (Telex)
390     //    10    X.121 (X.25, Frame Relay)
391     //    11    IPX
392     //    12    Appletalk
393     //    13    Decnet IV
394     //    14    Banyan Vines
395     //    15    E.164 with NSAP format subaddress           [UNI-3.1] [Andy_Malis]
396     //    16    DNS (Domain Name System)
397     //    17    Distinguished Name                                    [Charles_Lynn]
398     //    18    AS Number                                             [Charles_Lynn]
399     //    19    XTP over IP version 4                                 [Mike_Saul]
400     //    20    XTP over IP version 6                                 [Mike_Saul]
401     //    21    XTP native mode XTP                                   [Mike_Saul]
402     //    22    Fibre Channel World-Wide Port Name                   [Mark_Bakke]
403     //    23    Fibre Channel World-Wide Node Name                   [Mark_Bakke]
404     //    24    GWID                                                 [Subra_Hegde]
405     //    25    AFI for L2VPN information [RFC4761][RFC6074]
406     //    26-16383 Unassigned
407     //    16384 EIGRP Common Service Family [Donnie_Savage] 2008-05-13
408     //    16385 EIGRP IPv4 Service Family [Donnie_Savage] 2008-05-13
409     //    16386 EIGRP IPv6 Service Family [Donnie_Savage] 2008-05-13
410     //    16387 LISP Canonical Address Format (LCAF) [David_Meyer] 2009-11-12
411     //    16388-32767 Unassigned
412     //    32768-65534 Unassigned
413     //    65535 Reserved
414   };
415
416   /**
417   * Version description
418   * @param v Version type
419   * @return Version description
420   */
421   static const char* asText(const _v v) throw() { // anna_declare_enum is not safe, because labels don't have to match a sequence
422     if(v == IPv4) return "IPv4";
423
424     if(v == IPv6) return "IPv6";
425
426     if(v == E164) return "E164";
427
428     return NULL;
429   }
430
431 } iana_address_version_t;
432
433
434 /**
435    Struct for IANA Addresses
436 */
437 typedef struct {
438
439   /** address version */
440   U16 Version;
441
442   /** address printable value. No checkings are done regarding specific version (application responsability) */
443   std::string Value;
444
445
446   /** Gets the address version */
447   const U16 & getVersion() const throw() { return Version; }
448
449   /** Gets the address printable value */
450   const char * getValue() const throw() { return Value.c_str(); }
451
452
453   // Helpers
454
455   /** Return true when is an IPv4 address */
456   bool isIPv4() const throw() { return ((iana_address_version_t::_v)Version == iana_address_version_t::IPv4); }
457   /** Return true when is an IPv6 address */
458   bool isIPv6() const throw() { return ((iana_address_version_t::_v)Version == iana_address_version_t::IPv6); }
459   /** Return true when is an E164 (SMDS, Frame Relay, ATM) address */
460   bool isE164() const throw() { return ((iana_address_version_t::_v)Version == iana_address_version_t::E164); }
461
462   /** Sets version for IPv4 address and address itself. Checking is not performed (could assign IPv6 instead ...) */
463   void setIPv4(const char *value) throw() { Version = iana_address_version_t::IPv4; Value = value ? value : ""; }
464
465   /** Sets version for IPv6 address and address itself. Checking is not performed (could assign IPv4 instead ...) */
466   void setIPv6(const char *value) throw() { Version = iana_address_version_t::IPv6; Value = value ? value : ""; }
467
468   /** Sets version for E164 address and address itself. Checking is not performed ... */
469   void setE164(const char *value) throw() { Version = iana_address_version_t::E164; Value = value ? value : ""; }
470
471
472   /**
473   * Class string representation
474   *
475   * @return String with class content
476   */
477   std::string asString() const throw() {
478     std::string result;
479     result += Value.c_str(); // assume that all IANA addresses have a printable representation
480     result += " (";
481     const char *versionAsText = iana_address_version_t::asText((iana_address_version_t::_v)Version);
482
483     if(versionAsText) {
484       result += versionAsText;
485       result += ", ";
486     }
487
488     result += "IANA version '";
489     char aux [16];
490     sprintf(aux, "%d", Version);
491     result += aux;
492     result += "')";
493     return result;
494   }
495
496 } iana_address_t;
497
498
499 };
500
501
502 #endif