orte/liborte/cdr.c

   1 /*
   2  *  $Id: cdr.c,v 0.0.0.1                2004/11/26
   3  *
   4  *  DEBUG:  section 5                   CDR codeing
   5  *  AUTHOR: Petr Smolik                 petr.smolik@wo.cz
   6  *
   7  *  ORTE - OCERA Real-Time Ethernet     http://www.ocera.org/
   8  *  --------------------------------------------------------------------
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  This module maintains a hash table of key/value pairs.
  21  *  Keys can be strings of any size, or numbers up to size
  22  *  unsigned long (HASHKEYTYPE).
  23  *  Values should be a pointer to some data you wish to store.
  24  *
  25  *  Original of source was from ORBit: A CORBA v2.2 ORB
  26  *
  27  */
  28
  29 #include "orte_all.h"
  30
  31 #define CDR_GROW_AMOUNT 128
  32
  33 CORBA_boolean
  34 CDR_buffer_init(CDR_Codec *codec, const unsigned int size)
  35 {
  36
  37         if(codec->release_buffer) {
  38                 FREE(codec->buffer);
  39         }
  40
  41         codec->buffer=(CORBA_octet *)MALLOC(size);
  42         codec->buf_len=size;
  43         codec->wptr_max=size;
  44         codec->rptr=codec->wptr=0;
  45         codec->release_buffer=CORBA_TRUE;
  46
  47         return CORBA_TRUE;
  48 }
  49
  50 /*
  51 CORBA_boolean
  52 CDR_buffer_grow(CDR_Codec *codec, const unsigned int growth)
  53 {
  54         unsigned int real_growth,quot;
  55
  56         if(codec->release_buffer) {
  57                 quot = growth / CDR_GROW_AMOUNT;
  58                 real_growth=CDR_GROW_AMOUNT * (quot+1);
  59
  60                 codec->buffer=(CORBA_octet *)REALLOC(codec->buffer,
  61                                                      codec->buf_len
  62                                                      +real_growth);
  63         }
  64
  65         return CORBA_TRUE;
  66 }
  67 */
  68 CORBA_boolean
  69 CDR_buffer_puts(CDR_Codec *codec, const void *data, const unsigned int len)
  70 {
  71         if(codec->wptr+len > codec->wptr_max) {
  72                 return CORBA_FALSE;
  73         }
  74
  75         memcpy(&codec->buffer[codec->wptr], data, len);
  76         codec->wptr+=len;
  77
  78         return CORBA_TRUE;
  79 }
  80
  81 CORBA_boolean
  82 CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len)
  83 {
  84         if(codec->rptr+len > codec->buf_len) {
  85                 return CORBA_FALSE;
  86         }
  87
  88         memcpy(dest, &codec->buffer[codec->rptr], len);
  89         codec->rptr+=len;
  90
  91         return CORBA_TRUE;
  92 }
  93
  94 CORBA_boolean
  95 CDR_buffer_put(CDR_Codec *codec, void *datum)
  96 {
  97         if(codec->wptr+1 > codec->wptr_max) {
  98                 return(CORBA_FALSE);
  99         }
 100
 101         codec->buffer[codec->wptr++]=*(unsigned char *)datum;
 102         return CORBA_TRUE;
 103 }
 104
 105 CORBA_boolean
 106 CDR_buffer_get(CDR_Codec *codec, void *dest)
 107 {
 108         if(codec->rptr+1 > codec->buf_len) {
 109                 return(CORBA_FALSE);
 110         }
 111
 112         *(CORBA_octet *)dest=codec->buffer[codec->rptr++];
 113         return CORBA_TRUE;
 114 }
 115
 116 #define CDR_buffer_put2(codec, datum) CDR_buffer_putn(codec, datum, 2)
 117 #define CDR_buffer_put4(codec, datum) CDR_buffer_putn(codec, datum, 4)
 118 #define CDR_buffer_put8(codec, datum) CDR_buffer_putn(codec, datum, 8)
 119 #define CDR_buffer_put16(codec, datum) CDR_buffer_putn(codec, datum, 16)
 120 #define CDR_buffer_get2(codec, dest) CDR_buffer_getn(codec, dest, 2)
 121 #define CDR_buffer_get4(codec, dest) CDR_buffer_getn(codec, dest, 4)
 122 #define CDR_buffer_get8(codec, dest) CDR_buffer_getn(codec, dest, 8)
 123 #define CDR_buffer_get16(codec, dest) CDR_buffer_getn(codec, dest, 16)
 124
 125 static CORBA_boolean
 126 CDR_buffer_getn(CDR_Codec *codec, void *dest, int bsize)
 127 {
 128         codec->rptr = (unsigned long)ALIGN_ADDRESS(codec->rptr, bsize);
 129         if(codec->host_endian==codec->data_endian)
 130                 memcpy(dest, codec->buffer + codec->rptr, bsize);
 131         else
 132                 rtps_byteswap(dest, codec->buffer + codec->rptr, bsize);
 133         codec->rptr += bsize;
 134
 135         return CORBA_TRUE;
 136 }
 137
 138 static CORBA_boolean
 139 CDR_buffer_putn(CDR_Codec *codec, void *datum, int bsize)
 140 {
 141         unsigned long forward,i;
 142
 143         forward = (unsigned long)ALIGN_ADDRESS(codec->wptr, bsize);
 144         if (forward+bsize > codec->wptr_max) {
 145                 return CORBA_FALSE;
 146         }
 147
 148         i = codec->wptr;
 149         while(forward > i)
 150                 codec->buffer[i++] = '\0';
 151
 152         codec->wptr = forward;
 153         if(codec->host_endian==codec->data_endian)
 154                 memcpy(codec->buffer + codec->wptr, datum, bsize);
 155         else
 156                 rtps_byteswap(codec->buffer + codec->wptr, datum, bsize);
 157         codec->wptr += bsize;
 158
 159         return CORBA_TRUE;
 160 }
 161
 162 #define CDR_swap2(d,s) rtps_byteswap((d), (s), 2)
 163 #define CDR_swap4(d,s) rtps_byteswap((d), (s), 4)
 164 #define CDR_swap8(d,s) rtps_byteswap((d), (s), 8)
 165 #define CDR_swap16(d,s) rtps_byteswap((d), (s), 16)
 166
 167 inline CORBA_boolean
 168 CDR_put_short(CDR_Codec *codec, CORBA_short s)
 169 {
 170         return CDR_buffer_put2(codec, &s);
 171 }
 172
 173 inline CORBA_boolean
 174 CDR_get_short(CDR_Codec *codec, CORBA_short *s)
 175 {
 176         return CDR_buffer_get2(codec, s);
 177 }
 178
 179 inline CORBA_boolean
 180 CDR_put_ushort(CDR_Codec *codec, CORBA_unsigned_short us)
 181 {
 182         return CDR_buffer_put2(codec, &us);
 183 }
 184
 185 inline CORBA_boolean
 186 CDR_get_ushort(CDR_Codec *codec, CORBA_unsigned_short *us)
 187 {
 188         return CDR_buffer_get2(codec, us);
 189 }
 190
 191 inline CORBA_boolean
 192 CDR_put_long(CDR_Codec *codec, CORBA_long l)
 193 {
 194         return CDR_buffer_put4(codec, &l);
 195 }
 196
 197 inline CORBA_boolean
 198 CDR_get_long(CDR_Codec *codec, CORBA_long *l)
 199 {
 200         return CDR_buffer_get4(codec, l);
 201 }
 202
 203 inline CORBA_boolean
 204 CDR_put_ulong(CDR_Codec *codec, CORBA_unsigned_long ul)
 205 {
 206         return CDR_buffer_put4(codec, &ul);
 207 }
 208
 209 inline CORBA_boolean
 210 CDR_get_ulong(CDR_Codec *codec, CORBA_unsigned_long *ul)
 211 {
 212         return CDR_buffer_get4(codec, ul);
 213 }
 214
 215 #ifdef HAVE_CORBA_LONG_LONG
 216 inline CORBA_boolean
 217 CDR_get_long_long(CDR_Codec *codec, CORBA_long_long *ul)
 218 {
 219         return CDR_buffer_get8(codec, ul);
 220 }
 221
 222 inline CORBA_boolean
 223 CDR_put_long_long(CDR_Codec *codec, CORBA_long_long ll)
 224 {
 225         return CDR_buffer_put8(codec, &ll);
 226 }
 227
 228 inline CORBA_boolean
 229 CDR_put_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long ll)
 230 {
 231         return CDR_buffer_put8(codec, &ll);
 232 }
 233
 234 inline CORBA_boolean
 235 CDR_get_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long *ull)
 236 {
 237         return CDR_buffer_get8(codec, ull);
 238 }
 239 #endif
 240
 241 inline CORBA_boolean
 242 CDR_put_float(CDR_Codec *codec, CORBA_float f)
 243 {
 244         return CDR_buffer_put4(codec, &f);
 245 }
 246
 247 inline CORBA_boolean
 248 CDR_get_float(CDR_Codec *codec, CORBA_float *f)
 249 {
 250         return CDR_buffer_get4(codec, f);
 251 }
 252
 253 inline CORBA_boolean
 254 CDR_put_double(CDR_Codec *codec, CORBA_double d)
 255 {
 256         return CDR_buffer_put8(codec, &d);
 257 }
 258
 259 inline CORBA_boolean
 260 CDR_get_double(CDR_Codec *codec, CORBA_double *d)
 261 {
 262         return CDR_buffer_get8(codec, d);
 263 }
 264
 265 inline CORBA_boolean
 266 CDR_put_long_double(CDR_Codec *codec, CORBA_long_double ld)
 267 {
 268         return CDR_buffer_put16(codec, &ld);
 269 }
 270
 271 inline CORBA_boolean
 272 CDR_put_octet(CDR_Codec *codec, CORBA_octet datum)
 273 {
 274         return CDR_buffer_put(codec, &datum);
 275 }
 276
 277 inline CORBA_boolean
 278 CDR_get_octet(CDR_Codec *codec, CORBA_octet *datum)
 279 {
 280         return(CDR_buffer_get(codec, datum));
 281 }
 282
 283 inline CORBA_boolean
 284 CDR_put_octets(CDR_Codec *codec, void *data, unsigned long len)
 285 {
 286         return CDR_buffer_puts(codec, data, len);
 287 }
 288
 289 inline CORBA_boolean
 290 CDR_put_char(CDR_Codec *codec, CORBA_char c)
 291 {
 292         return CDR_buffer_put(codec, &c);
 293 }
 294
 295 inline CORBA_boolean
 296 CDR_get_char(CDR_Codec *codec, CORBA_char *c)
 297 {
 298         return CDR_buffer_get(codec, c);
 299 }
 300
 301 inline CORBA_boolean
 302 CDR_put_boolean(CDR_Codec *codec, CORBA_boolean datum)
 303 {
 304         datum = datum&&1;
 305         return CDR_buffer_put(codec, &datum);
 306 }
 307
 308 inline CORBA_boolean
 309 CDR_get_boolean(CDR_Codec *codec, CORBA_boolean *b)
 310 {
 311         return CDR_buffer_get(codec, b);
 312 }
 313
 314 CORBA_boolean
 315 CDR_put_string(CDR_Codec *codec, const char *str)
 316 {
 317         unsigned int len;
 318
 319         len=strlen(str)+1;
 320
 321         if (CDR_put_ulong(codec, len)==CORBA_FALSE) return -1;
 322         return CDR_buffer_puts(codec, str, len);
 323 }
 324
 325 CORBA_boolean
 326 CDR_get_string_static(CDR_Codec *codec,CORBA_char **str)
 327 {
 328         CORBA_unsigned_long len;
 329
 330         if(CDR_get_ulong(codec, &len)==CORBA_FALSE)
 331                 return CORBA_FALSE;
 332
 333         if((codec->rptr + len) > codec->buf_len)
 334                 return CORBA_FALSE;
 335
 336         *str = ((CORBA_char *)codec->buffer) + codec->rptr;
 337
 338         codec->rptr += len;
 339
 340         return CORBA_TRUE;
 341 }
 342
 343 CORBA_boolean
 344 CDR_get_string(CDR_Codec *codec, CORBA_char **str)
 345 {
 346         CORBA_unsigned_long len;
 347
 348         if(CDR_get_ulong(codec, &len)==CORBA_FALSE)
 349                 return(CORBA_FALSE);
 350
 351         if(len==0)
 352                 return(CORBA_FALSE);
 353
 354         *str=MALLOC(len);
 355
 356         if(CDR_buffer_gets(codec, *str, len)==CORBA_FALSE) {
 357                 FREE(*str);
 358                 return(CORBA_FALSE);
 359         }
 360
 361         if((*str)[len-1]!='\0') {
 362                 (*str)[len-1]='\0';
 363         }
 364
 365         return(CORBA_TRUE);
 366 }
 367
 368 CORBA_boolean
 369 CDR_get_string_buff(CDR_Codec *codec, CORBA_char *str)
 370 {
 371         CORBA_unsigned_long len;
 372
 373         if(CDR_get_ulong(codec, &len)==CORBA_FALSE)
 374                 return(CORBA_FALSE);
 375
 376         if(len==0)
 377                 return(CORBA_FALSE);
 378
 379         if(CDR_buffer_gets(codec, str, len)==CORBA_FALSE) {
 380                 return(CORBA_FALSE);
 381         }
 382
 383         if(str[len-1]!='\0') {
 384                 str[len-1]='\0';
 385         }
 386
 387         return(CORBA_TRUE);
 388 }
 389
 390 CORBA_boolean
 391 CDR_get_seq_begin(CDR_Codec *codec, CORBA_unsigned_long *ul)
 392 {
 393         return(CDR_get_ulong(codec, ul));
 394 }
 395
 396 CDR_Codec *
 397 CDR_codec_init_static(CDR_Codec *codec)
 398 {
 399         memset(codec, 0, sizeof(CDR_Codec));
 400
 401         codec->host_endian = FLAG_ENDIANNESS;
 402
 403         return codec;
 404 }
 405
 406 CDR_Codec *
 407 CDR_codec_init(void)
 408 {
 409         CDR_Codec *c;
 410
 411         c=MALLOC(sizeof(CDR_Codec));
 412         CDR_codec_init_static(c);
 413
 414         return(c);
 415 }
 416
 417 void
 418 CDR_codec_release_buffer(CDR_Codec *codec)
 419 {
 420         if(codec->release_buffer)
 421                 FREE(codec->buffer);
 422 }
 423
 424
 425 void
 426 CDR_codec_free(CDR_Codec *codec)
 427 {
 428         CDR_codec_release_buffer(codec);
 429         FREE(codec);
 430 }