Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
API cleanup: s/dict_insert/dict_set/ and s/dict_retrieve/dict_get/ for consistency...
[simgrid.git] / 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_set_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_get_ext(refs,(char*)ref, sizeof(void*), &dummy);
370     if (errcode == mismatch_error) {
371       VERB1("Sending data referenced at %p", *ref);
372       TRY(gras_dict_set_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_get_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 }