3 Serialisation Support Functions
10 Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
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.
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.
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,
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.
43 /* serial_int16 -- Serialise a signed 16 bit integer. */
45 void serial_int16(uint8_t * * const ptr, const int16_t v)
47 int16_t vo = htons(v);
49 memcpy(*ptr, &vo, sizeof vo);
53 /* serial_uint16 -- Serialise an unsigned 16 bit integer. */
55 void serial_uint16(uint8_t * * const ptr, const uint16_t v)
57 uint16_t vo = htons(v);
59 memcpy(*ptr, &vo, sizeof vo);
63 /* serial_int32 -- Serialise a signed 32 bit integer. */
65 void serial_int32(uint8_t * * const ptr, const int32_t v)
67 int32_t vo = htonl(v);
69 memcpy(*ptr, &vo, sizeof vo);
73 /* serial_uint32 -- Serialise an unsigned 32 bit integer. */
75 void serial_uint32(uint8_t * * const ptr, const uint32_t v)
77 uint32_t vo = htonl(v);
79 memcpy(*ptr, &vo, sizeof vo);
83 /* serial_int64 -- Serialise a signed 64 bit integer. */
85 void serial_int64(uint8_t * * const ptr, const int64_t v)
88 memcpy(*ptr, &v, sizeof(int64_t));
91 uint8_t rv[sizeof(int64_t)];
92 uint8_t *pv = (uint8_t *) &v;
94 for (i = 0; i < 8; i++) {
97 memcpy(*ptr, &rv, sizeof(int64_t));
99 *ptr += sizeof(int64_t);
103 /* serial_uint64 -- Serialise an unsigned 64 bit integer. */
105 void serial_uint64(uint8_t * * const ptr, const uint64_t v)
107 if (htonl(1) == 1L) {
108 memcpy(*ptr, &v, sizeof(uint64_t));
111 uint8_t rv[sizeof(uint64_t)];
112 uint8_t *pv = (uint8_t *) &v;
114 for (i = 0; i < 8; i++) {
117 memcpy(*ptr, &rv, sizeof(uint64_t));
119 *ptr += sizeof(uint64_t);
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. */
130 void serial_float64(uint8_t * * const ptr, const float64_t v)
132 if (htonl(1) == 1L) {
133 memcpy(*ptr, &v, sizeof(float64_t));
136 uint8_t rv[sizeof(float64_t)];
137 uint8_t *pv = (uint8_t *) &v;
139 for (i = 0; i < 8; i++) {
142 memcpy(*ptr, &rv, sizeof(float64_t));
144 *ptr += sizeof(float64_t);
147 int serial_string(uint8_t * const ptr, char * const str)
149 int len = strlen((const char *) str) + 1;
150 memcpy(ptr, str, len);
155 /* unserial_int16 -- Unserialise a signed 16 bit integer. */
157 int16_t unserial_int16(uint8_t * * const ptr)
161 memcpy(&vo, *ptr, sizeof vo);
166 /* unserial_uint16 -- Unserialise an unsigned 16 bit integer. */
168 uint16_t unserial_uint16(uint8_t * * const ptr)
172 memcpy(&vo, *ptr, sizeof vo);
177 /* unserial_int32 -- Unserialise a signed 32 bit integer. */
179 int32_t unserial_int32(uint8_t * * const ptr)
183 memcpy(&vo, *ptr, sizeof vo);
188 /* unserial_uint32 -- Unserialise an unsigned 32 bit integer. */
190 uint32_t unserial_uint32(uint8_t * * const ptr)
194 memcpy(&vo, *ptr, sizeof vo);
199 /* unserial_int64 -- Unserialise a signed 64 bit integer. */
201 int64_t unserial_int64(uint8_t * * const ptr)
205 if (htonl(1) == 1L) {
206 memcpy(&v, *ptr, sizeof(int64_t));
209 uint8_t rv[sizeof(int64_t)];
210 uint8_t *pv = (uint8_t *) &v;
212 memcpy(&v, *ptr, sizeof(int64_t));
213 for (i = 0; i < 8; i++) {
216 memcpy(&v, &rv, sizeof(int64_t));
218 *ptr += sizeof(int64_t);
222 /* unserial_uint64 -- Unserialise an unsigned 64 bit integer. */
224 uint64_t unserial_uint64(uint8_t * * const ptr)
228 if (htonl(1) == 1L) {
229 memcpy(&v, *ptr, sizeof(uint64_t));
232 uint8_t rv[sizeof(uint64_t)];
233 uint8_t *pv = (uint8_t *) &v;
235 memcpy(&v, *ptr, sizeof(uint64_t));
236 for (i = 0; i < 8; i++) {
239 memcpy(&v, &rv, sizeof(uint64_t));
241 *ptr += sizeof(uint64_t);
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. */
253 float64_t unserial_float64(uint8_t * * const ptr)
257 if (htonl(1) == 1L) {
258 memcpy(&v, *ptr, sizeof(float64_t));
261 uint8_t rv[sizeof(float64_t)];
262 uint8_t *pv = (uint8_t *) &v;
264 memcpy(&v, *ptr, sizeof(float64_t));
265 for (i = 0; i < 8; i++) {
268 memcpy(&v, &rv, sizeof(float64_t));
270 *ptr += sizeof(float64_t);
274 int unserial_string(uint8_t * const ptr, char * const str)
276 int len = strlen((char *)ptr) + 1;
277 memcpy(str, ptr, len);