2 Bacula® - The Network Backup Solution
4 Copyright (C) 2000-2010 Free Software Foundation Europe e.V.
6 The main author of Bacula is Kern Sibbald, with contributions from
7 many others, a complete list can be found in the file AUTHORS.
8 This program is Free Software; you can redistribute it and/or
9 modify it under the terms of version three of the GNU Affero General Public
10 License as published by the Free Software Foundation and included
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 General Public License for more details.
18 You should have received a copy of the GNU Affero General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 Bacula® is a registered trademark ofKern Sibbald.
24 The licensor of Bacula is the Free Software Foundation Europe
25 (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
26 Switzerland, email:ftf@fsfeurope.org.
30 * Written by John Walker, MM
34 /* Serialisation support functions from serial.c. */
36 extern void serial_int16(uint8_t * * const ptr, const int16_t v);
37 extern void serial_uint16(uint8_t * * const ptr, const uint16_t v);
38 extern void serial_int32(uint8_t * * const ptr, const int32_t v);
39 extern void serial_uint32(uint8_t * * const ptr, const uint32_t v);
40 extern void serial_int64(uint8_t * * ptr, int64_t v);
41 extern void serial_uint64(uint8_t * * const ptr, const uint64_t v);
42 extern void serial_btime(uint8_t * * const ptr, const btime_t v);
43 extern void serial_float64(uint8_t * * const ptr, const float64_t v);
44 extern void serial_string(uint8_t * * const ptr, const char * const str);
46 extern int16_t unserial_int16(uint8_t * * const ptr);
47 extern uint16_t unserial_uint16(uint8_t * * const ptr);
48 extern int32_t unserial_int32(uint8_t * * const ptr);
49 extern uint32_t unserial_uint32(uint8_t * * const ptr);
50 extern int64_t unserial_int64(uint8_t * * const ptr);
51 extern uint64_t unserial_uint64(uint8_t * * const ptr);
52 extern btime_t unserial_btime(uint8_t * * const ptr);
53 extern float64_t unserial_float64(uint8_t * * const ptr);
54 extern void unserial_string(uint8_t * * const ptr, char * const str, int max);
60 These macros use a uint8_t pointer, ser_ptr, which must be
61 defined by the code which uses them.
68 /* ser_declare -- Declare ser_ptr locally within a function. */
69 #define ser_declare uint8_t *ser_ptr
70 #define unser_declare uint8_t *ser_ptr
72 /* ser_begin(x, s) -- Begin serialisation into a buffer x of size s. */
73 #define ser_begin(x, s) ser_ptr = ((uint8_t *)(x))
74 #define unser_begin(x, s) ser_ptr = ((uint8_t *)(x))
76 /* ser_length -- Determine length in bytes of serialised into a
78 #define ser_length(x) ((uint32_t)(ser_ptr - (uint8_t *)(x)))
79 #define unser_length(x) ((uint32_t)(ser_ptr - (uint8_t *)(x)))
81 /* ser_end(x, s) -- End serialisation into a buffer x of size s. */
82 #define ser_end(x, s) ASSERT(ser_length(x) <= (s))
83 #define unser_end(x, s) ASSERT(ser_length(x) <= (s))
85 /* ser_check(x, s) -- Verify length of serialised data in buffer x is
87 #define ser_check(x, s) ASSERT(ser_length(x) == (s))
91 /* 8 bit signed integer */
92 #define ser_int8(x) *ser_ptr++ = (x)
93 /* 8 bit unsigned integer */
94 #define ser_uint8(x) *ser_ptr++ = (x)
96 /* 16 bit signed integer */
97 #define ser_int16(x) serial_int16(&ser_ptr, x)
98 /* 16 bit unsigned integer */
99 #define ser_uint16(x) serial_uint16(&ser_ptr, x)
101 /* 32 bit signed integer */
102 #define ser_int32(x) serial_int32(&ser_ptr, x)
103 /* 32 bit unsigned integer */
104 #define ser_uint32(x) serial_uint32(&ser_ptr, x)
106 /* 64 bit signed integer */
107 #define ser_int64(x) serial_int64(&ser_ptr, x)
108 /* 64 bit unsigned integer */
109 #define ser_uint64(x) serial_uint64(&ser_ptr, x)
111 /* btime -- 64 bit unsigned integer */
112 #define ser_btime(x) serial_btime(&ser_ptr, x)
115 /* 64 bit IEEE floating point number */
116 #define ser_float64(x) serial_float64(&ser_ptr, x)
118 /* 128 bit signed integer */
119 #define ser_int128(x) memcpy(ser_ptr, x, sizeof(int128_t)), ser_ptr += sizeof(int128_t)
121 /* Binary byte stream len bytes not requiring serialisation */
122 #define ser_bytes(x, len) memcpy(ser_ptr, (x), (len)), ser_ptr += (len)
124 /* Binary byte stream not requiring serialisation (length obtained by sizeof) */
125 #define ser_buffer(x) ser_bytes((x), (sizeof (x)))
127 /* Binary string not requiring serialization */
128 #define ser_string(x) serial_string(&ser_ptr, (x))
130 /* Unserialisation */
132 /* 8 bit signed integer */
133 #define unser_int8(x) (x) = *ser_ptr++
134 /* 8 bit unsigned integer */
135 #define unser_uint8(x) (x) = *ser_ptr++
137 /* 16 bit signed integer */
138 #define unser_int16(x) (x) = unserial_int16(&ser_ptr)
139 /* 16 bit unsigned integer */
140 #define unser_uint16(x) (x) = unserial_uint16(&ser_ptr)
142 /* 32 bit signed integer */
143 #define unser_int32(x) (x) = unserial_int32(&ser_ptr)
144 /* 32 bit unsigned integer */
145 #define unser_uint32(x) (x) = unserial_uint32(&ser_ptr)
147 /* 64 bit signed integer */
148 #define unser_int64(x) (x) = unserial_int64(&ser_ptr)
149 /* 64 bit unsigned integer */
150 #define unser_uint64(x) (x) = unserial_uint64(&ser_ptr)
152 /* btime -- 64 bit unsigned integer */
153 #define unser_btime(x) (x) = unserial_btime(&ser_ptr)
155 /* 64 bit IEEE floating point number */
156 #define unser_float64(x)(x) = unserial_float64(&ser_ptr)
158 /* 128 bit signed integer */
159 #define unser_int128(x) memcpy(ser_ptr, x, sizeof(int128_t)), ser_ptr += sizeof(int128_t)
161 /* Binary byte stream len bytes not requiring serialisation */
162 #define unser_bytes(x, len) memcpy((x), ser_ptr, (len)), ser_ptr += (len)
164 /* Binary byte stream not requiring serialisation (length obtained by sizeof) */
165 #define unser_buffer(x) unser_bytes((x), (sizeof (x)))
167 /* Binary string not requiring serialization (length obtained from max) */
168 #define unser_nstring(x,max) unserial_string(&ser_ptr, (x), (int)(max))
170 /* Binary string not requiring serialisation (length obtained by sizeof) */
171 #define unser_string(x) unserial_string(&ser_ptr, (x), sizeof(x))
173 #endif /* __SERIAL_H_ */