git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/serial.h

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2016 Kern Sibbald
   5
   6    The original author of Bacula is Kern Sibbald, with contributions
   7    from many others, a complete list can be found in the file AUTHORS.
   8
   9    You may use this file and others of this release according to the
  10    license defined in the LICENSE file, which includes the Affero General
  11    Public License, v3.0 ("AGPLv3") and some additional permissions and
  12    terms pursuant to its AGPLv3 Section 7.
  13
  14    This notice must be preserved when any source code is
  15    conveyed and/or propagated.
  16
  17    Bacula(R) is a registered trademark of Kern Sibbald.
  18 */
  19 /*
  20  *
  21  * Written by John Walker, MM
  22  *
  23  */
  24
  25 /*  Serialisation support functions from serial.c.  */
  26
  27 extern void serial_int16(uint8_t * * const ptr, const int16_t v);
  28 extern void serial_uint16(uint8_t * * const ptr, const uint16_t v);
  29 extern void serial_int32(uint8_t * * const ptr, const int32_t v);
  30 extern void serial_uint32(uint8_t * * const ptr, const uint32_t v);
  31 extern void serial_int64(uint8_t * * ptr, int64_t v);
  32 extern void serial_uint64(uint8_t * * const ptr, const uint64_t v);
  33 extern void serial_btime(uint8_t * * const ptr, const btime_t v);
  34 extern void serial_float64(uint8_t * * const ptr, const float64_t v);
  35 extern void serial_string(uint8_t * * const ptr, const char * const str);
  36
  37 extern int16_t unserial_int16(uint8_t * * const ptr);
  38 extern uint16_t unserial_uint16(uint8_t * * const ptr);
  39 extern int32_t unserial_int32(uint8_t * * const ptr);
  40 extern uint32_t unserial_uint32(uint8_t * * const ptr);
  41 extern int64_t unserial_int64(uint8_t * * const ptr);
  42 extern uint64_t unserial_uint64(uint8_t * * const ptr);
  43 extern btime_t unserial_btime(uint8_t * * const ptr);
  44 extern float64_t unserial_float64(uint8_t * * const ptr);
  45 extern void unserial_string(uint8_t * * const ptr, char * const str, int max);
  46
  47 /*
  48
  49                          Serialisation Macros
  50
  51     These macros use a uint8_t pointer, ser_ptr, which must be
  52     defined by the code which uses them.
  53
  54 */
  55
  56 #ifndef __SERIAL_H_
  57 #define __SERIAL_H_ 1
  58
  59 /*  ser_declare  --  Declare ser_ptr locally within a function.  */
  60 #define ser_declare     uint8_t *ser_ptr
  61 #define unser_declare   uint8_t *ser_ptr
  62
  63 /*  ser_begin(x, s)  --  Begin serialisation into a buffer x of size s.  */
  64 #define ser_begin(x, s) ser_ptr = ((uint8_t *)(x))
  65 #define unser_begin(x, s) ser_ptr = ((uint8_t *)(x))
  66
  67 /*  ser_length  --  Determine length in bytes of serialised into a
  68                     buffer x.  */
  69 #define ser_length(x)  ((uint32_t)(ser_ptr - (uint8_t *)(x)))
  70 #define unser_length(x) ((uint32_t)(ser_ptr - (uint8_t *)(x)))
  71
  72 /*  ser_end(x, s)  --  End serialisation into a buffer x of size s.  */
  73 #define ser_end(x, s)   ASSERT(ser_length(x) <= ((uint32_t)(s)))
  74 #define unser_end(x, s)   ASSERT(unser_length(x) <= ((uint32_t)(s)))
  75
  76 /*  ser_check(x, s)  --  Verify length of serialised data in buffer x is
  77                          expected length s.  */
  78 #define ser_check(x, s) ASSERT(ser_length(x) == ((uint32_t)(s)))
  79 #define unser_check(x, s) ASSERT(unser_length(x) == ((uint32_t)(s)))
  80
  81 /*  ser_assign(ptr, len) -- assign current position to ptr and go len bytes forward  */
  82 #define ser_assign(ptr, len) { ptr = (typeof(ptr))ser_ptr; ser_ptr += (len); }
  83 #define unser_assign(ptr, len) { ptr = (typeof(ptr))ser_ptr; ser_ptr += (len); }
  84
  85 /*                          Serialisation                   */
  86
  87 /*  8 bit signed integer  */
  88 #define ser_int8(x)     *ser_ptr++ = (x)
  89 /*  8 bit unsigned integer  */
  90 #define ser_uint8(x)    *ser_ptr++ = (x)
  91
  92 /*  16 bit signed integer  */
  93 #define ser_int16(x)    serial_int16(&ser_ptr, x)
  94 /*  16 bit unsigned integer  */
  95 #define ser_uint16(x)   serial_uint16(&ser_ptr, x)
  96
  97 /*  32 bit signed integer  */
  98 #define ser_int32(x)    serial_int32(&ser_ptr, x)
  99 /*  32 bit unsigned integer  */
 100 #define ser_uint32(x)   serial_uint32(&ser_ptr, x)
 101
 102 /*  64 bit signed integer  */
 103 #define ser_int64(x)    serial_int64(&ser_ptr, x)
 104 /*  64 bit unsigned integer  */
 105 #define ser_uint64(x)   serial_uint64(&ser_ptr, x)
 106
 107 /* btime -- 64 bit unsigned integer */
 108 #define ser_btime(x)    serial_btime(&ser_ptr, x)
 109
 110
 111 /*  64 bit IEEE floating point number  */
 112 #define ser_float64(x)  serial_float64(&ser_ptr, x)
 113
 114 /*  128 bit signed integer  */
 115 #define ser_int128(x)   memcpy(ser_ptr, x, sizeof(int128_t)), ser_ptr += sizeof(int128_t)
 116
 117 /*  Binary byte stream len bytes not requiring serialisation  */
 118 #define ser_bytes(x, len) memcpy(ser_ptr, (x), (len)), ser_ptr += (len)
 119
 120 /*  Binary byte stream not requiring serialisation (length obtained by sizeof)  */
 121 #define ser_buffer(x)   ser_bytes((x), (sizeof (x)))
 122
 123 /* Binary string not requiring serialization */
 124 #define ser_string(x)   serial_string(&ser_ptr, (x))
 125
 126 /*                         Unserialisation                  */
 127
 128 /*  8 bit signed integer  */
 129 #define unser_int8(x)   (x) = *ser_ptr++
 130 /*  8 bit unsigned integer  */
 131 #define unser_uint8(x)  (x) = *ser_ptr++
 132
 133 /*  16 bit signed integer  */
 134 #define unser_int16(x)  (x) = unserial_int16(&ser_ptr)
 135 /*  16 bit unsigned integer  */
 136 #define unser_uint16(x) (x) = unserial_uint16(&ser_ptr)
 137
 138 /*  32 bit signed integer  */
 139 #define unser_int32(x)  (x) = unserial_int32(&ser_ptr)
 140 /*  32 bit unsigned integer  */
 141 #define unser_uint32(x) (x) = unserial_uint32(&ser_ptr)
 142
 143 /*  64 bit signed integer  */
 144 #define unser_int64(x)  (x) = unserial_int64(&ser_ptr)
 145 /*  64 bit unsigned integer  */
 146 #define unser_uint64(x) (x) = unserial_uint64(&ser_ptr)
 147
 148 /* btime -- 64 bit unsigned integer */
 149 #define unser_btime(x) (x) = unserial_btime(&ser_ptr)
 150
 151 /*  64 bit IEEE floating point number  */
 152 #define unser_float64(x)(x) = unserial_float64(&ser_ptr)
 153
 154 /*  128 bit signed integer  */
 155 #define unser_int128(x) memcpy(ser_ptr, x, sizeof(int128_t)), ser_ptr += sizeof(int128_t)
 156
 157 /*  Binary byte stream len bytes not requiring serialisation  */
 158 #define unser_bytes(x, len) memcpy((x), ser_ptr, (len)), ser_ptr += (len)
 159
 160 /*  Binary byte stream not requiring serialisation (length obtained by sizeof)  */
 161 #define unser_buffer(x)  unser_bytes((x), (sizeof (x)))
 162
 163 /* Binary string not requiring serialization (length obtained from max) */
 164 #define unser_nstring(x,max) unserial_string(&ser_ptr, (x), (int)(max))
 165
 166 /*  Binary string not requiring serialisation (length obtained by sizeof)  */
 167 #define unser_string(x) unserial_string(&ser_ptr, (x), sizeof(x))
 168
 169 #endif /* __SERIAL_H_ */