src/cdr.h

   1 /*
   2  *  $Id: cdr.h,v 0.0.0.1                2004/11/26
   3  *
   4  *  -------------------------------------------------------------------
   5  *                                ORTE
   6  *                      Open Real-Time Ethernet
   7  *
   8  *                      Copyright (C) 2001-2006
   9  *  Department of Control Engineering FEE CTU Prague, Czech Republic
  10  *                      http://dce.felk.cvut.cz
  11  *                      http://www.ocera.org
  12  *
  13  *  Author:              Petr Smolik    petr.smolik@wo.cz
  14  *  Advisor:             Pavel Pisa
  15  *  Project Responsible: Zdenek Hanzalek
  16  *
  17  *  Modified for FORB by Michal Sojka <sojkam1@fel.cvut.cz>, 2008
  18  *  --------------------------------------------------------------------
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  Original of source was from ORBit: A CORBA v2.2 ORB
  31  */
  32 /**
  33  * @file   cdr.h
  34  * @author Michal Sojka <sojkam1@fel.cvut.cz>
  35  * @date   Sun Oct 12 16:55:44 2008
  36  *
  37  * @brief Handling of serialization/deserialization.
  38  *
  39  * Forked from ORTE project.
  40  *
  41  *
  42  */
  43 #ifndef _FORB_CDR_H_
  44 #define _FORB_CDR_H_
  45
  46 #include "basic_types.h"
  47 #include "cdr_codec.h"
  48 #include "object_type.h"
  49
  50 /*
  51  * Alignment of CORBA types mapped to C.
  52  * These have *nothing* to do with CDR alignment.
  53  */
  54 #define ORTE_ALIGNOF_CORBA_OCTET        1
  55 #define ORTE_ALIGNOF_CORBA_BOOLEAN      1
  56 #define ORTE_ALIGNOF_CORBA_CHAR         1
  57 #define ORTE_ALIGNOF_CORBA_WCHAR        2
  58 #define ORTE_ALIGNOF_CORBA_SHORT        2
  59 #define ORTE_ALIGNOF_CORBA_LONG         4
  60 #define ORTE_ALIGNOF_CORBA_LONG_LONG    8
  61 #define ORTE_ALIGNOF_CORBA_FLOAT        4
  62 #define ORTE_ALIGNOF_CORBA_DOUBLE       8
  63 #define ORTE_ALIGNOF_CORBA_LONG_DOUBLE  16
  64 #define ORTE_ALIGNOF_CORBA_STRUCT       1
  65 #define ORTE_ALIGNOF_CORBA_POINTER      4
  66
  67 typedef enum {
  68         BigEndian=0,
  69         LittleEndian=1
  70 } FORB_CDR_Endianness;
  71
  72 /**
  73  * Codec used for serialization/deserialization
  74  *
  75  * @host_endian:
  76  * @data_endian:
  77  * @buffer: buffer for data
  78  * @buf_len: buffer length
  79  * @wptr_max: maximal size of writing data
  80  * @wptr: write index
  81  * @wptr_last: index of the data after the last written data
  82  * @rptr: read index
  83  * @readonly: readonly attribute
  84  * @release_buffer: use CORBA_TRUE if is necessary to free buffer memory after destruction of structure
  85  * @orb: Needed for deserialization of object references.
  86  *
  87  * Struct @FORB_CDR_Codec is used by serialization and deserialization functions.
  88  */
  89 struct FORB_CDR_Codec {
  90         FORB_CDR_Endianness host_endian;
  91         FORB_CDR_Endianness data_endian;
  92         CORBA_octet *buffer;
  93         unsigned int buf_len;
  94         unsigned int wptr_max;
  95         unsigned int wptr;
  96         unsigned int wptr_last;
  97         unsigned int rptr;
  98         CORBA_boolean readonly;
  99         CORBA_boolean release_buffer;
 100         forb_orb orb;
 101 };
 102
 103 #define HEXDIGIT(c) (isdigit((guchar)(c))?(c)-'0':tolower((guchar)(c))-'a'+10)
 104 #define HEXOCTET(a,b) ((HEXDIGIT((a)) << 4) | HEXDIGIT((b)))
 105
 106 static inline CORBA_long FORB_CDR_data_size(FORB_CDR_Codec *codec)
 107 {
 108         return codec->wptr_last - codec->rptr;
 109 }
 110
 111 extern CORBA_boolean FORB_CDR_buffer_init(FORB_CDR_Codec *codec, const unsigned int size, const unsigned int first);
 112 extern CORBA_boolean FORB_CDR_buffer_reset(FORB_CDR_Codec *codec, const unsigned int first);
 113 extern CORBA_boolean FORB_CDR_buffer_prepend(FORB_CDR_Codec *codec, const unsigned int len);
 114 extern FORB_CDR_Codec *FORB_CDR_codec_init(forb_orb orb);
 115 extern FORB_CDR_Codec *FORB_CDR_codec_init_static(FORB_CDR_Codec *codec, forb_orb orb);
 116 extern void FORB_CDR_codec_release_buffer(FORB_CDR_Codec *codec);
 117 extern void FORB_CDR_codec_free(FORB_CDR_Codec *);
 118
 119 extern CORBA_boolean FORB_CDR_buffer_puts(FORB_CDR_Codec *codec, const void *data, const unsigned int len);
 120 extern CORBA_boolean FORB_CDR_buffer_gets(FORB_CDR_Codec *codec, void *dest, const unsigned int len);
 121
 122 extern CORBA_boolean FORB_CDR_put_short(FORB_CDR_Codec *codec, CORBA_short s);
 123 extern CORBA_boolean FORB_CDR_put_ushort(FORB_CDR_Codec *codec, CORBA_unsigned_short us);
 124 extern CORBA_boolean FORB_CDR_put_long(FORB_CDR_Codec *codec, CORBA_long l);
 125 extern CORBA_boolean FORB_CDR_put_ulong(FORB_CDR_Codec *codec, CORBA_unsigned_long ul);
 126 /* #ifdef HAVE_CORBA_LONG_LONG */
 127 extern CORBA_boolean FORB_CDR_put_long_long(FORB_CDR_Codec *codec, CORBA_long_long ll);
 128 extern CORBA_boolean FORB_CDR_put_ulong_long(FORB_CDR_Codec *codec, CORBA_unsigned_long_long ull);
 129 extern CORBA_boolean FORB_CDR_get_ulong_long(FORB_CDR_Codec *codec, CORBA_unsigned_long_long *ul);
 130 extern CORBA_boolean FORB_CDR_get_long_long(FORB_CDR_Codec *codec, CORBA_long_long *ul);
 131 /* #endif */
 132 extern CORBA_boolean FORB_CDR_put_float(FORB_CDR_Codec *codec, CORBA_float f);
 133 extern CORBA_boolean FORB_CDR_put_double(FORB_CDR_Codec *codec, CORBA_double d);
 134 extern CORBA_boolean FORB_CDR_put_long_double(FORB_CDR_Codec *codec, CORBA_long_double ld);
 135 extern CORBA_boolean FORB_CDR_put_octet(FORB_CDR_Codec *codec, CORBA_octet datum);
 136 extern CORBA_boolean FORB_CDR_put_octets(FORB_CDR_Codec *codec, void *data, unsigned long len);
 137 extern CORBA_boolean FORB_CDR_put_char(FORB_CDR_Codec *codec, CORBA_char c);
 138 extern CORBA_boolean FORB_CDR_put_boolean(FORB_CDR_Codec *codec, CORBA_boolean datum);
 139 extern CORBA_boolean FORB_CDR_put_string(FORB_CDR_Codec *codec, const CORBA_char *str);
 140 extern CORBA_boolean FORB_CDR_buffer_gets(FORB_CDR_Codec *codec, void *dest, const unsigned int len);
 141 extern CORBA_boolean FORB_CDR_get_short(FORB_CDR_Codec *codec, CORBA_short *us);
 142 extern CORBA_boolean FORB_CDR_get_ushort(FORB_CDR_Codec *codec, CORBA_unsigned_short *us);
 143 extern CORBA_boolean FORB_CDR_get_long(FORB_CDR_Codec *codec, CORBA_long *l);
 144 extern CORBA_boolean FORB_CDR_get_ulong(FORB_CDR_Codec *codec, CORBA_unsigned_long *ul);
 145 extern CORBA_boolean FORB_CDR_get_octet(FORB_CDR_Codec *codec, CORBA_octet *datum);
 146 extern CORBA_boolean FORB_CDR_get_boolean(FORB_CDR_Codec *codec, CORBA_boolean *b);
 147 extern CORBA_boolean FORB_CDR_get_char(FORB_CDR_Codec *codec, CORBA_char *c);
 148 extern CORBA_boolean FORB_CDR_get_string(FORB_CDR_Codec *codec, CORBA_char **str);
 149 extern CORBA_boolean FORB_CDR_get_string_buff(FORB_CDR_Codec *codec, CORBA_char *str);
 150 extern CORBA_boolean FORB_CDR_get_string_static(FORB_CDR_Codec *codec, CORBA_char **str);
 151 extern CORBA_boolean FORB_CDR_get_seq_begin(FORB_CDR_Codec *codec, CORBA_unsigned_long *ul);
 152 extern CORBA_boolean FORB_CDR_get_float(FORB_CDR_Codec *codec, CORBA_float *f);
 153 extern CORBA_boolean FORB_CDR_get_double(FORB_CDR_Codec *codec, CORBA_double *d);
 154
 155 extern CORBA_boolean FORB_CDR_put_align(FORB_CDR_Codec *codec, unsigned bsize);
 156 extern CORBA_boolean FORB_CDR_get_align(FORB_CDR_Codec *codec, unsigned bsize);
 157
 158
 159 /* serialization functions */
 160 #define CORBA_short_serialize(x,y)             FORB_CDR_put_short((x),*(y))
 161 #define CORBA_long_serialize(x,y)              FORB_CDR_put_long((x),*(y))
 162 #define CORBA_long_long_serialize(x,y)         FORB_CDR_put_long_long((x),*(y))
 163 #define CORBA_unsigned_short_serialize(x,y)    FORB_CDR_put_ushort((x),*(y))
 164 #define CORBA_unsigned_long_serialize(x,y)     FORB_CDR_put_ulong((x),*(y))
 165 #define CORBA_unsigned_long_long_serialize(x,y) FORB_CDR_put_ulong_long((x),*(y))
 166 #define CORBA_float_serialize(x,y)             FORB_CDR_put_float((x),*(y))
 167 #define CORBA_double_serialize(x,y)            FORB_CDR_put_double((x),*(y))
 168 #define CORBA_char_serialize(x,y)              FORB_CDR_put_char((x),*(y))
 169 #define CORBA_boolean_serialize(x,y)           FORB_CDR_put_boolean((x),*(y))
 170 #define CORBA_octet_serialize(x,y)             FORB_CDR_put_octet((x),*(y))
 171 #define CORBA_long_double_serialize(x,y)       FORB_CDR_put_long_double((x),*(y))
 172 #define CORBA_string_serialize(x,y)            FORB_CDR_put_string((x),*(y))
 173
 174 /* deserialization functions */
 175 #define CORBA_short_deserialize(x,y)           FORB_CDR_get_short((x),(y))
 176 #define CORBA_long_deserialize(x,y)            FORB_CDR_get_long((x),(y))
 177 #define CORBA_long_long_deserialize(x,y)       FORB_CDR_get_long_long((x),(y))
 178 #define CORBA_unsigned_short_deserialize(x,y)  FORB_CDR_get_ushort((x),(y))
 179 #define CORBA_unsigned_long_deserialize(x,y)   FORB_CDR_get_ulong((x),(y))
 180 #define CORBA_unsigned_long_long_deserialize(x,y) FORB_CDR_get_ulong_long((x),(y))
 181 #define CORBA_float_deserialize(x,y)           FORB_CDR_get_float((x),(y))
 182 #define CORBA_double_deserialize(x,y)          FORB_CDR_get_double((x),(y))
 183 #define CORBA_char_deserialize(x,y)            FORB_CDR_get_char((x),(y))
 184 #define CORBA_boolean_deserialize(x,y)         FORB_CDR_get_boolean((x),(y))
 185 #define CORBA_octet_deserialize(x,y)           FORB_CDR_get_octet((x),(y))
 186 #define CORBA_long_double_deserialize(x,y)     FORB_CDR_get_long_double((x),(y))
 187 #define CORBA_string_deserialize(x,y)          FORB_CDR_get_string((x),(y))
 188
 189
 190 #endif /* !_FORB_CDR_H_ */