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

   1 /*
   2
   3                    Serialisation Support Functions
   4                           John Walker
   5
   6
   7      Version $Id$
   8 */
   9 /*
  10    Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
  11
  12    This program is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation; either version 2 of
  15    the License, or (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20    General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public
  23    License along with this program; if not, write to the Free
  24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  25    MA 02111-1307, USA.
  26
  27  */
  28
  29
  30 #include "bacula.h"
  31 #include "serial.h"
  32
  33 /*
  34
  35         NOTE:  The following functions should work on any
  36                vaguely contemporary platform.  Production
  37                builds should use optimised macros (void
  38                on platforms with network byte order and IEEE
  39                floating point format as native.
  40
  41 */
  42
  43 /*  serial_int16  --  Serialise a signed 16 bit integer.  */
  44
  45 void serial_int16(uint8_t * * const ptr, const int16_t v)
  46 {
  47     int16_t vo = htons(v);
  48
  49     memcpy(*ptr, &vo, sizeof vo);
  50     *ptr += sizeof vo;
  51 }
  52
  53 /*  serial_uint16  --  Serialise an unsigned 16 bit integer.  */
  54
  55 void serial_uint16(uint8_t * * const ptr, const uint16_t v)
  56 {
  57     uint16_t vo = htons(v);
  58
  59     memcpy(*ptr, &vo, sizeof vo);
  60     *ptr += sizeof vo;
  61 }
  62
  63 /*  serial_int32  --  Serialise a signed 32 bit integer.  */
  64
  65 void serial_int32(uint8_t * * const ptr, const int32_t v)
  66 {
  67     int32_t vo = htonl(v);
  68
  69     memcpy(*ptr, &vo, sizeof vo);
  70     *ptr += sizeof vo;
  71 }
  72
  73 /*  serial_uint32  --  Serialise an unsigned 32 bit integer.  */
  74
  75 void serial_uint32(uint8_t * * const ptr, const uint32_t v)
  76 {
  77     uint32_t vo = htonl(v);
  78
  79     memcpy(*ptr, &vo, sizeof vo);
  80     *ptr += sizeof vo;
  81 }
  82
  83 /*  serial_int64  --  Serialise a signed 64 bit integer.  */
  84
  85 void serial_int64(uint8_t * * const ptr, const int64_t v)
  86 {
  87     if (htonl(1) == 1L) {
  88         memcpy(*ptr, &v, sizeof(int64_t));
  89     } else {
  90         int i;
  91         uint8_t rv[sizeof(int64_t)];
  92         uint8_t *pv = (uint8_t *) &v;
  93
  94         for (i = 0; i < 8; i++) {
  95             rv[i] = pv[7 - i];
  96         }
  97         memcpy(*ptr, &rv, sizeof(int64_t));
  98     }
  99     *ptr += sizeof(int64_t);
 100 }
 101
 102
 103 /*  serial_uint64  --  Serialise an unsigned 64 bit integer.  */
 104
 105 void serial_uint64(uint8_t * * const ptr, const uint64_t v)
 106 {
 107     if (htonl(1) == 1L) {
 108         memcpy(*ptr, &v, sizeof(uint64_t));
 109     } else {
 110         int i;
 111         uint8_t rv[sizeof(uint64_t)];
 112         uint8_t *pv = (uint8_t *) &v;
 113
 114         for (i = 0; i < 8; i++) {
 115             rv[i] = pv[7 - i];
 116         }
 117         memcpy(*ptr, &rv, sizeof(uint64_t));
 118     }
 119     *ptr += sizeof(uint64_t);
 120 }
 121
 122
 123 /*  serial_float64  --  Serialise a 64 bit IEEE floating point number.
 124                         This code assumes that the host floating point
 125                         format is IEEE and that floating point quantities
 126                         are stored in IEEE format either LSB first or MSB
 127                         first.  More creative host formats will require
 128                         additional transformations here.  */
 129
 130 void serial_float64(uint8_t * * const ptr, const float64_t v)
 131 {
 132     if (htonl(1) == 1L) {
 133         memcpy(*ptr, &v, sizeof(float64_t));
 134     } else {
 135         int i;
 136         uint8_t rv[sizeof(float64_t)];
 137         uint8_t *pv = (uint8_t *) &v;
 138
 139         for (i = 0; i < 8; i++) {
 140             rv[i] = pv[7 - i];
 141         }
 142         memcpy(*ptr, &rv, sizeof(float64_t));
 143     }
 144     *ptr += sizeof(float64_t);
 145 }
 146
 147 int serial_string(uint8_t * const ptr, char * const str)
 148 {
 149    int len = strlen((const char *) str) + 1;
 150    memcpy(ptr, str, len);
 151    return len;
 152 }
 153
 154
 155 /*  unserial_int16  --  Unserialise a signed 16 bit integer.  */
 156
 157 int16_t unserial_int16(uint8_t * * const ptr)
 158 {
 159     int16_t vo;
 160
 161     memcpy(&vo, *ptr, sizeof vo);
 162     *ptr += sizeof vo;
 163     return ntohs(vo);
 164 }
 165
 166 /*  unserial_uint16  --  Unserialise an unsigned 16 bit integer.  */
 167
 168 uint16_t unserial_uint16(uint8_t * * const ptr)
 169 {
 170     uint16_t vo;
 171
 172     memcpy(&vo, *ptr, sizeof vo);
 173     *ptr += sizeof vo;
 174     return ntohs(vo);
 175 }
 176
 177 /*  unserial_int32  --  Unserialise a signed 32 bit integer.  */
 178
 179 int32_t unserial_int32(uint8_t * * const ptr)
 180 {
 181     int32_t vo;
 182
 183     memcpy(&vo, *ptr, sizeof vo);
 184     *ptr += sizeof vo;
 185     return ntohl(vo);
 186 }
 187
 188 /*  unserial_uint32  --  Unserialise an unsigned 32 bit integer.  */
 189
 190 uint32_t unserial_uint32(uint8_t * * const ptr)
 191 {
 192     uint32_t vo;
 193
 194     memcpy(&vo, *ptr, sizeof vo);
 195     *ptr += sizeof vo;
 196     return ntohl(vo);
 197 }
 198
 199 /*  unserial_int64  --  Unserialise a signed 64 bit integer.  */
 200
 201 int64_t unserial_int64(uint8_t * * const ptr)
 202 {
 203     int64_t v;
 204
 205     if (htonl(1) == 1L) {
 206         memcpy(&v, *ptr, sizeof(int64_t));
 207     } else {
 208         int i;
 209         uint8_t rv[sizeof(int64_t)];
 210         uint8_t *pv = (uint8_t *) &v;
 211
 212         memcpy(&v, *ptr, sizeof(int64_t));
 213         for (i = 0; i < 8; i++) {
 214             rv[i] = pv[7 - i];
 215         }
 216         memcpy(&v, &rv, sizeof(int64_t));
 217     }
 218     *ptr += sizeof(int64_t);
 219     return v;
 220 }
 221
 222 /*  unserial_uint64  --  Unserialise an unsigned 64 bit integer.  */
 223
 224 uint64_t unserial_uint64(uint8_t * * const ptr)
 225 {
 226     uint64_t v;
 227
 228     if (htonl(1) == 1L) {
 229         memcpy(&v, *ptr, sizeof(uint64_t));
 230     } else {
 231         int i;
 232         uint8_t rv[sizeof(uint64_t)];
 233         uint8_t *pv = (uint8_t *) &v;
 234
 235         memcpy(&v, *ptr, sizeof(uint64_t));
 236         for (i = 0; i < 8; i++) {
 237             rv[i] = pv[7 - i];
 238         }
 239         memcpy(&v, &rv, sizeof(uint64_t));
 240     }
 241     *ptr += sizeof(uint64_t);
 242     return v;
 243 }
 244
 245
 246 /*  unserial_float64  --  Unserialise a 64 bit IEEE floating point number.
 247                          This code assumes that the host floating point
 248                          format is IEEE and that floating point quantities
 249                          are stored in IEEE format either LSB first or MSB
 250                          first.  More creative host formats will require
 251                          additional transformations here.  */
 252
 253 float64_t unserial_float64(uint8_t * * const ptr)
 254 {
 255     float64_t v;
 256
 257     if (htonl(1) == 1L) {
 258         memcpy(&v, *ptr, sizeof(float64_t));
 259     } else {
 260         int i;
 261         uint8_t rv[sizeof(float64_t)];
 262         uint8_t *pv = (uint8_t *) &v;
 263
 264         memcpy(&v, *ptr, sizeof(float64_t));
 265         for (i = 0; i < 8; i++) {
 266             rv[i] = pv[7 - i];
 267         }
 268         memcpy(&v, &rv, sizeof(float64_t));
 269     }
 270     *ptr += sizeof(float64_t);
 271     return v;
 272 }
 273
 274 int unserial_string(uint8_t  * const ptr, char * const str)
 275 {
 276    int len = strlen((char *)ptr) + 1;
 277    memcpy(str, ptr, len);
 278    return len;
 279 }