This source file includes following definitions.
- pmix_bfrops_base_copy
- pmix_bfrops_base_copy_payload
- pmix_bfrops_base_std_copy
- pmix_bfrops_base_copy_string
- pmix_bfrops_base_copy_value
- pmix_bfrops_base_copy_info
- pmix_bfrops_base_copy_buf
- pmix_bfrops_base_copy_app
- pmix_bfrops_base_copy_kval
- pmix_bfrops_base_copy_proc
- pmix_bfrop_base_copy_persist
- pmix_bfrops_base_copy_bo
- pmix_bfrops_base_copy_pdata
- pmix_bfrops_base_copy_pinfo
- pmix_bfrops_base_copy_darray
- pmix_bfrops_base_copy_query
- pmix_bfrops_base_copy_envar
- pmix_bfrops_base_copy_coord
- pmix_bfrops_base_copy_regattr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 #include <src/include/pmix_config.h>
23
24
25 #include "src/util/argv.h"
26 #include "src/util/error.h"
27 #include "src/util/output.h"
28 #include "src/include/pmix_globals.h"
29
30 #include "src/mca/bfrops/base/base.h"
31
32 pmix_status_t pmix_bfrops_base_copy(pmix_pointer_array_t *regtypes,
33 void **dest, void *src,
34 pmix_data_type_t type)
35 {
36 pmix_bfrop_type_info_t *info;
37
38
39 if (NULL == dest || NULL == src) {
40 PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
41 return PMIX_ERR_BAD_PARAM;
42 }
43
44
45 if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(regtypes, type))) {
46 PMIX_ERROR_LOG(PMIX_ERR_UNKNOWN_DATA_TYPE);
47 return PMIX_ERR_UNKNOWN_DATA_TYPE;
48 }
49
50 return info->odti_copy_fn(dest, src, type);
51 }
52
53 pmix_status_t pmix_bfrops_base_copy_payload(pmix_buffer_t *dest,
54 pmix_buffer_t *src)
55 {
56 size_t to_copy = 0;
57 char *ptr;
58
59
60 if (NULL == dest->base_ptr){
61
62 dest->type = src->type;
63 } else if (dest->type != src->type) {
64
65 PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
66 return PMIX_ERR_BAD_PARAM;
67 }
68
69 to_copy = src->pack_ptr - src->unpack_ptr;
70 if (NULL == (ptr = pmix_bfrop_buffer_extend(dest, to_copy))) {
71 PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
72 return PMIX_ERR_OUT_OF_RESOURCE;
73 }
74 memcpy(ptr,src->unpack_ptr, to_copy);
75 dest->bytes_used += to_copy;
76 dest->pack_ptr += to_copy;
77 return PMIX_SUCCESS;
78 }
79
80
81
82
83
84 pmix_status_t pmix_bfrops_base_std_copy(void **dest, void *src,
85 pmix_data_type_t type)
86 {
87 size_t datasize;
88 uint8_t *val = NULL;
89
90 switch(type) {
91 case PMIX_BOOL:
92 datasize = sizeof(bool);
93 break;
94
95 case PMIX_INT:
96 case PMIX_UINT:
97 datasize = sizeof(int);
98 break;
99
100 case PMIX_SIZE:
101 datasize = sizeof(size_t);
102 break;
103
104 case PMIX_PID:
105 datasize = sizeof(pid_t);
106 break;
107
108 case PMIX_BYTE:
109 case PMIX_INT8:
110 case PMIX_UINT8:
111 datasize = 1;
112 break;
113
114 case PMIX_INT16:
115 case PMIX_UINT16:
116 case PMIX_IOF_CHANNEL:
117 datasize = 2;
118 break;
119
120 case PMIX_INT32:
121 case PMIX_UINT32:
122 datasize = 4;
123 break;
124
125 case PMIX_INT64:
126 case PMIX_UINT64:
127 datasize = 8;
128 break;
129
130 case PMIX_FLOAT:
131 datasize = sizeof(float);
132 break;
133
134 case PMIX_TIMEVAL:
135 datasize = sizeof(struct timeval);
136 break;
137
138 case PMIX_TIME:
139 datasize = sizeof(time_t);
140 break;
141
142 case PMIX_STATUS:
143 datasize = sizeof(pmix_status_t);
144 break;
145
146 case PMIX_PROC_RANK:
147 datasize = sizeof(pmix_rank_t);
148 break;
149
150 case PMIX_PERSIST:
151 datasize = sizeof(pmix_persistence_t);
152 break;
153
154 case PMIX_POINTER:
155 datasize = sizeof(char*);
156 break;
157
158 case PMIX_SCOPE:
159 datasize = sizeof(pmix_scope_t);
160 break;
161
162 case PMIX_DATA_RANGE:
163 datasize = sizeof(pmix_data_range_t);
164 break;
165
166 case PMIX_COMMAND:
167 datasize = sizeof(pmix_cmd_t);
168 break;
169
170 case PMIX_INFO_DIRECTIVES:
171 datasize = sizeof(pmix_info_directives_t);
172 break;
173
174 case PMIX_PROC_STATE:
175 datasize = sizeof(pmix_proc_state_t);
176 break;
177
178 case PMIX_ALLOC_DIRECTIVE:
179 datasize = sizeof(pmix_alloc_directive_t);
180 break;
181
182 default:
183 return PMIX_ERR_UNKNOWN_DATA_TYPE;
184 }
185
186 val = (uint8_t*)malloc(datasize);
187 if (NULL == val) {
188 return PMIX_ERR_OUT_OF_RESOURCE;
189 }
190
191 memcpy(val, src, datasize);
192 *dest = val;
193
194 return PMIX_SUCCESS;
195 }
196
197
198
199
200
201
202 pmix_status_t pmix_bfrops_base_copy_string(char **dest, char *src,
203 pmix_data_type_t type)
204 {
205 if (NULL == src) {
206 *dest = NULL;
207 } else {
208 *dest = strdup(src);
209 }
210
211 return PMIX_SUCCESS;
212 }
213
214
215 pmix_status_t pmix_bfrops_base_copy_value(pmix_value_t **dest,
216 pmix_value_t *src,
217 pmix_data_type_t type)
218 {
219 pmix_value_t *p;
220
221
222 *dest = (pmix_value_t*)malloc(sizeof(pmix_value_t));
223 if (NULL == *dest) {
224 return PMIX_ERR_OUT_OF_RESOURCE;
225 }
226 p = *dest;
227
228
229 p->type = src->type;
230
231 return pmix_bfrops_base_value_xfer(p, src);
232 }
233
234 pmix_status_t pmix_bfrops_base_copy_info(pmix_info_t **dest,
235 pmix_info_t *src,
236 pmix_data_type_t type)
237 {
238 *dest = (pmix_info_t*)malloc(sizeof(pmix_info_t));
239 pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
240 (*dest)->flags = src->flags;
241 return pmix_bfrops_base_value_xfer(&(*dest)->value, &src->value);
242 }
243
244 pmix_status_t pmix_bfrops_base_copy_buf(pmix_buffer_t **dest,
245 pmix_buffer_t *src,
246 pmix_data_type_t type)
247 {
248 *dest = PMIX_NEW(pmix_buffer_t);
249 pmix_bfrops_base_copy_payload(*dest, src);
250 return PMIX_SUCCESS;
251 }
252
253 pmix_status_t pmix_bfrops_base_copy_app(pmix_app_t **dest,
254 pmix_app_t *src,
255 pmix_data_type_t type)
256 {
257 size_t j;
258
259 *dest = (pmix_app_t*)malloc(sizeof(pmix_app_t));
260 (*dest)->cmd = strdup(src->cmd);
261 (*dest)->argv = pmix_argv_copy(src->argv);
262 (*dest)->env = pmix_argv_copy(src->env);
263 if (NULL != src->cwd) {
264 (*dest)->cwd = strdup(src->cwd);
265 }
266 (*dest)->maxprocs = src->maxprocs;
267 (*dest)->ninfo = src->ninfo;
268 (*dest)->info = (pmix_info_t*)malloc(src->ninfo * sizeof(pmix_info_t));
269 for (j=0; j < src->ninfo; j++) {
270 pmix_strncpy((*dest)->info[j].key, src->info[j].key, PMIX_MAX_KEYLEN);
271 pmix_value_xfer(&(*dest)->info[j].value, &src->info[j].value);
272 }
273 return PMIX_SUCCESS;
274 }
275
276 pmix_status_t pmix_bfrops_base_copy_kval(pmix_kval_t **dest,
277 pmix_kval_t *src,
278 pmix_data_type_t type)
279 {
280 pmix_kval_t *p;
281
282
283 *dest = PMIX_NEW(pmix_kval_t);
284 if (NULL == *dest) {
285 return PMIX_ERR_OUT_OF_RESOURCE;
286 }
287 p = *dest;
288
289
290 p->value->type = src->value->type;
291
292 return pmix_bfrops_base_value_xfer(p->value, src->value);
293 }
294
295 pmix_status_t pmix_bfrops_base_copy_proc(pmix_proc_t **dest,
296 pmix_proc_t *src,
297 pmix_data_type_t type)
298 {
299 *dest = (pmix_proc_t*)malloc(sizeof(pmix_proc_t));
300 if (NULL == *dest) {
301 return PMIX_ERR_OUT_OF_RESOURCE;
302 }
303 pmix_strncpy((*dest)->nspace, src->nspace, PMIX_MAX_NSLEN);
304 (*dest)->rank = src->rank;
305 return PMIX_SUCCESS;
306 }
307
308 pmix_status_t pmix_bfrop_base_copy_persist(pmix_persistence_t **dest,
309 pmix_persistence_t *src,
310 pmix_data_type_t type)
311 {
312 *dest = (pmix_persistence_t*)malloc(sizeof(pmix_persistence_t));
313 if (NULL == *dest) {
314 return PMIX_ERR_OUT_OF_RESOURCE;
315 }
316 memcpy(*dest, src, sizeof(pmix_persistence_t));
317 return PMIX_SUCCESS;
318 }
319
320 pmix_status_t pmix_bfrops_base_copy_bo(pmix_byte_object_t **dest,
321 pmix_byte_object_t *src,
322 pmix_data_type_t type)
323 {
324 *dest = (pmix_byte_object_t*)malloc(sizeof(pmix_byte_object_t));
325 if (NULL == *dest) {
326 return PMIX_ERR_OUT_OF_RESOURCE;
327 }
328 (*dest)->bytes = (char*)malloc(src->size);
329 memcpy((*dest)->bytes, src->bytes, src->size);
330 (*dest)->size = src->size;
331 return PMIX_SUCCESS;
332 }
333
334 pmix_status_t pmix_bfrops_base_copy_pdata(pmix_pdata_t **dest,
335 pmix_pdata_t *src,
336 pmix_data_type_t type)
337 {
338 *dest = (pmix_pdata_t*)malloc(sizeof(pmix_pdata_t));
339 pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
340 (*dest)->proc.rank = src->proc.rank;
341 pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
342 return pmix_bfrops_base_value_xfer(&(*dest)->value, &src->value);
343 }
344
345 pmix_status_t pmix_bfrops_base_copy_pinfo(pmix_proc_info_t **dest,
346 pmix_proc_info_t *src,
347 pmix_data_type_t type)
348 {
349 pmix_proc_info_t *p;
350
351 PMIX_PROC_INFO_CREATE(p, 1);
352 if (NULL == p) {
353 return PMIX_ERR_NOMEM;
354 }
355 memcpy(&p->proc, &src->proc, sizeof(pmix_proc_t));
356 if (NULL != src->hostname) {
357 p->hostname = strdup(src->hostname);
358 }
359 if (NULL != src->executable_name) {
360 p->executable_name = strdup(src->executable_name);
361 }
362 memcpy(&p->pid, &src->pid, sizeof(pid_t));
363 memcpy(&p->exit_code, &src->exit_code, sizeof(int));
364 memcpy(&p->state, &src->state, sizeof(pmix_proc_state_t));
365 *dest = p;
366 return PMIX_SUCCESS;
367 }
368
369
370
371
372 pmix_status_t pmix_bfrops_base_copy_darray(pmix_data_array_t **dest,
373 pmix_data_array_t *src,
374 pmix_data_type_t type)
375 {
376 pmix_data_array_t *p;
377 size_t n, m;
378 pmix_status_t rc;
379 char **prarray, **strarray;
380 pmix_value_t *pv, *sv;
381 pmix_app_t *pa, *sa;
382 pmix_info_t *p1, *s1;
383 pmix_pdata_t *pd, *sd;
384 pmix_buffer_t *pb, *sb;
385 pmix_byte_object_t *pbo, *sbo;
386 pmix_kval_t *pk, *sk;
387 pmix_proc_info_t *pi, *si;
388 pmix_query_t *pq, *sq;
389 pmix_envar_t *pe, *se;
390 pmix_regattr_t *pr, *sr;
391
392 p = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
393 if (NULL == p) {
394 return PMIX_ERR_NOMEM;
395 }
396 p->type = src->type;
397 p->size = src->size;
398 if (0 == p->size || NULL == src->array) {
399 *dest = p;
400 return PMIX_SUCCESS;
401 }
402
403
404 switch (src->type) {
405 case PMIX_UINT8:
406 case PMIX_INT8:
407 case PMIX_BYTE:
408 p->array = (char*)malloc(src->size);
409 if (NULL == p->array) {
410 free(p);
411 return PMIX_ERR_NOMEM;
412 }
413 memcpy(p->array, src->array, src->size);
414 break;
415 case PMIX_UINT16:
416 case PMIX_INT16:
417 p->array = (char*)malloc(src->size * sizeof(uint16_t));
418 if (NULL == p->array) {
419 free(p);
420 return PMIX_ERR_NOMEM;
421 }
422 memcpy(p->array, src->array, src->size * sizeof(uint16_t));
423 break;
424 case PMIX_UINT32:
425 case PMIX_INT32:
426 p->array = (char*)malloc(src->size * sizeof(uint32_t));
427 if (NULL == p->array) {
428 free(p);
429 return PMIX_ERR_NOMEM;
430 }
431 memcpy(p->array, src->array, src->size * sizeof(uint32_t));
432 break;
433 case PMIX_UINT64:
434 case PMIX_INT64:
435 p->array = (char*)malloc(src->size * sizeof(uint64_t));
436 if (NULL == p->array) {
437 free(p);
438 return PMIX_ERR_NOMEM;
439 }
440 memcpy(p->array, src->array, src->size * sizeof(uint64_t));
441 break;
442 case PMIX_BOOL:
443 p->array = (char*)malloc(src->size * sizeof(bool));
444 if (NULL == p->array) {
445 free(p);
446 return PMIX_ERR_NOMEM;
447 }
448 memcpy(p->array, src->array, src->size * sizeof(bool));
449 break;
450 case PMIX_SIZE:
451 p->array = (char*)malloc(src->size * sizeof(size_t));
452 if (NULL == p->array) {
453 free(p);
454 return PMIX_ERR_NOMEM;
455 }
456 memcpy(p->array, src->array, src->size * sizeof(size_t));
457 break;
458 case PMIX_PID:
459 p->array = (char*)malloc(src->size * sizeof(pid_t));
460 if (NULL == p->array) {
461 free(p);
462 return PMIX_ERR_NOMEM;
463 }
464 memcpy(p->array, src->array, src->size * sizeof(pid_t));
465 break;
466 case PMIX_STRING:
467 p->array = (char**)malloc(src->size * sizeof(char*));
468 if (NULL == p->array) {
469 free(p);
470 return PMIX_ERR_NOMEM;
471 }
472 prarray = (char**)p->array;
473 strarray = (char**)src->array;
474 for (n=0; n < src->size; n++) {
475 if (NULL != strarray[n]) {
476 prarray[n] = strdup(strarray[n]);
477 }
478 }
479 break;
480 case PMIX_INT:
481 case PMIX_UINT:
482 p->array = (char*)malloc(src->size * sizeof(int));
483 if (NULL == p->array) {
484 free(p);
485 return PMIX_ERR_NOMEM;
486 }
487 memcpy(p->array, src->array, src->size * sizeof(int));
488 break;
489 case PMIX_FLOAT:
490 p->array = (char*)malloc(src->size * sizeof(float));
491 if (NULL == p->array) {
492 free(p);
493 return PMIX_ERR_NOMEM;
494 }
495 memcpy(p->array, src->array, src->size * sizeof(float));
496 break;
497 case PMIX_DOUBLE:
498 p->array = (char*)malloc(src->size * sizeof(double));
499 if (NULL == p->array) {
500 free(p);
501 return PMIX_ERR_NOMEM;
502 }
503 memcpy(p->array, src->array, src->size * sizeof(double));
504 break;
505 case PMIX_TIMEVAL:
506 p->array = (struct timeval*)malloc(src->size * sizeof(struct timeval));
507 if (NULL == p->array) {
508 free(p);
509 return PMIX_ERR_NOMEM;
510 }
511 memcpy(p->array, src->array, src->size * sizeof(struct timeval));
512 break;
513 case PMIX_TIME:
514 p->array = (time_t*)malloc(src->size * sizeof(time_t));
515 if (NULL == p->array) {
516 free(p);
517 return PMIX_ERR_NOMEM;
518 }
519 memcpy(p->array, src->array, src->size * sizeof(time_t));
520 break;
521 case PMIX_STATUS:
522 p->array = (pmix_status_t*)malloc(src->size * sizeof(pmix_status_t));
523 if (NULL == p->array) {
524 free(p);
525 return PMIX_ERR_NOMEM;
526 }
527 memcpy(p->array, src->array, src->size * sizeof(pmix_status_t));
528 break;
529 case PMIX_VALUE:
530 PMIX_VALUE_CREATE(p->array, src->size);
531 if (NULL == p->array) {
532 free(p);
533 return PMIX_ERR_NOMEM;
534 }
535 pv = (pmix_value_t*)p->array;
536 sv = (pmix_value_t*)src->array;
537 for (n=0; n < src->size; n++) {
538 if (PMIX_SUCCESS != (rc = pmix_bfrops_base_value_xfer(&pv[n], &sv[n]))) {
539 PMIX_VALUE_FREE(pv, src->size);
540 free(p);
541 return rc;
542 }
543 }
544 break;
545 case PMIX_PROC:
546 PMIX_PROC_CREATE(p->array, src->size);
547 if (NULL == p->array) {
548 free(p);
549 return PMIX_ERR_NOMEM;
550 }
551 memcpy(p->array, src->array, src->size * sizeof(pmix_proc_t));
552 break;
553 case PMIX_PROC_RANK:
554 p->array = (char*)malloc(src->size * sizeof(pmix_rank_t));
555 if (NULL == p->array) {
556 free(p);
557 return PMIX_ERR_NOMEM;
558 }
559 memcpy(p->array, src->array, src->size * sizeof(pmix_proc_t));
560 break;
561 case PMIX_APP:
562 PMIX_APP_CREATE(p->array, src->size);
563 if (NULL == p->array) {
564 free(p);
565 return PMIX_ERR_NOMEM;
566 }
567 pa = (pmix_app_t*)p->array;
568 sa = (pmix_app_t*)src->array;
569 for (n=0; n < src->size; n++) {
570 if (NULL != sa[n].cmd) {
571 pa[n].cmd = strdup(sa[n].cmd);
572 }
573 if (NULL != sa[n].argv) {
574 pa[n].argv = pmix_argv_copy(sa[n].argv);
575 }
576 if (NULL != sa[n].env) {
577 pa[n].env = pmix_argv_copy(sa[n].env);
578 }
579 if (NULL != sa[n].cwd) {
580 pa[n].cwd = strdup(sa[n].cwd);
581 }
582 pa[n].maxprocs = sa[n].maxprocs;
583 if (0 < sa[n].ninfo && NULL != sa[n].info) {
584 PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
585 if (NULL == pa[n].info) {
586 PMIX_APP_FREE(pa, p->size);
587 free(p);
588 return PMIX_ERR_NOMEM;
589 }
590 pa[n].ninfo = sa[n].ninfo;
591 for (m=0; m < pa[n].ninfo; m++) {
592 PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
593 }
594 }
595 }
596 break;
597 case PMIX_INFO:
598 PMIX_INFO_CREATE(p->array, src->size);
599 if (NULL == p->array) {
600 free(p);
601 return PMIX_ERR_NOMEM;
602 }
603 p1 = (pmix_info_t*)p->array;
604 s1 = (pmix_info_t*)src->array;
605 for (n=0; n < src->size; n++) {
606 PMIX_INFO_XFER(&p1[n], &s1[n]);
607 }
608 break;
609 case PMIX_PDATA:
610 PMIX_PDATA_CREATE(p->array, src->size);
611 if (NULL == p->array) {
612 free(p);
613 return PMIX_ERR_NOMEM;
614 }
615 pd = (pmix_pdata_t*)p->array;
616 sd = (pmix_pdata_t*)src->array;
617 for (n=0; n < src->size; n++) {
618 PMIX_PDATA_XFER(&pd[n], &sd[n]);
619 }
620 break;
621 case PMIX_BUFFER:
622 p->array = (pmix_buffer_t*)malloc(src->size * sizeof(pmix_buffer_t));
623 if (NULL == p->array) {
624 free(p);
625 return PMIX_ERR_NOMEM;
626 }
627 pb = (pmix_buffer_t*)p->array;
628 sb = (pmix_buffer_t*)src->array;
629 for (n=0; n < src->size; n++) {
630 PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
631 pmix_bfrops_base_copy_payload(&pb[n], &sb[n]);
632 }
633 break;
634 case PMIX_BYTE_OBJECT:
635 case PMIX_COMPRESSED_STRING:
636 p->array = (pmix_byte_object_t*)malloc(src->size * sizeof(pmix_byte_object_t));
637 if (NULL == p->array) {
638 free(p);
639 return PMIX_ERR_NOMEM;
640 }
641 pbo = (pmix_byte_object_t*)p->array;
642 sbo = (pmix_byte_object_t*)src->array;
643 for (n=0; n < src->size; n++) {
644 if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
645 pbo[n].size = sbo[n].size;
646 pbo[n].bytes = (char*)malloc(pbo[n].size);
647 memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
648 } else {
649 pbo[n].bytes = NULL;
650 pbo[n].size = 0;
651 }
652 }
653 break;
654 case PMIX_KVAL:
655 p->array = (pmix_kval_t*)calloc(src->size , sizeof(pmix_kval_t));
656 if (NULL == p->array) {
657 free(p);
658 return PMIX_ERR_NOMEM;
659 }
660 pk = (pmix_kval_t*)p->array;
661 sk = (pmix_kval_t*)src->array;
662 for (n=0; n < src->size; n++) {
663 if (NULL != sk[n].key) {
664 pk[n].key = strdup(sk[n].key);
665 }
666 if (NULL != sk[n].value) {
667 PMIX_VALUE_CREATE(pk[n].value, 1);
668 if (NULL == pk[n].value) {
669 PMIX_VALUE_FREE(pk[n].value, 1);
670 free(p);
671 return PMIX_ERR_NOMEM;
672 }
673 if (PMIX_SUCCESS != (rc = pmix_bfrops_base_value_xfer(pk[n].value, sk[n].value))) {
674 PMIX_VALUE_FREE(pk[n].value, 1);
675 free(p);
676 return rc;
677 }
678 }
679 }
680 break;
681 case PMIX_PERSIST:
682 p->array = (pmix_persistence_t*)malloc(src->size * sizeof(pmix_persistence_t));
683 if (NULL == p->array) {
684 free(p);
685 return PMIX_ERR_NOMEM;
686 }
687 memcpy(p->array, src->array, src->size * sizeof(pmix_persistence_t));
688 break;
689 case PMIX_POINTER:
690 p->array = (char**)malloc(src->size * sizeof(char*));
691 prarray = (char**)p->array;
692 strarray = (char**)src->array;
693 for (n=0; n < src->size; n++) {
694 prarray[n] = strarray[n];
695 }
696 break;
697 case PMIX_SCOPE:
698 p->array = (pmix_scope_t*)malloc(src->size * sizeof(pmix_scope_t));
699 if (NULL == p->array) {
700 free(p);
701 return PMIX_ERR_NOMEM;
702 }
703 memcpy(p->array, src->array, src->size * sizeof(pmix_scope_t));
704 break;
705 case PMIX_DATA_RANGE:
706 p->array = (pmix_data_range_t*)malloc(src->size * sizeof(pmix_data_range_t));
707 if (NULL == p->array) {
708 free(p);
709 return PMIX_ERR_NOMEM;
710 }
711 memcpy(p->array, src->array, src->size * sizeof(pmix_data_range_t));
712 break;
713 case PMIX_COMMAND:
714 p->array = (pmix_cmd_t*)malloc(src->size * sizeof(pmix_cmd_t));
715 if (NULL == p->array) {
716 free(p);
717 return PMIX_ERR_NOMEM;
718 }
719 memcpy(p->array, src->array, src->size * sizeof(pmix_cmd_t));
720 break;
721 case PMIX_INFO_DIRECTIVES:
722 p->array = (pmix_info_directives_t*)malloc(src->size * sizeof(pmix_info_directives_t));
723 if (NULL == p->array) {
724 free(p);
725 return PMIX_ERR_NOMEM;
726 }
727 memcpy(p->array, src->array, src->size * sizeof(pmix_info_directives_t));
728 break;
729 case PMIX_PROC_INFO:
730 PMIX_PROC_INFO_CREATE(p->array, src->size);
731 if (NULL == p->array) {
732 free(p);
733 return PMIX_ERR_NOMEM;
734 }
735 pi = (pmix_proc_info_t*)p->array;
736 si = (pmix_proc_info_t*)src->array;
737 for (n=0; n < src->size; n++) {
738 memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
739 if (NULL != si[n].hostname) {
740 pi[n].hostname = strdup(si[n].hostname);
741 } else {
742 pi[n].hostname = NULL;
743 }
744 if (NULL != si[n].executable_name) {
745 pi[n].executable_name = strdup(si[n].executable_name);
746 } else {
747 pi[n].executable_name = NULL;
748 }
749 pi[n].pid = si[n].pid;
750 pi[n].exit_code = si[n].exit_code;
751 pi[n].state = si[n].state;
752 }
753 break;
754 case PMIX_DATA_ARRAY:
755 free(p);
756 return PMIX_ERR_NOT_SUPPORTED;
757 case PMIX_QUERY:
758 PMIX_QUERY_CREATE(p->array, src->size);
759 if (NULL == p->array) {
760 free(p);
761 return PMIX_ERR_NOMEM;
762 }
763 pq = (pmix_query_t*)p->array;
764 sq = (pmix_query_t*)src->array;
765 for (n=0; n < src->size; n++) {
766 if (NULL != sq[n].keys) {
767 pq[n].keys = pmix_argv_copy(sq[n].keys);
768 }
769 if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
770 PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
771 if (NULL == pq[n].qualifiers) {
772 PMIX_INFO_FREE(pq[n].qualifiers, sq[n].nqual);
773 free(p);
774 return PMIX_ERR_NOMEM;
775 }
776 for (m=0; m < sq[n].nqual; m++) {
777 PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
778 }
779 pq[n].nqual = sq[n].nqual;
780 } else {
781 pq[n].qualifiers = NULL;
782 pq[n].nqual = 0;
783 }
784 }
785 break;
786 case PMIX_ENVAR:
787 PMIX_ENVAR_CREATE(p->array, src->size);
788 if (NULL == p->array) {
789 free(p);
790 return PMIX_ERR_NOMEM;
791 }
792 pe = (pmix_envar_t*)p->array;
793 se = (pmix_envar_t*)src->array;
794 for (n=0; n < src->size; n++) {
795 if (NULL != se[n].envar) {
796 pe[n].envar = strdup(se[n].envar);
797 }
798 if (NULL != se[n].value) {
799 pe[n].value = strdup(se[n].value);
800 }
801 pe[n].separator = se[n].separator;
802 }
803 break;
804 case PMIX_COORD:
805 p->array = malloc(src->size * sizeof(pmix_coord_t));
806 if (NULL == p->array) {
807 free(p);
808 return PMIX_ERR_NOMEM;
809 }
810 memcpy(p->array, src->array, src->size * sizeof(pmix_coord_t));
811 break;
812 case PMIX_REGATTR:
813 PMIX_REGATTR_CREATE(p->array, src->size);
814 if (NULL == p->array) {
815 free(p);
816 return PMIX_ERR_NOMEM;
817 }
818 pr = (pmix_regattr_t*)p->array;
819 sr = (pmix_regattr_t*)src->array;
820 for (n=0; n < src->size; n++) {
821 if (NULL != sr[n].name) {
822 pr[n].name = strdup(sr[n].name);
823 }
824 PMIX_LOAD_KEY(pr[n].string, sr[n].string);
825 pr[n].type = sr[n].type;
826 if (NULL != sr[n].info) {
827 PMIX_INFO_XFER(pr[n].info, sr[n].info);
828 }
829 pr[n].ninfo = sr[n].ninfo;
830 pr[n].description = pmix_argv_copy(sr[n].description);
831 }
832 break;
833 default:
834 free(p);
835 return PMIX_ERR_UNKNOWN_DATA_TYPE;
836 }
837
838 (*dest) = p;
839 return PMIX_SUCCESS;
840 }
841
842 pmix_status_t pmix_bfrops_base_copy_query(pmix_query_t **dest,
843 pmix_query_t *src,
844 pmix_data_type_t type)
845 {
846 pmix_status_t rc;
847
848 *dest = (pmix_query_t*)malloc(sizeof(pmix_query_t));
849 if (NULL != src->keys) {
850 (*dest)->keys = pmix_argv_copy(src->keys);
851 }
852 (*dest)->nqual = src->nqual;
853 if (NULL != src->qualifiers) {
854 if (PMIX_SUCCESS != (rc = pmix_bfrops_base_copy_info(&((*dest)->qualifiers), src->qualifiers, PMIX_INFO))) {
855 free(*dest);
856 return rc;
857 }
858 }
859 return PMIX_SUCCESS;
860 }
861
862 pmix_status_t pmix_bfrops_base_copy_envar(pmix_envar_t **dest,
863 pmix_envar_t *src,
864 pmix_data_type_t type)
865 {
866 PMIX_ENVAR_CREATE(*dest, 1);
867 if (NULL == (*dest)) {
868 return PMIX_ERR_NOMEM;
869 }
870 if (NULL != src->envar) {
871 (*dest)->envar = strdup(src->envar);
872 }
873 if (NULL != src->value) {
874 (*dest)->value = strdup(src->value);
875 }
876 (*dest)->separator = src->separator;
877 return PMIX_SUCCESS;
878 }
879
880 pmix_status_t pmix_bfrops_base_copy_coord(pmix_coord_t **dest,
881 pmix_coord_t *src,
882 pmix_data_type_t type)
883 {
884 *dest = (pmix_coord_t*)malloc(sizeof(pmix_coord_t));
885 memcpy(*dest, src, sizeof(pmix_coord_t));
886 return PMIX_SUCCESS;
887 }
888
889 pmix_status_t pmix_bfrops_base_copy_regattr(pmix_regattr_t **dest,
890 pmix_regattr_t *src,
891 pmix_data_type_t type)
892 {
893 PMIX_REGATTR_CREATE(*dest, 1);
894 if (NULL == (*dest)) {
895 return PMIX_ERR_NOMEM;
896 }
897 if (NULL != src->name) {
898 (*dest)->name = strdup(src->name);
899 }
900 PMIX_LOAD_KEY((*dest)->string, src->string);
901 (*dest)->type = src->type;
902 if (NULL != src->info) {
903 PMIX_INFO_XFER((*dest)->info, src->info);
904 }
905 (*dest)->ninfo = src->ninfo;
906 (*dest)->description = pmix_argv_copy(src->description);
907 return PMIX_SUCCESS;
908 }