X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=bacula%2Fsrc%2Flib%2Fserial.h;h=f3adaab0d890921efba1e0c7f074f5b2f63bcce9;hb=cb6c193f8df8207fd7b58fcfe50c6dcde23cc440;hp=7066e776b893727b855869cef992f511740137d8;hpb=1ef84681d13d0c355d6ae78579d2afe1c8d8d0e2;p=bacula%2Fbacula

diff --git a/bacula/src/lib/serial.h b/bacula/src/lib/serial.h
index 7066e776b8..f3adaab0d8 100644
--- a/bacula/src/lib/serial.h
+++ b/bacula/src/lib/serial.h
@@ -1,4 +1,7 @@
-
+/*
+ *
+ *   Version $Id$
+ */
 
 /*
    Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
@@ -41,7 +44,7 @@ extern int unserial_string(uint8_t * ptr, char * str);
 
 /*
 
-                         Serialisation Macros
+			 Serialisation Macros
 
     These macros use a uint8_t pointer, ser_ptr, which must be
     defined by the code which uses them.
@@ -52,83 +55,83 @@ extern int unserial_string(uint8_t * ptr, char * str);
 #define __SERIAL_H_ 1
 
 /*  ser_declare  --  Declare ser_ptr locally within a function.  */
-#define ser_declare     uint8_t *ser_ptr
-#define unser_declare   uint8_t *ser_ptr
+#define ser_declare	uint8_t *ser_ptr
+#define unser_declare	uint8_t *ser_ptr
 
 /*  ser_begin(x, s)  --  Begin serialisation into a buffer x of size s.  */
 #define ser_begin(x, s) ser_ptr = ((uint8_t *)(x))
 #define unser_begin(x, s) ser_ptr = ((uint8_t *)(x))
 
-/*  ser_length  --  Determine length in bytes of serialised into a
-                    buffer x.  */
+/*  ser_length	--  Determine length in bytes of serialised into a
+		    buffer x.  */
 #define ser_length(x)  (ser_ptr - (uint8_t *)(x))
 #define unser_length(x)  (ser_ptr - (uint8_t *)(x))
 
 /*  ser_end(x, s)  --  End serialisation into a buffer x of size s.  */
-#define ser_end(x, s)   ASSERT(ser_length(x) <= (s))
+#define ser_end(x, s)	ASSERT(ser_length(x) <= (s))
 #define unser_end(x, s)   ASSERT(ser_length(x) <= (s))
 
 /*  ser_check(x, s)  --  Verify length of serialised data in buffer x is
-                         expected length s.  */
+			 expected length s.  */
 #define ser_check(x, s) ASSERT(ser_length(x) == (s))
 
-/*                          Serialisation                   */
+/*			    Serialisation		    */
 
 /*  8 bit signed integer  */
-#define ser_int8(x)     *ser_ptr++ = (x)
+#define ser_int8(x)	*ser_ptr++ = (x)
 /*  8 bit unsigned integer  */
-#define ser_uint8(x)    *ser_ptr++ = (x)
+#define ser_uint8(x)	*ser_ptr++ = (x)
 
 /*  16 bit signed integer  */
-#define ser_int16(x)    serial_int16(&ser_ptr, x)
+#define ser_int16(x)	serial_int16(&ser_ptr, x)
 /*  16 bit unsigned integer  */
-#define ser_uint16(x)   serial_uint16(&ser_ptr, x)
+#define ser_uint16(x)	serial_uint16(&ser_ptr, x)
 
 /*  32 bit signed integer  */
-#define ser_int32(x)    serial_int32(&ser_ptr, x)
+#define ser_int32(x)	serial_int32(&ser_ptr, x)
 /*  32 bit unsigned integer  */
-#define ser_uint32(x)   serial_uint32(&ser_ptr, x)
+#define ser_uint32(x)	serial_uint32(&ser_ptr, x)
 
 /*  64 bit signed integer  */
-#define ser_int64(x)    serial_int64(&ser_ptr, x)
+#define ser_int64(x)	serial_int64(&ser_ptr, x)
 /*  64 bit unsigned integer  */
-#define ser_uint64(x)   serial_uint64(&ser_ptr, x)
+#define ser_uint64(x)	serial_uint64(&ser_ptr, x)
 
 
 /*  64 bit IEEE floating point number  */
-#define ser_float64(x)  serial_float64(&ser_ptr, x)
+#define ser_float64(x)	serial_float64(&ser_ptr, x)
 
 /*  128 bit signed integer  */
-#define ser_int128(x)   memcpy(ser_ptr, x, sizeof(int128_t)), ser_ptr += sizeof(int128_t)
+#define ser_int128(x)	memcpy(ser_ptr, x, sizeof(int128_t)), ser_ptr += sizeof(int128_t)
 
 /*  Binary byte stream len bytes not requiring serialisation  */
 #define ser_bytes(x, len) memcpy(ser_ptr, (x), (len)), ser_ptr += (len)
 
-/*  Binary byte stream not requiring serialisation (length obtained by sizeof)  */
-#define ser_buffer(x)   ser_bytes((x), (sizeof (x)))
+/*  Binary byte stream not requiring serialisation (length obtained by sizeof)	*/
+#define ser_buffer(x)	ser_bytes((x), (sizeof (x)))
 
 /* Binary string not requiring serialization */
-#define ser_string(x)   ser_ptr += serial_string(ser_ptr, (x))
+#define ser_string(x)	ser_ptr += serial_string(ser_ptr, (x))
 
-/*                         Unserialisation                  */
+/*			   Unserialisation		    */
 
 /*  8 bit signed integer  */
-#define unser_int8(x)   (x) = *ser_ptr++
+#define unser_int8(x)	(x) = *ser_ptr++
 /*  8 bit unsigned integer  */
-#define unser_uint8(x)  (x) = *ser_ptr++
+#define unser_uint8(x)	(x) = *ser_ptr++
 
 /*  16 bit signed integer  */
-#define unser_int16(x)  (x) = unserial_int16(&ser_ptr)
+#define unser_int16(x)	(x) = unserial_int16(&ser_ptr)
 /*  16 bit unsigned integer  */
 #define unser_uint16(x) (x) = unserial_uint16(&ser_ptr)
 
 /*  32 bit signed integer  */
-#define unser_int32(x)  (x) = unserial_int32(&ser_ptr)
+#define unser_int32(x)	(x) = unserial_int32(&ser_ptr)
 /*  32 bit unsigned integer  */
 #define unser_uint32(x) (x) = unserial_uint32(&ser_ptr)
 
 /*  64 bit signed integer  */
-#define unser_int64(x)  (x) = unserial_int64(&ser_ptr)
+#define unser_int64(x)	(x) = unserial_int64(&ser_ptr)
 /*  64 bit unsigned integer  */
 #define unser_uint64(x) (x) = unserial_uint64(&ser_ptr)
 
@@ -141,7 +144,7 @@ extern int unserial_string(uint8_t * ptr, char * str);
 /*  Binary byte stream len bytes not requiring serialisation  */
 #define unser_bytes(x, len) memcpy((x), ser_ptr, (len)), ser_ptr += (len)
 
-/*  Binary byte stream not requiring serialisation (length obtained by sizeof)  */
+/*  Binary byte stream not requiring serialisation (length obtained by sizeof)	*/
 #define unser_buffer(x)  unser_bytes((x), (sizeof (x)))
 
 /* Binary string not requiring serialization */