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

   1 /*
   2
   3                    Serialisation Support Functions
   4                           John Walker
   5 */
   6 /*
   7    Bacula® - The Network Backup Solution
   8
   9    Copyright (C) 2000-2014 Free Software Foundation Europe e.V.
  10
  11    The main author of Bacula is Kern Sibbald, with contributions from many
  12    others, a complete list can be found in the file AUTHORS.
  13
  14    You may use this file and others of this release according to the
  15    license defined in the LICENSE file, which includes the Affero General
  16    Public License, v3.0 ("AGPLv3") and some additional permissions and
  17    terms pursuant to its AGPLv3 Section 7.
  18
  19    Bacula® is a registered trademark of Kern Sibbald.
  20 */
  21
  22
  23 #include "bacula.h"
  24 #include "serial.h"
  25
  26 /*
  27
  28         NOTE:  The following functions should work on any
  29                vaguely contemporary platform.  Production
  30                builds should use optimised macros (void
  31                on platforms with network byte order and IEEE
  32                floating point format as native.
  33
  34 */
  35
  36 /*  serial_int16  --  Serialise a signed 16 bit integer.  */
  37
  38 void serial_int16(uint8_t * * const ptr, const int16_t v)
  39 {
  40     int16_t vo = htons(v);
  41
  42     memcpy(*ptr, &vo, sizeof vo);
  43     *ptr += sizeof vo;
  44 }
  45
  46 /*  serial_uint16  --  Serialise an unsigned 16 bit integer.  */
  47
  48 void serial_uint16(uint8_t * * const ptr, const uint16_t v)
  49 {
  50     uint16_t vo = htons(v);
  51
  52     memcpy(*ptr, &vo, sizeof vo);
  53     *ptr += sizeof vo;
  54 }
  55
  56 /*  serial_int32  --  Serialise a signed 32 bit integer.  */
  57
  58 void serial_int32(uint8_t * * const ptr, const int32_t v)
  59 {
  60     int32_t vo = htonl(v);
  61
  62     memcpy(*ptr, &vo, sizeof vo);
  63     *ptr += sizeof vo;
  64 }
  65
  66 /*  serial_uint32  --  Serialise an unsigned 32 bit integer.  */
  67
  68 void serial_uint32(uint8_t * * const ptr, const uint32_t v)
  69 {
  70     uint32_t vo = htonl(v);
  71
  72     memcpy(*ptr, &vo, sizeof vo);
  73     *ptr += sizeof vo;
  74 }
  75
  76 /*  serial_int64  --  Serialise a signed 64 bit integer.  */
  77
  78 void serial_int64(uint8_t * * const ptr, const int64_t v)
  79 {
  80     if (bigendian()) {
  81         memcpy(*ptr, &v, sizeof(int64_t));
  82     } else {
  83         int i;
  84         uint8_t rv[sizeof(int64_t)];
  85         uint8_t *pv = (uint8_t *) &v;
  86
  87         for (i = 0; i < 8; i++) {
  88             rv[i] = pv[7 - i];
  89         }
  90         memcpy(*ptr, &rv, sizeof(int64_t));
  91     }
  92     *ptr += sizeof(int64_t);
  93 }
  94
  95
  96 /*  serial_uint64  --  Serialise an unsigned 64 bit integer.  */
  97
  98 void serial_uint64(uint8_t * * const ptr, const uint64_t v)
  99 {
 100     if (bigendian()) {
 101         memcpy(*ptr, &v, sizeof(uint64_t));
 102     } else {
 103         int i;
 104         uint8_t rv[sizeof(uint64_t)];
 105         uint8_t *pv = (uint8_t *) &v;
 106
 107         for (i = 0; i < 8; i++) {
 108             rv[i] = pv[7 - i];
 109         }
 110         memcpy(*ptr, &rv, sizeof(uint64_t));
 111     }
 112     *ptr += sizeof(uint64_t);
 113 }
 114
 115
 116 /*  serial_btime  --  Serialise an btime_t 64 bit integer.  */
 117
 118 void serial_btime(uint8_t * * const ptr, const btime_t v)
 119 {
 120     if (bigendian()) {
 121         memcpy(*ptr, &v, sizeof(btime_t));
 122     } else {
 123         int i;
 124         uint8_t rv[sizeof(btime_t)];
 125         uint8_t *pv = (uint8_t *) &v;
 126
 127         for (i = 0; i < 8; i++) {
 128             rv[i] = pv[7 - i];
 129         }
 130         memcpy(*ptr, &rv, sizeof(btime_t));
 131     }
 132     *ptr += sizeof(btime_t);
 133 }
 134
 135
 136
 137 /*  serial_float64  --  Serialise a 64 bit IEEE floating point number.
 138                         This code assumes that the host floating point
 139                         format is IEEE and that floating point quantities
 140                         are stored in IEEE format either LSB first or MSB
 141                         first.  More creative host formats will require
 142                         additional transformations here.  */
 143
 144 void serial_float64(uint8_t * * const ptr, const float64_t v)
 145 {
 146     if (bigendian()) {
 147         memcpy(*ptr, &v, sizeof(float64_t));
 148     } else {
 149         int i;
 150         uint8_t rv[sizeof(float64_t)];
 151         uint8_t *pv = (uint8_t *) &v;
 152
 153         for (i = 0; i < 8; i++) {
 154             rv[i] = pv[7 - i];
 155         }
 156         memcpy(*ptr, &rv, sizeof(float64_t));
 157     }
 158     *ptr += sizeof(float64_t);
 159 }
 160
 161 void serial_string(uint8_t * * const ptr, const char * const str)
 162 {
 163    int i;
 164    char *dest = (char *)*ptr;
 165    char *src = (char *)str;
 166    for (i=0; src[i] != 0;  i++) {
 167       dest[i] = src[i];
 168    }
 169    dest[i++] = 0;                  /* terminate output string */
 170    *ptr += i;                      /* update pointer */
 171 // Dmsg2(000, "ser src=%s dest=%s\n", src, dest);
 172 }
 173
 174
 175 /*  unserial_int16  --  Unserialise a signed 16 bit integer.  */
 176
 177 int16_t unserial_int16(uint8_t * * const ptr)
 178 {
 179     int16_t vo;
 180
 181     memcpy(&vo, *ptr, sizeof vo);
 182     *ptr += sizeof vo;
 183     return ntohs(vo);
 184 }
 185
 186 /*  unserial_uint16  --  Unserialise an unsigned 16 bit integer.  */
 187
 188 uint16_t unserial_uint16(uint8_t * * const ptr)
 189 {
 190     uint16_t vo;
 191
 192     memcpy(&vo, *ptr, sizeof vo);
 193     *ptr += sizeof vo;
 194     return ntohs(vo);
 195 }
 196
 197 /*  unserial_int32  --  Unserialise a signed 32 bit integer.  */
 198
 199 int32_t unserial_int32(uint8_t * * const ptr)
 200 {
 201     int32_t vo;
 202
 203     memcpy(&vo, *ptr, sizeof vo);
 204     *ptr += sizeof vo;
 205     return ntohl(vo);
 206 }
 207
 208 /*  unserial_uint32  --  Unserialise an unsigned 32 bit integer.  */
 209
 210 uint32_t unserial_uint32(uint8_t * * const ptr)
 211 {
 212     uint32_t vo;
 213
 214     memcpy(&vo, *ptr, sizeof vo);
 215     *ptr += sizeof vo;
 216     return ntohl(vo);
 217 }
 218
 219 /*  unserial_uint64  --  Unserialise an unsigned 64 bit integer.  */
 220
 221 uint64_t unserial_uint64(uint8_t * * const ptr)
 222 {
 223     uint64_t v;
 224
 225     if (bigendian()) {
 226         memcpy(&v, *ptr, sizeof(uint64_t));
 227     } else {
 228         int i;
 229         uint8_t rv[sizeof(uint64_t)];
 230         uint8_t *pv = (uint8_t *) &v;
 231
 232         memcpy(&v, *ptr, sizeof(uint64_t));
 233         for (i = 0; i < 8; i++) {
 234             rv[i] = pv[7 - i];
 235         }
 236         memcpy(&v, &rv, sizeof(uint64_t));
 237     }
 238     *ptr += sizeof(uint64_t);
 239     return v;
 240 }
 241
 242 /*  unserial_btime  --  Unserialise a btime_t 64 bit integer.  */
 243
 244 btime_t unserial_btime(uint8_t * * const ptr)
 245 {
 246     btime_t v;
 247
 248     if (bigendian()) {
 249         memcpy(&v, *ptr, sizeof(btime_t));
 250     } else {
 251         int i;
 252         uint8_t rv[sizeof(btime_t)];
 253         uint8_t *pv = (uint8_t *) &v;
 254
 255         memcpy(&v, *ptr, sizeof(btime_t));
 256         for (i = 0; i < 8; i++) {
 257             rv[i] = pv[7 - i];
 258         }
 259         memcpy(&v, &rv, sizeof(btime_t));
 260     }
 261     *ptr += sizeof(btime_t);
 262     return v;
 263 }
 264
 265
 266
 267 /*  unserial_float64  --  Unserialise a 64 bit IEEE floating point number.
 268                          This code assumes that the host floating point
 269                          format is IEEE and that floating point quantities
 270                          are stored in IEEE format either LSB first or MSB
 271                          first.  More creative host formats will require
 272                          additional transformations here.  */
 273
 274 float64_t unserial_float64(uint8_t * * const ptr)
 275 {
 276     float64_t v;
 277
 278     if (bigendian()) {
 279         memcpy(&v, *ptr, sizeof(float64_t));
 280     } else {
 281         int i;
 282         uint8_t rv[sizeof(float64_t)];
 283         uint8_t *pv = (uint8_t *) &v;
 284
 285         memcpy(&v, *ptr, sizeof(float64_t));
 286         for (i = 0; i < 8; i++) {
 287             rv[i] = pv[7 - i];
 288         }
 289         memcpy(&v, &rv, sizeof(float64_t));
 290     }
 291     *ptr += sizeof(float64_t);
 292     return v;
 293 }
 294
 295 void unserial_string(uint8_t * * const ptr, char * const str, int max)
 296 {
 297    int i;
 298    char *src = (char*)(*ptr);
 299    char *dest = str;
 300    for (i=0; i<max && src[i] != 0;  i++) {
 301       dest[i] = src[i];
 302    }
 303    dest[i++] = 0;            /* terminate output string */
 304    *ptr += i;                /* update pointer */
 305 // Dmsg2(000, "unser src=%s dest=%s\n", src, dest);
 306 }