src/gras/DataDesc/ddt_exchange.c

   1 /* $Id$ */
   2
   3 /* ddt_exchange - send/recv data described                                  */
   4
   5 /* Authors: Olivier Aumage, Martin Quinson                                  */
   6 /* Copyright (C) 2003, 2004 the GRAS posse.                                 */
   7
   8 /* This program is free software; you can redistribute it and/or modify it
   9    under the terms of the license (GNU LGPL) which comes with this package. */
  10
  11 #include "DataDesc/datadesc_private.h"
  12
  13 GRAS_LOG_NEW_DEFAULT_SUBCATEGORY(exchange,DataDesc);
  14
  15 static const char *gras_datadesc_cat_names[9] = {
  16   "undefined",
  17   "scalar", "struct", "union", "ref", "array", "ignored",
  18   "invalid"};
  19
  20 static gras_datadesc_type_t *int_type = NULL;
  21 static gras_datadesc_type_t *pointer_type = NULL;
  22 static gras_error_t gras_dd_send_int(gras_socket_t *sock,             int  i);
  23 static gras_error_t gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i);
  24
  25 static gras_error_t
  26 gras_dd_alloc_ref(gras_dict_t *refs,  long int     size,
  27                   char       **r_ref, long int     r_len,
  28                   char       **l_ref);
  29 static int
  30 gras_dd_is_r_null(char **r_ptr, long int length);
  31
  32 static gras_error_t
  33 gras_datadesc_send_rec(gras_socket_t        *sock,
  34                        gras_dd_cbps_t       *state,
  35                        gras_dict_t          *refs,
  36                        gras_datadesc_type_t *type,
  37                        char                 *data);
  38 static gras_error_t
  39 gras_datadesc_recv_rec(gras_socket_t        *sock,
  40                        gras_dd_cbps_t       *state,
  41                        gras_dict_t          *refs,
  42                        gras_datadesc_type_t *type,
  43                        int                   r_arch,
  44                        char                **r_data,
  45                        long int              r_lgr,
  46                        char                **dst);
  47
  48
  49 static gras_error_t
  50 gras_dd_send_int(gras_socket_t *sock,int i) {
  51   gras_error_t errcode;
  52
  53   if (!int_type)
  54     TRY(gras_datadesc_by_name("int", &int_type));
  55
  56   DEBUG1("send_int(%d)",i);
  57   return gras_trp_chunk_send(sock, (char*)&i, int_type->size[GRAS_THISARCH]);
  58 }
  59
  60 static gras_error_t
  61 gras_dd_recv_int(gras_socket_t *sock, int r_arch, int *i) {
  62   gras_error_t errcode;
  63
  64   if (!int_type)
  65     TRY(gras_datadesc_by_name("int", &int_type));
  66
  67   if (int_type->size[GRAS_THISARCH] >= int_type->size[r_arch]) {
  68     TRY(gras_trp_chunk_recv(sock, (char*)i, int_type->size[r_arch]));
  69     TRY(gras_dd_convert_elm(int_type,r_arch, i,i));
  70   } else {
  71     void *ptr = NULL;
  72     ptr = malloc((size_t)int_type->size[r_arch]);
  73     TRY(gras_trp_chunk_recv(sock, (char*)ptr, int_type->size[r_arch]));
  74     TRY(gras_dd_convert_elm(int_type,r_arch, ptr,i));
  75     free(ptr);
  76   }
  77   DEBUG1("recv_int(%d)",*i);
  78
  79   return no_error;
  80 }
  81
  82 /*
  83  * Note: here we suppose that the remote NULL is a sequence
  84  *       of 'length' bytes set to 0.
  85  * FIXME: Check in configure?
  86  */
  87 static int
  88 gras_dd_is_r_null(char **r_ptr, long int length) {
  89   int i;
  90
  91   for (i=0; i<length; i++) {
  92     if ( ((unsigned char*)r_ptr) [i]) {
  93       return 0;
  94     }
  95   }
  96
  97   return 1;
  98 }
  99
 100 static gras_error_t
 101 gras_dd_alloc_ref(gras_dict_t *refs,
 102                   long int     size,
 103                   char       **r_ref,
 104                   long int     r_len, /* pointer_type->size[r_arch] */
 105                   char       **l_ref) {
 106   char *l_data = NULL;
 107   gras_error_t errcode;
 108
 109   gras_assert1(size>0,"Cannot allocate %d bytes!", size);
 110   if (! (l_data = malloc((size_t)size)) )
 111     RAISE_MALLOC;
 112
 113   *l_ref = l_data;
 114   DEBUG2("l_data=%p, &l_data=%p",l_data,&l_data);
 115
 116   DEBUG3("alloc_ref: r_ref=%p; *r_ref=%p, r_len=%d",
 117          r_ref, r_ref?*r_ref:NULL, r_len);
 118   if (r_ref && !gras_dd_is_r_null( r_ref, r_len)) {
 119     void *ptr = malloc(sizeof(void *));
 120     if (!ptr)
 121       RAISE_MALLOC;
 122     //    memcpy(ptr,&l_data, sizeof(void *));
 123     memcpy(ptr,l_ref, sizeof(void *));
 124
 125     DEBUG2("Insert %p under %p",*(void**)ptr, *(void**)r_ref);
 126     /* FIXME: Leaking on the ptr. Do I really need to copy it? */
 127     TRY(gras_dict_insert_ext(refs,(const char *) r_ref, r_len, ptr, NULL));
 128   }
 129   return no_error;
 130 }
 131
 132 /**
 133  * gras_datadesc_type_cmp:
 134  *
 135  * Compares two datadesc types with the same semantic than strcmp.
 136  *
 137  * This comparison does not take the set headers into account (name and ID),
 138  * but only the payload (actual type description).
 139  */
 140 int gras_datadesc_type_cmp(const gras_datadesc_type_t *d1,
 141                            const gras_datadesc_type_t *d2) {
 142   int ret,cpt;
 143   gras_dd_cat_field_t *field1,*field2;
 144   gras_datadesc_type_t *field_desc_1,*field_desc_2;
 145
 146
 147   if (!d1 && d2) return 1;
 148   if (!d1 && !d2) return 0;
 149   if ( d1 && !d2) return -1;
 150
 151   if      (d1->size          != d2->size     )
 152     return d1->size          >  d2->size         ? 1 : -1;
 153   if      (d1->alignment     != d2->alignment)
 154     return d1->alignment     >  d2->alignment    ? 1 : -1;
 155   if      (d1->aligned_size  != d2->aligned_size)
 156     return d1->aligned_size  >  d2->aligned_size ? 1 : -1;
 157
 158   if      (d1->category_code != d2->category_code)
 159     return d1->category_code >  d2->category_code ? 1 : -1;
 160
 161   if      (d1->pre          != d2->pre)
 162     return d1->pre          >  d2->pre ? 1 : -1;
 163   if      (d1->post         != d2->post)
 164     return d1->post          > d2->post ? 1 : -1;
 165
 166   switch (d1->category_code) {
 167   case e_gras_datadesc_type_cat_scalar:
 168     if (d1->category.scalar_data.encoding != d2->category.scalar_data.encoding)
 169       return d1->category.scalar_data.encoding > d2->category.scalar_data.encoding ? 1 : -1 ;
 170     break;
 171
 172   case e_gras_datadesc_type_cat_struct:
 173     if (gras_dynar_length(d1->category.struct_data.fields) !=
 174         gras_dynar_length(d2->category.struct_data.fields))
 175       return gras_dynar_length(d1->category.struct_data.fields) >
 176         gras_dynar_length(d2->category.struct_data.fields) ?
 177         1 : -1;
 178
 179     gras_dynar_foreach(d1->category.struct_data.fields, cpt, field1) {
 180
 181       gras_dynar_get(d2->category.struct_data.fields, cpt, field2);
 182       gras_datadesc_by_id(field1->code,&field_desc_1); /* FIXME: errcode ignored */
 183       gras_datadesc_by_id(field2->code,&field_desc_2);
 184       ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2);
 185       if (ret)
 186         return ret;
 187
 188     }
 189     break;
 190
 191   case e_gras_datadesc_type_cat_union:
 192     if (d1->category.union_data.selector != d2->category.union_data.selector)
 193       return d1->category.union_data.selector > d2->category.union_data.selector ? 1 : -1;
 194
 195     if (gras_dynar_length(d1->category.union_data.fields) !=
 196         gras_dynar_length(d2->category.union_data.fields))
 197       return gras_dynar_length(d1->category.union_data.fields) >
 198              gras_dynar_length(d2->category.union_data.fields) ?
 199         1 : -1;
 200
 201     gras_dynar_foreach(d1->category.union_data.fields, cpt, field1) {
 202
 203       gras_dynar_get(d2->category.union_data.fields, cpt, field2);
 204       gras_datadesc_by_id(field1->code,&field_desc_1); /* FIXME: errcode ignored */
 205       gras_datadesc_by_id(field2->code,&field_desc_2);
 206       ret = gras_datadesc_type_cmp(field_desc_1,field_desc_2);
 207       if (ret)
 208         return ret;
 209
 210     }
 211     break;
 212
 213
 214   case e_gras_datadesc_type_cat_ref:
 215     if (d1->category.ref_data.selector != d2->category.ref_data.selector)
 216       return d1->category.ref_data.selector > d2->category.ref_data.selector ? 1 : -1;
 217
 218     if (d1->category.ref_data.code != d2->category.ref_data.code)
 219       return d1->category.ref_data.code > d2->category.ref_data.code ? 1 : -1;
 220     break;
 221
 222   case e_gras_datadesc_type_cat_array:
 223     if (d1->category.array_data.code != d2->category.array_data.code)
 224       return d1->category.array_data.code > d2->category.array_data.code ? 1 : -1;
 225
 226     if (d1->category.array_data.fixed_size != d2->category.array_data.fixed_size)
 227       return d1->category.array_data.fixed_size > d2->category.array_data.fixed_size ? 1 : -1;
 228
 229     if (d1->category.array_data.dynamic_size != d2->category.array_data.dynamic_size)
 230       return d1->category.array_data.dynamic_size > d2->category.array_data.dynamic_size ? 1 : -1;
 231
 232     break;
 233
 234   case e_gras_datadesc_type_cat_ignored:
 235     /* That's ignored... */
 236   default:
 237     /* two stupidly created ddt are equally stupid ;) */
 238     break;
 239   }
 240   return 0;
 241
 242 }
 243
 244 /**
 245  * gras_datadesc_cpy:
 246  *
 247  * Copy the data pointed by src and described by type
 248  * to a new location, and store a pointer to it in dst.
 249  *
 250  */
 251 gras_error_t gras_datadesc_cpy(gras_datadesc_type_t *type,
 252                                void *src,
 253                                void **dst) {
 254   RAISE_UNIMPLEMENTED;
 255 }
 256
 257 static gras_error_t
 258 gras_datadesc_send_rec(gras_socket_t        *sock,
 259                        gras_dd_cbps_t       *state,
 260                        gras_dict_t          *refs,
 261                        gras_datadesc_type_t *type,
 262                        char                 *data) {
 263
 264   gras_error_t          errcode;
 265   int                   cpt;
 266   gras_datadesc_type_t *sub_type; /* type on which we recurse */
 267
 268   VERB2("Send a %s (%s)",
 269         type->name, gras_datadesc_cat_names[type->category_code]);
 270
 271   if (type->pre) {
 272     type->pre(state,type,data);
 273   }
 274
 275   switch (type->category_code) {
 276   case e_gras_datadesc_type_cat_scalar:
 277     TRY(gras_trp_chunk_send(sock, data, type->size[GRAS_THISARCH]));
 278     break;
 279
 280   case e_gras_datadesc_type_cat_struct: {
 281     gras_dd_cat_struct_t  struct_data;
 282     gras_dd_cat_field_t  *field;
 283     char                 *field_data;
 284
 285     struct_data = type->category.struct_data;
 286     VERB1(">> Send all fields of the structure %s",type->name);
 287     gras_dynar_foreach(struct_data.fields, cpt, field) {
 288       field_data = data;
 289       field_data += field->offset[GRAS_THISARCH];
 290
 291       TRY(gras_datadesc_by_id(field->code, &sub_type));
 292
 293       if (field->pre)
 294         field->pre(state,sub_type,field_data);
 295
 296       TRY(gras_datadesc_send_rec(sock,state,refs,sub_type, field_data));
 297
 298       if (field->post)
 299         field->post(state,sub_type,field_data);
 300     }
 301     VERB1("<< Sent all fields of the structure %s", type->name);
 302
 303     break;
 304   }
 305
 306   case e_gras_datadesc_type_cat_union: {
 307     gras_dd_cat_union_t    union_data;
 308     gras_dd_cat_field_t   *field;
 309     int                    field_num;
 310
 311     union_data = type->category.union_data;
 312
 313     /* retrieve the field number */
 314     field_num = union_data.selector(state, type, data);
 315
 316     gras_assert1(field_num > 0,
 317                  "union field selector of %s gave a negative value",
 318                  type->name);
 319
 320     gras_assert3(field_num < gras_dynar_length(union_data.fields),
 321          "union field selector of %s returned %d but there is only %d fields",
 322                  type->name, field_num, gras_dynar_length(union_data.fields));
 323
 324     /* Send the field number */
 325     TRY(gras_dd_send_int(sock, field_num));
 326
 327     /* Send the content */
 328     gras_dynar_get(union_data.fields, field_num, field);
 329     TRY(gras_datadesc_by_id(field->code, &sub_type));
 330
 331     if (field->pre)
 332       field->pre(state,sub_type,data);
 333
 334     TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, data));
 335
 336     if (field->post)
 337       field->post(state,sub_type,data);
 338
 339     break;
 340   }
 341
 342   case e_gras_datadesc_type_cat_ref: {
 343     gras_dd_cat_ref_t      ref_data;
 344     int                    ref_code;
 345
 346     void                 **ref=(void**)data;
 347     void *dummy;
 348
 349     ref_data = type->category.ref_data;
 350
 351     /* Detect the referenced type and send it to peer if needed */
 352     ref_code = ref_data.code;
 353     if (ref_code < 0) {
 354       ref_code = ref_data.selector(state,type,data);
 355       TRY(gras_dd_send_int(sock, ref_code));
 356     }
 357
 358     /* Send the actual value of the pointer for cycle handling */
 359     if (!pointer_type)
 360       TRY(gras_datadesc_by_name("data pointer", &pointer_type));
 361     TRY(gras_trp_chunk_send(sock, (char*)data,
 362                             pointer_type->size[GRAS_THISARCH]));
 363
 364     /* Send the pointed data only if not already sent */
 365     if (*(void**)data == NULL) {
 366       VERB0("Not sending NULL referenced data");
 367       break;
 368     }
 369     errcode = gras_dict_retrieve_ext(refs,(char*)ref, sizeof(void*), &dummy);
 370     if (errcode == mismatch_error) {
 371       VERB1("Sending data referenced at %p", *ref);
 372       TRY(gras_dict_insert_ext(refs, (char*)ref, sizeof(void*), ref, NULL));
 373       TRY(gras_datadesc_by_id(ref_code, &sub_type));
 374       TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, *ref));
 375
 376     } else if (errcode == no_error) {
 377       VERB1("Not sending data referenced at %p (already done)", *ref);
 378     } else {
 379       return errcode;
 380     }
 381
 382     break;
 383   }
 384
 385   case e_gras_datadesc_type_cat_array: {
 386     gras_dd_cat_array_t    array_data;
 387     long int               count;
 388     char                  *ptr=data;
 389     long int               elm_size;
 390
 391     array_data = type->category.array_data;
 392
 393     /* determine and send the element count */
 394     count = array_data.fixed_size;
 395     if (count <= 0) {
 396       count = array_data.dynamic_size(state,type,data);
 397       gras_assert1(count >=0,
 398                    "Invalid (negative) array size for type %s",type->name);
 399       TRY(gras_dd_send_int(sock, count));
 400     }
 401
 402     /* send the content */
 403     TRY(gras_datadesc_by_id(array_data.code, &sub_type));
 404     elm_size = sub_type->aligned_size[GRAS_THISARCH];
 405     for (cpt=0; cpt<count; cpt++) {
 406       TRY(gras_datadesc_send_rec(sock,state,refs, sub_type, ptr));
 407       ptr += elm_size;
 408     }
 409     break;
 410   }
 411
 412   default:
 413     gras_assert0(0, "Invalid type");
 414   }
 415
 416   if (type->post) {
 417     type->post(state,type,data);
 418   }
 419
 420   return no_error;
 421 }
 422
 423 /**
 424  * gras_datadesc_send:
 425  *
 426  * Copy the data pointed by src and described by type to the socket
 427  *
 428  */
 429 gras_error_t gras_datadesc_send(gras_socket_t *sock,
 430                                 gras_datadesc_type_t *type,
 431                                 void *src) {
 432
 433   gras_error_t errcode;
 434   gras_dd_cbps_t *state = NULL;
 435   gras_dict_t    *refs; /* all references already sent */
 436
 437   TRY(gras_dict_new(&refs));
 438   TRY(gras_dd_cbps_new(&state));
 439
 440   errcode = gras_datadesc_send_rec(sock,state,refs,type,(char*)src);
 441
 442   gras_dict_free(&refs);
 443   gras_dd_cbps_free(&state);
 444
 445   return errcode;
 446 }
 447
 448 /**
 449  * gras_datadesc_recv_rec:
 450  *
 451  * Do the data reception job recursively.
 452  */
 453 gras_error_t
 454 gras_datadesc_recv_rec(gras_socket_t        *sock,
 455                        gras_dd_cbps_t       *state,
 456                        gras_dict_t          *refs,
 457                        gras_datadesc_type_t *type,
 458                        int                   r_arch,
 459                        char                **r_data,
 460                        long int              r_lgr,
 461                        char                **dst) {
 462
 463   gras_error_t          errcode;
 464   char                 *l_data = *dst; /* dereference to avoid typo */
 465   int                   cpt;
 466   gras_datadesc_type_t *sub_type;
 467
 468   VERB1("Recv a %s", type->name);
 469
 470   switch (type->category_code) {
 471   case e_gras_datadesc_type_cat_scalar:
 472     if (!l_data) {
 473       TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst));
 474       l_data = *dst;
 475     }
 476
 477     if (type->size[GRAS_THISARCH] >= type->size[r_arch]) {
 478       TRY(gras_trp_chunk_recv(sock, (char*)l_data, type->size[r_arch]));
 479       TRY(gras_dd_convert_elm(type,r_arch, l_data,l_data));
 480     } else {
 481       void *ptr = NULL;
 482       ptr = malloc((size_t)type->size[r_arch]);
 483       TRY(gras_trp_chunk_recv(sock, (char*)ptr, type->size[r_arch]));
 484       TRY(gras_dd_convert_elm(type,r_arch, ptr,l_data));
 485       free(ptr);
 486     }
 487     break;
 488
 489   case e_gras_datadesc_type_cat_struct: {
 490     gras_dd_cat_struct_t   struct_data;
 491     gras_dd_cat_field_t   *field;
 492
 493     struct_data = type->category.struct_data;
 494
 495     if (!l_data) {
 496       TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst));
 497       l_data = *dst;
 498     }
 499
 500     VERB1(">> Receive all fields of the structure %s",type->name);
 501     gras_dynar_foreach(struct_data.fields, cpt, field) {
 502       char                 *field_data = l_data + field->offset[GRAS_THISARCH];
 503
 504       TRY(gras_datadesc_by_id(field->code, &sub_type));
 505
 506       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
 507                                  r_arch,NULL,0,
 508                                  &field_data));
 509     }
 510     VERB1("<< Received all fields of the structure %s", type->name);
 511
 512     break;
 513   }
 514
 515   case e_gras_datadesc_type_cat_union: {
 516     gras_dd_cat_union_t    union_data;
 517     gras_dd_cat_field_t   *field;
 518     int                    field_num;
 519
 520     union_data = type->category.union_data;
 521
 522     if (!l_data) {
 523       TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst));
 524       l_data = *dst;
 525     }
 526
 527     /* retrieve the field number */
 528     TRY(gras_dd_recv_int(sock, r_arch, &field_num));
 529     if (field_num < 0)
 530       RAISE1(mismatch_error,
 531              "Received union field for %s is negative", type->name);
 532     if (field_num < gras_dynar_length(union_data.fields))
 533       RAISE3(mismatch_error,
 534              "Received union field for %s is %d but there is only %d fields",
 535              type->name, field_num, gras_dynar_length(union_data.fields));
 536
 537     /* Recv the content */
 538     gras_dynar_get(union_data.fields, field_num, field);
 539     TRY(gras_datadesc_by_id(field->code, &sub_type));
 540
 541     TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
 542                                r_arch,NULL,0,
 543                                dst));
 544     break;
 545   }
 546
 547   case e_gras_datadesc_type_cat_ref: {
 548     char             **r_ref = NULL;
 549     char             **l_ref = NULL;
 550     gras_dd_cat_ref_t  ref_data;
 551     int                ref_code;
 552
 553     ref_data = type->category.ref_data;
 554
 555     /* Get the referenced type locally or from peer */
 556     ref_code = ref_data.code;
 557     if (ref_code < 0)
 558       TRY(gras_dd_recv_int(sock, r_arch, &ref_code));
 559
 560     /* Get the actual value of the pointer for cycle handling */
 561     if (!pointer_type)
 562       TRY(gras_datadesc_by_name("data pointer", &pointer_type));
 563
 564     if (! (r_ref = malloc((size_t)pointer_type->size[r_arch])) )
 565       RAISE_MALLOC;
 566     TRY(gras_trp_chunk_recv(sock, (char*)r_ref,
 567                             pointer_type->size[r_arch]));
 568
 569     if (!l_data) {
 570       TRY(gras_dd_alloc_ref(refs,type->size[GRAS_THISARCH],r_data,r_lgr, dst));
 571       l_data = *dst;
 572     }
 573
 574     /* Receive the pointed data only if not already sent */
 575     if (gras_dd_is_r_null(r_ref, pointer_type->size[r_arch])) {
 576       VERB1("Not receiving data remotely referenced at %p since it's NULL",
 577             *(void **)r_ref);
 578       *(void**)l_data = NULL;
 579       break;
 580     }
 581     errcode = gras_dict_retrieve_ext(refs,
 582                                      (char*)r_ref, pointer_type->size[r_arch],
 583                                      (void**)&l_ref);
 584
 585
 586     if (errcode == mismatch_error) {
 587       void *l_referenced=NULL;
 588       VERB1("Receiving data remotely referenced at %p", *(void**)r_ref);
 589
 590       TRY(gras_datadesc_by_id(ref_code, &sub_type));
 591       //      DEBUG2("l_ref= %p; &l_ref=%p",l_referenced,&l_referenced);
 592       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
 593                                  r_arch,r_ref,pointer_type->size[r_arch],
 594                                  (char**)&l_referenced));
 595       *(void**)l_data=l_referenced;
 596
 597     } else if (errcode == no_error) {
 598       VERB1("NOT receiving data remotely referenced at %p (already done). ",
 599             *(void**)r_ref);
 600
 601       VERB2("l_ref=%p; *l_ref=%p", l_ref,*l_ref);
 602
 603       *(void**)l_data=*l_ref;
 604
 605     } else {
 606       return errcode;
 607     }
 608     VERB1("*l_data=%p",*(void**)l_data);
 609     break;
 610   }
 611
 612   case e_gras_datadesc_type_cat_array: {
 613     gras_dd_cat_array_t    array_data;
 614     int       count;
 615     char     *ptr;
 616     long int  elm_size;
 617
 618     array_data = type->category.array_data;
 619     /* determine element count locally or from peer */
 620     count = array_data.fixed_size;
 621     if (count <= 0)
 622       TRY(gras_dd_recv_int(sock, r_arch, &count));
 623     if (count < 0)
 624       RAISE1(mismatch_error,
 625              "Invalid (negative) array size for type %s",type->name);
 626
 627     /* receive the content */
 628     TRY(gras_datadesc_by_id(array_data.code, &sub_type));
 629     elm_size = sub_type->aligned_size[GRAS_THISARCH];
 630
 631     if (!l_data) {
 632       TRY(gras_dd_alloc_ref(refs,elm_size*count,r_data,r_lgr, dst));
 633       l_data = *dst;
 634     }
 635
 636     ptr = l_data;
 637     for (cpt=0; cpt<count; cpt++) {
 638       TRY(gras_datadesc_recv_rec(sock,state,refs, sub_type,
 639                                  r_arch, NULL, 0, &ptr));
 640       ptr += elm_size;
 641     }
 642     break;
 643   }
 644
 645   default:
 646     gras_assert0(0, "Invalid type");
 647   }
 648
 649   return no_error;
 650 }
 651
 652 /**
 653  * gras_datadesc_recv:
 654  *
 655  * Get an instance of the datatype described by @type from the @socket,
 656  * and store a pointer to it in @dst
 657  *
 658  */
 659 gras_error_t
 660 gras_datadesc_recv(gras_socket_t *sock,
 661                    gras_datadesc_type_t *type,
 662                    int r_arch,
 663                    void **dst) {
 664
 665   gras_error_t errcode;
 666   gras_dd_cbps_t *state = NULL; /* callback persistent state */
 667   gras_dict_t    *refs;         /* all references already sent */
 668
 669   TRY(gras_dict_new(&refs));
 670   TRY(gras_dd_cbps_new(&state));
 671   if (!dst)
 672     CRITICAL0("Cannot receive data into a NULL pointer!");
 673   if (*dst)
 674     VERB0("'*dst' not NULL in datadesc_recv. Data to be copied there without malloc");
 675
 676   errcode = gras_datadesc_recv_rec(sock, state, refs, type,
 677                                    r_arch, NULL, 0,
 678                                    (char **) dst);
 679
 680   gras_dict_free(&refs);
 681   gras_dd_cbps_free(&state);
 682
 683   return errcode;
 684 }