root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v20/copy.c

DEFINITIONS

1. pmix20_bfrop_copy
2. pmix20_bfrop_copy_payload
3. pmix20_bfrop_std_copy
4. pmix20_bfrop_value_cmp
5. pmix20_bfrop_copy_string
6. pmix_value_cmp
7. pmix20_bfrop_value_xfer
8. pmix20_bfrop_copy_value
9. pmix20_bfrop_copy_info
10. pmix20_bfrop_copy_buf
11. pmix20_bfrop_copy_app
12. pmix20_bfrop_copy_kval
13. pmix20_bfrop_copy_proc
14. pmix20_bfrop_copy_modex
15. pmix20_bfrop_copy_persist
16. pmix20_bfrop_copy_bo
17. pmix20_bfrop_copy_pdata
18. pmix20_bfrop_copy_pinfo
19. pmix20_bfrop_copy_darray
20. pmix20_bfrop_copy_query
21. pmix20_bfrop_copy_array

   1 /*
   2  * Copyright (c) 2004-2007 The Trustees of Indiana University and Indiana
   3  *                         University Research and Technology
   4  *                         Corporation.  All rights reserved.
   5  * Copyright (c) 2004-2006 The University of Tennessee and The University
   6  *                         of Tennessee Research Foundation.  All rights
   7  *                         reserved.
   8  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
   9  *                         University of Stuttgart.  All rights reserved.
  10  * Copyright (c) 2004-2005 The Regents of the University of California.
  11  *                         All rights reserved.
  12  * Copyright (c) 2014-2018 Intel, Inc.  All rights reserved.
  13  * Copyright (c) 2015      Research Organization for Information Science
  14  *                         and Technology (RIST). All rights reserved.
  15  * Copyright (c) 2016      IBM Corporation.  All rights reserved.
  16  * $COPYRIGHT$
  17  *
  18  * Additional copyrights may follow
  19  *
  20  * $HEADER$
  21  */
  22 
  23 #include <src/include/pmix_config.h>
  24 
  25 
  26 #include "src/util/argv.h"
  27 #include "src/util/error.h"
  28 #include "src/util/output.h"
  29 #include "src/mca/bfrops/base/base.h"
  30 #include "bfrop_pmix20.h"
  31 #include "internal.h"
  32 
  33  pmix_status_t pmix20_bfrop_copy(void **dest, void *src, pmix_data_type_t type)
  34 {
  35     pmix_bfrop_type_info_t *info;
  36 
  37     /* check for error */
  38     if (NULL == dest) {
  39         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  40         return PMIX_ERR_BAD_PARAM;
  41     }
  42     if (NULL == src) {
  43         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  44         return PMIX_ERR_BAD_PARAM;
  45     }
  46 
  47    /* Lookup the copy function for this type and call it */
  48 
  49     if (NULL == (info = (pmix_bfrop_type_info_t*)pmix_pointer_array_get_item(&mca_bfrops_v20_component.types, type))) {
  50         PMIX_ERROR_LOG(PMIX_ERR_UNKNOWN_DATA_TYPE);
  51         return PMIX_ERR_UNKNOWN_DATA_TYPE;
  52     }
  53 
  54     return info->odti_copy_fn(dest, src, type);
  55 }
  56 
  57 pmix_status_t pmix20_bfrop_copy_payload(pmix_buffer_t *dest, pmix_buffer_t *src)
  58 {
  59     size_t to_copy = 0;
  60     char *ptr;
  61     /* deal with buffer type */
  62     if( NULL == dest->base_ptr ){
  63         /* destination buffer is empty - derive src buffer type */
  64         dest->type = src->type;
  65     } else if( dest->type != src->type ){
  66         /* buffer types mismatch */
  67         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  68         return PMIX_ERR_BAD_PARAM;
  69     }
  70 
  71     to_copy = src->pack_ptr - src->unpack_ptr;
  72     if( NULL == (ptr = pmix_bfrop_buffer_extend(dest, to_copy)) ){
  73         PMIX_ERROR_LOG(PMIX_ERR_OUT_OF_RESOURCE);
  74         return PMIX_ERR_OUT_OF_RESOURCE;
  75     }
  76     memcpy(ptr,src->unpack_ptr, to_copy);
  77     dest->bytes_used += to_copy;
  78     dest->pack_ptr += to_copy;
  79     return PMIX_SUCCESS;
  80 }
  81 
  82 
  83 /*
  84  * STANDARD COPY FUNCTION - WORKS FOR EVERYTHING NON-STRUCTURED
  85  */
  86  pmix_status_t pmix20_bfrop_std_copy(void **dest, void *src, pmix_data_type_t type)
  87 {
  88     size_t datasize;
  89     uint8_t *val = NULL;
  90 
  91     switch(type) {
  92     case PMIX_BOOL:
  93         datasize = sizeof(bool);
  94         break;
  95 
  96     case PMIX_INT:
  97     case PMIX_UINT:
  98         datasize = sizeof(int);
  99         break;
 100 
 101     case PMIX_SIZE:
 102         datasize = sizeof(size_t);
 103         break;
 104 
 105     case PMIX_PID:
 106         datasize = sizeof(pid_t);
 107         break;
 108 
 109     case PMIX_BYTE:
 110     case PMIX_INT8:
 111     case PMIX_UINT8:
 112         datasize = 1;
 113         break;
 114 
 115     case PMIX_INT16:
 116     case PMIX_UINT16:
 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 /* compare function for pmix_value_t*/
 198 pmix_value_cmp_t pmix20_bfrop_value_cmp(pmix_value_t *p, pmix_value_t *p1)
 199 {
 200     bool rc = false;
 201     switch (p->type) {
 202         case PMIX_BOOL:
 203             rc = (p->data.flag == p1->data.flag);
 204             break;
 205         case PMIX_BYTE:
 206             rc = (p->data.byte == p1->data.byte);
 207             break;
 208         case PMIX_SIZE:
 209             rc = (p->data.size == p1->data.size);
 210             break;
 211         case PMIX_INT:
 212             rc = (p->data.integer == p1->data.integer);
 213             break;
 214         case PMIX_INT8:
 215             rc = (p->data.int8 == p1->data.int8);
 216             break;
 217         case PMIX_INT16:
 218             rc = (p->data.int16 == p1->data.int16);
 219             break;
 220         case PMIX_INT32:
 221             rc = (p->data.int32 == p1->data.int32);
 222             break;
 223         case PMIX_INT64:
 224             rc = (p->data.int64 == p1->data.int64);
 225             break;
 226         case PMIX_UINT:
 227             rc = (p->data.uint == p1->data.uint);
 228             break;
 229         case PMIX_UINT8:
 230             rc = (p->data.uint8 == p1->data.int8);
 231             break;
 232         case PMIX_UINT16:
 233             rc = (p->data.uint16 == p1->data.uint16);
 234             break;
 235         case PMIX_UINT32:
 236             rc = (p->data.uint32 == p1->data.uint32);
 237             break;
 238         case PMIX_UINT64:
 239             rc = (p->data.uint64 == p1->data.uint64);
 240             break;
 241         case PMIX_STRING:
 242             rc = strcmp(p->data.string, p1->data.string);
 243             break;
 244         default:
 245             pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
 246     }
 247     if (rc) {
 248         return PMIX_EQUAL;
 249     }
 250     return PMIX_VALUE1_GREATER;
 251 }
 252 
 253 /* COPY FUNCTIONS FOR NON-STANDARD SYSTEM TYPES */
 254 
 255 /*
 256  * STRING
 257  */
 258  pmix_status_t pmix20_bfrop_copy_string(char **dest, char *src, pmix_data_type_t type)
 259 {
 260     if (NULL == src) {  /* got zero-length string/NULL pointer - store NULL */
 261         *dest = NULL;
 262     } else {
 263         *dest = strdup(src);
 264     }
 265 
 266     return PMIX_SUCCESS;
 267 }
 268 /* compare function for pmix_value_t */
 269 bool pmix_value_cmp(pmix_value_t *p, pmix_value_t *p1)
 270 {
 271     bool rc = false;
 272 
 273     if (p->type != p1->type) {
 274         return rc;
 275     }
 276 
 277     switch (p->type) {
 278         case PMIX_UNDEF:
 279             rc = true;
 280             break;
 281         case PMIX_BOOL:
 282             rc = (p->data.flag == p1->data.flag);
 283             break;
 284         case PMIX_BYTE:
 285             rc = (p->data.byte == p1->data.byte);
 286             break;
 287         case PMIX_SIZE:
 288             rc = (p->data.size == p1->data.size);
 289             break;
 290         case PMIX_INT:
 291             rc = (p->data.integer == p1->data.integer);
 292             break;
 293         case PMIX_INT8:
 294             rc = (p->data.int8 == p1->data.int8);
 295             break;
 296         case PMIX_INT16:
 297             rc = (p->data.int16 == p1->data.int16);
 298             break;
 299         case PMIX_INT32:
 300             rc = (p->data.int32 == p1->data.int32);
 301             break;
 302         case PMIX_INT64:
 303             rc = (p->data.int64 == p1->data.int64);
 304             break;
 305         case PMIX_UINT:
 306             rc = (p->data.uint == p1->data.uint);
 307             break;
 308         case PMIX_UINT8:
 309             rc = (p->data.uint8 == p1->data.int8);
 310             break;
 311         case PMIX_UINT16:
 312             rc = (p->data.uint16 == p1->data.uint16);
 313             break;
 314         case PMIX_UINT32:
 315             rc = (p->data.uint32 == p1->data.uint32);
 316             break;
 317         case PMIX_UINT64:
 318             rc = (p->data.uint64 == p1->data.uint64);
 319             break;
 320         case PMIX_STRING:
 321             rc = strcmp(p->data.string, p1->data.string);
 322             break;
 323         case PMIX_COMPRESSED_STRING:
 324             if (p->data.bo.size != p1->data.bo.size) {
 325                 return false;
 326             } else {
 327                 return true;
 328             }
 329         case PMIX_STATUS:
 330             rc = (p->data.status == p1->data.status);
 331             break;
 332         default:
 333             pmix_output(0, "COMPARE-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)p->type);
 334     }
 335     return rc;
 336 }
 337 /* COPY FUNCTIONS FOR GENERIC PMIX TYPES - we
 338  * are not allocating memory and so we cannot
 339  * use the regular copy functions */
 340 pmix_status_t pmix20_bfrop_value_xfer(pmix_value_t *p, const pmix_value_t *src)
 341 {
 342     size_t n, m;
 343     pmix_status_t rc;
 344     char **prarray, **strarray;
 345     pmix_value_t *pv, *sv;
 346     pmix_info_t *p1, *s1;
 347     pmix_app_t *pa, *sa;
 348     pmix_pdata_t *pd, *sd;
 349     pmix_buffer_t *pb, *sb;
 350     pmix_byte_object_t *pbo, *sbo;
 351     pmix_kval_t *pk, *sk;
 352     pmix_modex_data_t *pm, *sm;
 353     pmix_proc_info_t *pi, *si;
 354     pmix_query_t *pq, *sq;
 355 
 356     /* copy the right field */
 357     p->type = src->type;
 358     switch (src->type) {
 359         case PMIX_UNDEF:
 360             break;
 361         case PMIX_BOOL:
 362             p->data.flag = src->data.flag;
 363             break;
 364         case PMIX_BYTE:
 365             p->data.byte = src->data.byte;
 366             break;
 367         case PMIX_STRING:
 368             if (NULL != src->data.string) {
 369                 p->data.string = strdup(src->data.string);
 370             } else {
 371                 p->data.string = NULL;
 372             }
 373             break;
 374         case PMIX_SIZE:
 375             p->data.size = src->data.size;
 376             break;
 377         case PMIX_PID:
 378             p->data.pid = src->data.pid;
 379             break;
 380         case PMIX_INT:
 381             /* to avoid alignment issues */
 382             memcpy(&p->data.integer, &src->data.integer, sizeof(int));
 383             break;
 384         case PMIX_INT8:
 385             p->data.int8 = src->data.int8;
 386             break;
 387         case PMIX_INT16:
 388             /* to avoid alignment issues */
 389             memcpy(&p->data.int16, &src->data.int16, 2);
 390             break;
 391         case PMIX_INT32:
 392             /* to avoid alignment issues */
 393             memcpy(&p->data.int32, &src->data.int32, 4);
 394             break;
 395         case PMIX_INT64:
 396             /* to avoid alignment issues */
 397             memcpy(&p->data.int64, &src->data.int64, 8);
 398             break;
 399         case PMIX_UINT:
 400             /* to avoid alignment issues */
 401             memcpy(&p->data.uint, &src->data.uint, sizeof(unsigned int));
 402             break;
 403         case PMIX_UINT8:
 404             p->data.uint8 = src->data.uint8;
 405             break;
 406         case PMIX_UINT16:
 407             /* to avoid alignment issues */
 408             memcpy(&p->data.uint16, &src->data.uint16, 2);
 409             break;
 410         case PMIX_UINT32:
 411             /* to avoid alignment issues */
 412             memcpy(&p->data.uint32, &src->data.uint32, 4);
 413             break;
 414         case PMIX_UINT64:
 415             /* to avoid alignment issues */
 416             memcpy(&p->data.uint64, &src->data.uint64, 8);
 417             break;
 418         case PMIX_FLOAT:
 419             p->data.fval = src->data.fval;
 420             break;
 421         case PMIX_DOUBLE:
 422             p->data.dval = src->data.dval;
 423             break;
 424         case PMIX_TIMEVAL:
 425             memcpy(&p->data.tv, &src->data.tv, sizeof(struct timeval));
 426             break;
 427         case PMIX_TIME:
 428             memcpy(&p->data.time, &src->data.time, sizeof(time_t));
 429             break;
 430         case PMIX_STATUS:
 431             memcpy(&p->data.status, &src->data.status, sizeof(pmix_status_t));
 432             break;
 433         case PMIX_PROC:
 434             memcpy(&p->data.proc, &src->data.proc, sizeof(pmix_proc_t));
 435             break;
 436         case PMIX_PROC_RANK:
 437             memcpy(&p->data.proc, &src->data.rank, sizeof(pmix_rank_t));
 438             break;
 439         case PMIX_BYTE_OBJECT:
 440         case PMIX_COMPRESSED_STRING:
 441             memset(&p->data.bo, 0, sizeof(pmix_byte_object_t));
 442             if (NULL != src->data.bo.bytes && 0 < src->data.bo.size) {
 443                 p->data.bo.bytes = malloc(src->data.bo.size);
 444                 memcpy(p->data.bo.bytes, src->data.bo.bytes, src->data.bo.size);
 445                 p->data.bo.size = src->data.bo.size;
 446             } else {
 447                 p->data.bo.bytes = NULL;
 448                 p->data.bo.size = 0;
 449             }
 450             break;
 451         case PMIX_PERSIST:
 452             memcpy(&p->data.persist, &src->data.persist, sizeof(pmix_persistence_t));
 453             break;
 454         case PMIX_SCOPE:
 455             memcpy(&p->data.scope, &src->data.scope, sizeof(pmix_scope_t));
 456             break;
 457         case PMIX_DATA_RANGE:
 458             memcpy(&p->data.range, &src->data.range, sizeof(pmix_data_range_t));
 459             break;
 460         case PMIX_PROC_STATE:
 461             memcpy(&p->data.state, &src->data.state, sizeof(pmix_proc_state_t));
 462             break;
 463         case PMIX_PROC_INFO:
 464             PMIX_PROC_INFO_CREATE(p->data.pinfo, 1);
 465             if (NULL != src->data.pinfo->hostname) {
 466                 p->data.pinfo->hostname = strdup(src->data.pinfo->hostname);
 467             }
 468             if (NULL != src->data.pinfo->executable_name) {
 469                 p->data.pinfo->executable_name = strdup(src->data.pinfo->executable_name);
 470             }
 471             memcpy(&p->data.pinfo->pid, &src->data.pinfo->pid, sizeof(pid_t));
 472             memcpy(&p->data.pinfo->exit_code, &src->data.pinfo->exit_code, sizeof(int));
 473             memcpy(&p->data.pinfo->state, &src->data.pinfo->state, sizeof(pmix_proc_state_t));
 474             break;
 475         case PMIX_DATA_ARRAY:
 476             p->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
 477             p->data.darray->type = src->data.darray->type;
 478             p->data.darray->size = src->data.darray->size;
 479             if (0 == p->data.darray->size || NULL == src->data.darray->array) {
 480                 p->data.darray->array = NULL;
 481                 p->data.darray->size = 0;
 482                 break;
 483             }
 484             /* allocate space and do the copy */
 485             switch (src->data.darray->type) {
 486                 case PMIX_UINT8:
 487                 case PMIX_INT8:
 488                 case PMIX_BYTE:
 489                     p->data.darray->array = (char*)malloc(src->data.darray->size);
 490                     if (NULL == p->data.darray->array) {
 491                         return PMIX_ERR_NOMEM;
 492                     }
 493                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size);
 494                     break;
 495                 case PMIX_UINT16:
 496                 case PMIX_INT16:
 497                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint16_t));
 498                     if (NULL == p->data.darray->array) {
 499                         return PMIX_ERR_NOMEM;
 500                     }
 501                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint16_t));
 502                     break;
 503                 case PMIX_UINT32:
 504                 case PMIX_INT32:
 505                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint32_t));
 506                     if (NULL == p->data.darray->array) {
 507                         return PMIX_ERR_NOMEM;
 508                     }
 509                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint32_t));
 510                     break;
 511                 case PMIX_UINT64:
 512                 case PMIX_INT64:
 513                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(uint64_t));
 514                     if (NULL == p->data.darray->array) {
 515                         return PMIX_ERR_NOMEM;
 516                     }
 517                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(uint64_t));
 518                     break;
 519                 case PMIX_BOOL:
 520                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(bool));
 521                     if (NULL == p->data.darray->array) {
 522                         return PMIX_ERR_NOMEM;
 523                     }
 524                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(bool));
 525                     break;
 526                 case PMIX_SIZE:
 527                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(size_t));
 528                     if (NULL == p->data.darray->array) {
 529                         return PMIX_ERR_NOMEM;
 530                     }
 531                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(size_t));
 532                     break;
 533                 case PMIX_PID:
 534                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(pid_t));
 535                     if (NULL == p->data.darray->array) {
 536                         return PMIX_ERR_NOMEM;
 537                     }
 538                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pid_t));
 539                     break;
 540                 case PMIX_STRING:
 541                     p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
 542                     if (NULL == p->data.darray->array) {
 543                         return PMIX_ERR_NOMEM;
 544                     }
 545                     prarray = (char**)p->data.darray->array;
 546                     strarray = (char**)src->data.darray->array;
 547                     for (n=0; n < src->data.darray->size; n++) {
 548                         if (NULL != strarray[n]) {
 549                             prarray[n] = strdup(strarray[n]);
 550                         }
 551                     }
 552                     break;
 553                 case PMIX_INT:
 554                 case PMIX_UINT:
 555                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(int));
 556                     if (NULL == p->data.darray->array) {
 557                         return PMIX_ERR_NOMEM;
 558                     }
 559                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(int));
 560                     break;
 561                 case PMIX_FLOAT:
 562                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(float));
 563                     if (NULL == p->data.darray->array) {
 564                         return PMIX_ERR_NOMEM;
 565                     }
 566                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(float));
 567                     break;
 568                 case PMIX_DOUBLE:
 569                     p->data.darray->array = (char*)malloc(src->data.darray->size * sizeof(double));
 570                     if (NULL == p->data.darray->array) {
 571                         return PMIX_ERR_NOMEM;
 572                     }
 573                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(double));
 574                     break;
 575                 case PMIX_TIMEVAL:
 576                     p->data.darray->array = (struct timeval*)malloc(src->data.darray->size * sizeof(struct timeval));
 577                     if (NULL == p->data.darray->array) {
 578                         return PMIX_ERR_NOMEM;
 579                     }
 580                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(struct timeval));
 581                     break;
 582                 case PMIX_TIME:
 583                     p->data.darray->array = (time_t*)malloc(src->data.darray->size * sizeof(time_t));
 584                     if (NULL == p->data.darray->array) {
 585                         return PMIX_ERR_NOMEM;
 586                     }
 587                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(time_t));
 588                     break;
 589                 case PMIX_STATUS:
 590                     p->data.darray->array = (pmix_status_t*)malloc(src->data.darray->size * sizeof(pmix_status_t));
 591                     if (NULL == p->data.darray->array) {
 592                         return PMIX_ERR_NOMEM;
 593                     }
 594                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_status_t));
 595                     break;
 596                 case PMIX_VALUE:
 597                     PMIX_VALUE_CREATE(p->data.darray->array, src->data.darray->size);
 598                     if (NULL == p->data.darray->array) {
 599                         return PMIX_ERR_NOMEM;
 600                     }
 601                     pv = (pmix_value_t*)p->data.darray->array;
 602                     sv = (pmix_value_t*)src->data.darray->array;
 603                     for (n=0; n < src->data.darray->size; n++) {
 604                         if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(&pv[n], &sv[n]))) {
 605                             PMIX_VALUE_FREE(pv, src->data.darray->size);
 606                             return rc;
 607                         }
 608                     }
 609                     break;
 610                 case PMIX_PROC:
 611                     PMIX_PROC_CREATE(p->data.darray->array, src->data.darray->size);
 612                     if (NULL == p->data.darray->array) {
 613                         return PMIX_ERR_NOMEM;
 614                     }
 615                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_proc_t));
 616                     break;
 617                 case PMIX_APP:
 618                     PMIX_APP_CREATE(p->data.darray->array, src->data.darray->size);
 619                     if (NULL == p->data.darray->array) {
 620                         return PMIX_ERR_NOMEM;
 621                     }
 622                     pa = (pmix_app_t*)p->data.darray->array;
 623                     sa = (pmix_app_t*)src->data.darray->array;
 624                     for (n=0; n < src->data.darray->size; n++) {
 625                         if (NULL != sa[n].cmd) {
 626                             pa[n].cmd = strdup(sa[n].cmd);
 627                         }
 628                         if (NULL != sa[n].argv) {
 629                             pa[n].argv = pmix_argv_copy(sa[n].argv);
 630                         }
 631                         if (NULL != sa[n].env) {
 632                             pa[n].env = pmix_argv_copy(sa[n].env);
 633                         }
 634                         if (NULL != sa[n].cwd) {
 635                             pa[n].cwd = strdup(sa[n].cwd);
 636                         }
 637                         pa[n].maxprocs = sa[n].maxprocs;
 638                         if (0 < sa[n].ninfo && NULL != sa[n].info) {
 639                             PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
 640                             if (NULL == pa[n].info) {
 641                                 PMIX_APP_FREE(pa, src->data.darray->size);
 642                                 return PMIX_ERR_NOMEM;
 643                             }
 644                             pa[n].ninfo = sa[n].ninfo;
 645                             for (m=0; m < pa[n].ninfo; m++) {
 646                                 PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
 647                             }
 648                         }
 649                     }
 650                     break;
 651                 case PMIX_INFO:
 652                     PMIX_INFO_CREATE(p->data.darray->array, src->data.darray->size);
 653                     p1 = (pmix_info_t*)p->data.darray->array;
 654                     s1 = (pmix_info_t*)src->data.darray->array;
 655                     for (n=0; n < src->data.darray->size; n++) {
 656                         PMIX_INFO_LOAD(&p1[n], s1[n].key, &s1[n].value.data.flag, s1[n].value.type);
 657                     }
 658                     break;
 659                 case PMIX_PDATA:
 660                     PMIX_PDATA_CREATE(p->data.darray->array, src->data.darray->size);
 661                     if (NULL == p->data.darray->array) {
 662                         return PMIX_ERR_NOMEM;
 663                     }
 664                     pd = (pmix_pdata_t*)p->data.darray->array;
 665                     sd = (pmix_pdata_t*)src->data.darray->array;
 666                     for (n=0; n < src->data.darray->size; n++) {
 667                         PMIX_PDATA_LOAD(&pd[n], &sd[n].proc, sd[n].key, &sd[n].value.data.flag, sd[n].value.type);
 668                     }
 669                     break;
 670                 case PMIX_BUFFER:
 671                     p->data.darray->array = (pmix_buffer_t*)malloc(src->data.darray->size * sizeof(pmix_buffer_t));
 672                     if (NULL == p->data.darray->array) {
 673                         return PMIX_ERR_NOMEM;
 674                     }
 675                     pb = (pmix_buffer_t*)p->data.darray->array;
 676                     sb = (pmix_buffer_t*)src->data.darray->array;
 677                     for (n=0; n < src->data.darray->size; n++) {
 678                         PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
 679                         pmix20_bfrop_copy_payload(&pb[n], &sb[n]);
 680                     }
 681                     break;
 682                 case PMIX_BYTE_OBJECT:
 683                 case PMIX_COMPRESSED_STRING:
 684                     p->data.darray->array = (pmix_byte_object_t*)malloc(src->data.darray->size * sizeof(pmix_byte_object_t));
 685                     if (NULL == p->data.darray->array) {
 686                         return PMIX_ERR_NOMEM;
 687                     }
 688                     pbo = (pmix_byte_object_t*)p->data.darray->array;
 689                     sbo = (pmix_byte_object_t*)src->data.darray->array;
 690                     for (n=0; n < src->data.darray->size; n++) {
 691                         if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
 692                             pbo[n].size = sbo[n].size;
 693                             pbo[n].bytes = (char*)malloc(pbo[n].size);
 694                             memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
 695                         } else {
 696                             pbo[n].bytes = NULL;
 697                             pbo[n].size = 0;
 698                         }
 699                     }
 700                     break;
 701                 case PMIX_KVAL:
 702                     p->data.darray->array = (pmix_kval_t*)calloc(src->data.darray->size , sizeof(pmix_kval_t));
 703                     if (NULL == p->data.darray->array) {
 704                         return PMIX_ERR_NOMEM;
 705                     }
 706                     pk = (pmix_kval_t*)p->data.darray->array;
 707                     sk = (pmix_kval_t*)src->data.darray->array;
 708                     for (n=0; n < src->data.darray->size; n++) {
 709                         if (NULL != sk[n].key) {
 710                             pk[n].key = strdup(sk[n].key);
 711                         }
 712                         if (NULL != sk[n].value) {
 713                             PMIX_VALUE_CREATE(pk[n].value, 1);
 714                             if (NULL == pk[n].value) {
 715                                 free(p->data.darray->array);
 716                                 return PMIX_ERR_NOMEM;
 717                             }
 718                             if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(pk[n].value, sk[n].value))) {
 719                                 return rc;
 720                             }
 721                         }
 722                     }
 723                     break;
 724                 case PMIX_MODEX:
 725                     PMIX_MODEX_CREATE(p->data.darray->array, src->data.darray->size);
 726                     if (NULL == p->data.darray->array) {
 727                         return PMIX_ERR_NOMEM;
 728                     }
 729                     pm = (pmix_modex_data_t*)p->data.darray->array;
 730                     sm = (pmix_modex_data_t*)src->data.darray->array;
 731                     for (n=0; n < src->data.darray->size; n++) {
 732                         memcpy(&pm[n], &sm[n], sizeof(pmix_modex_data_t));
 733                         if (NULL != sm[n].blob && 0 < sm[n].size) {
 734                             pm[n].blob = (uint8_t*)malloc(sm[n].size);
 735                             if (NULL == pm[n].blob) {
 736                                 return PMIX_ERR_NOMEM;
 737                             }
 738                             memcpy(pm[n].blob, sm[n].blob, sm[n].size);
 739                             pm[n].size = sm[n].size;
 740                         } else {
 741                             pm[n].blob = NULL;
 742                             pm[n].size = 0;
 743                         }
 744                     }
 745                     break;
 746                 case PMIX_PERSIST:
 747                     p->data.darray->array = (pmix_persistence_t*)malloc(src->data.darray->size * sizeof(pmix_persistence_t));
 748                     if (NULL == p->data.darray->array) {
 749                         return PMIX_ERR_NOMEM;
 750                     }
 751                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_persistence_t));
 752                     break;
 753                 case PMIX_POINTER:
 754                     p->data.darray->array = (char**)malloc(src->data.darray->size * sizeof(char*));
 755                     if (NULL == p->data.darray->array) {
 756                         return PMIX_ERR_NOMEM;
 757                     }
 758                     prarray = (char**)p->data.darray->array;
 759                     strarray = (char**)src->data.darray->array;
 760                     for (n=0; n < src->data.darray->size; n++) {
 761                         prarray[n] = strarray[n];
 762                     }
 763                     break;
 764                 case PMIX_SCOPE:
 765                     p->data.darray->array = (pmix_scope_t*)malloc(src->data.darray->size * sizeof(pmix_scope_t));
 766                     if (NULL == p->data.darray->array) {
 767                         return PMIX_ERR_NOMEM;
 768                     }
 769                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_scope_t));
 770                     break;
 771                 case PMIX_DATA_RANGE:
 772                     p->data.darray->array = (pmix_data_range_t*)malloc(src->data.darray->size * sizeof(pmix_data_range_t));
 773                     if (NULL == p->data.darray->array) {
 774                         return PMIX_ERR_NOMEM;
 775                     }
 776                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_data_range_t));
 777                     break;
 778                 case PMIX_COMMAND:
 779                     p->data.darray->array = (pmix_cmd_t*)malloc(src->data.darray->size * sizeof(pmix_cmd_t));
 780                     if (NULL == p->data.darray->array) {
 781                         return PMIX_ERR_NOMEM;
 782                     }
 783                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_cmd_t));
 784                     break;
 785                 case PMIX_INFO_DIRECTIVES:
 786                     p->data.darray->array = (pmix_info_directives_t*)malloc(src->data.darray->size * sizeof(pmix_info_directives_t));
 787                     if (NULL == p->data.darray->array) {
 788                         return PMIX_ERR_NOMEM;
 789                     }
 790                     memcpy(p->data.darray->array, src->data.darray->array, src->data.darray->size * sizeof(pmix_info_directives_t));
 791                     break;
 792                 case PMIX_PROC_INFO:
 793                     PMIX_PROC_INFO_CREATE(p->data.darray->array, src->data.darray->size);
 794                     if (NULL == p->data.darray->array) {
 795                         return PMIX_ERR_NOMEM;
 796                     }
 797                     pi = (pmix_proc_info_t*)p->data.darray->array;
 798                     si = (pmix_proc_info_t*)src->data.darray->array;
 799                     for (n=0; n < src->data.darray->size; n++) {
 800                         memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
 801                         if (NULL != si[n].hostname) {
 802                             pi[n].hostname = strdup(si[n].hostname);
 803                         } else {
 804                             pi[n].hostname = NULL;
 805                         }
 806                         if (NULL != si[n].executable_name) {
 807                             pi[n].executable_name = strdup(si[n].executable_name);
 808                         } else {
 809                             pi[n].executable_name = NULL;
 810                         }
 811                         pi[n].pid = si[n].pid;
 812                         pi[n].exit_code = si[n].exit_code;
 813                         pi[n].state = si[n].state;
 814                     }
 815                     break;
 816                 case PMIX_DATA_ARRAY:
 817                     return PMIX_ERR_NOT_SUPPORTED;  // don't support iterative arrays
 818                 case PMIX_QUERY:
 819                     PMIX_QUERY_CREATE(p->data.darray->array, src->data.darray->size);
 820                     if (NULL == p->data.darray->array) {
 821                         return PMIX_ERR_NOMEM;
 822                     }
 823                     pq = (pmix_query_t*)p->data.darray->array;
 824                     sq = (pmix_query_t*)src->data.darray->array;
 825                     for (n=0; n < src->data.darray->size; n++) {
 826                         if (NULL != sq[n].keys) {
 827                             pq[n].keys = pmix_argv_copy(sq[n].keys);
 828                         }
 829                         if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
 830                             PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
 831                             if (NULL == pq[n].qualifiers) {
 832                                 PMIX_QUERY_FREE(pq, src->data.darray->size);
 833                                 return PMIX_ERR_NOMEM;
 834                             }
 835                             for (m=0; m < sq[n].nqual; m++) {
 836                                 PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
 837                             }
 838                             pq[n].nqual = sq[n].nqual;
 839                         } else {
 840                             pq[n].qualifiers = NULL;
 841                             pq[n].nqual = 0;
 842                         }
 843                     }
 844                     break;
 845                 default:
 846                     return PMIX_ERR_UNKNOWN_DATA_TYPE;
 847             }
 848             break;
 849         case PMIX_POINTER:
 850             memcpy(&p->data.ptr, &src->data.ptr, sizeof(void*));
 851             break;
 852         /**** DEPRECATED ****/
 853         case PMIX_INFO_ARRAY:
 854             return PMIX_ERR_NOT_SUPPORTED;
 855         /********************/
 856         default:
 857             pmix_output(0, "COPY-PMIX-VALUE: UNSUPPORTED TYPE %d", (int)src->type);
 858             return PMIX_ERROR;
 859     }
 860     return PMIX_SUCCESS;
 861 }
 862 
 863 /* PMIX_VALUE */
 864 pmix_status_t pmix20_bfrop_copy_value(pmix_value_t **dest, pmix_value_t *src,
 865                                     pmix_data_type_t type)
 866 {
 867     pmix_value_t *p;
 868 
 869     /* create the new object */
 870     *dest = (pmix_value_t*)malloc(sizeof(pmix_value_t));
 871     if (NULL == *dest) {
 872         return PMIX_ERR_OUT_OF_RESOURCE;
 873     }
 874     p = *dest;
 875 
 876     /* copy the type */
 877     p->type = src->type;
 878     /* copy the data */
 879     return pmix20_bfrop_value_xfer(p, src);
 880 }
 881 
 882 pmix_status_t pmix20_bfrop_copy_info(pmix_info_t **dest, pmix_info_t *src,
 883                                    pmix_data_type_t type)
 884 {
 885     *dest = (pmix_info_t*)malloc(sizeof(pmix_info_t));
 886     pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
 887     (*dest)->flags = src->flags;
 888     return pmix20_bfrop_value_xfer(&(*dest)->value, &src->value);
 889 }
 890 
 891 pmix_status_t pmix20_bfrop_copy_buf(pmix_buffer_t **dest, pmix_buffer_t *src,
 892                                   pmix_data_type_t type)
 893 {
 894     *dest = PMIX_NEW(pmix_buffer_t);
 895     pmix20_bfrop_copy_payload(*dest, src);
 896     return PMIX_SUCCESS;
 897 }
 898 
 899 pmix_status_t pmix20_bfrop_copy_app(pmix_app_t **dest, pmix_app_t *src,
 900                                   pmix_data_type_t type)
 901 {
 902     size_t j;
 903 
 904     *dest = (pmix_app_t*)malloc(sizeof(pmix_app_t));
 905     (*dest)->cmd = strdup(src->cmd);
 906     (*dest)->argv = pmix_argv_copy(src->argv);
 907     (*dest)->env = pmix_argv_copy(src->env);
 908     if (NULL != src->cwd) {
 909         (*dest)->cwd = strdup(src->cwd);
 910     }
 911     (*dest)->maxprocs = src->maxprocs;
 912     (*dest)->ninfo = src->ninfo;
 913     (*dest)->info = (pmix_info_t*)malloc(src->ninfo * sizeof(pmix_info_t));
 914     for (j=0; j < src->ninfo; j++) {
 915         pmix_strncpy((*dest)->info[j].key, src->info[j].key, PMIX_MAX_KEYLEN);
 916         pmix20_bfrop_value_xfer(&(*dest)->info[j].value, &src->info[j].value);
 917     }
 918     return PMIX_SUCCESS;
 919 }
 920 
 921 pmix_status_t pmix20_bfrop_copy_kval(pmix_kval_t **dest, pmix_kval_t *src,
 922                                    pmix_data_type_t type)
 923 {
 924     pmix_kval_t *p;
 925 
 926     /* create the new object */
 927     *dest = PMIX_NEW(pmix_kval_t);
 928     if (NULL == *dest) {
 929         return PMIX_ERR_OUT_OF_RESOURCE;
 930     }
 931     p = *dest;
 932 
 933     /* copy the type */
 934     p->value->type = src->value->type;
 935     /* copy the data */
 936     return pmix20_bfrop_value_xfer(p->value, src->value);
 937 }
 938 
 939 pmix_status_t pmix20_bfrop_copy_proc(pmix_proc_t **dest, pmix_proc_t *src,
 940                                    pmix_data_type_t type)
 941 {
 942     *dest = (pmix_proc_t*)malloc(sizeof(pmix_proc_t));
 943     if (NULL == *dest) {
 944         return PMIX_ERR_OUT_OF_RESOURCE;
 945     }
 946     pmix_strncpy((*dest)->nspace, src->nspace, PMIX_MAX_NSLEN);
 947     (*dest)->rank = src->rank;
 948     return PMIX_SUCCESS;
 949 }
 950 
 951 pmix_status_t pmix20_bfrop_copy_modex(pmix_modex_data_t **dest, pmix_modex_data_t *src,
 952                                     pmix_data_type_t type)
 953 {
 954     *dest = (pmix_modex_data_t*)malloc(sizeof(pmix_modex_data_t));
 955     if (NULL == *dest) {
 956         return PMIX_ERR_OUT_OF_RESOURCE;
 957     }
 958     (*dest)->blob = NULL;
 959     (*dest)->size = 0;
 960     if (NULL != src->blob) {
 961         (*dest)->blob = (uint8_t*)malloc(src->size * sizeof(uint8_t));
 962         if (NULL == (*dest)->blob) {
 963             return PMIX_ERR_OUT_OF_RESOURCE;
 964         }
 965         memcpy((*dest)->blob, src->blob, src->size * sizeof(uint8_t));
 966         (*dest)->size = src->size;
 967     }
 968     return PMIX_SUCCESS;
 969 }
 970 
 971 pmix_status_t pmix20_bfrop_copy_persist(pmix_persistence_t **dest, pmix_persistence_t *src,
 972                                       pmix_data_type_t type)
 973 {
 974     *dest = (pmix_persistence_t*)malloc(sizeof(pmix_persistence_t));
 975     if (NULL == *dest) {
 976         return PMIX_ERR_OUT_OF_RESOURCE;
 977     }
 978     memcpy(*dest, src, sizeof(pmix_persistence_t));
 979     return PMIX_SUCCESS;
 980 }
 981 
 982 pmix_status_t pmix20_bfrop_copy_bo(pmix_byte_object_t **dest, pmix_byte_object_t *src,
 983                                  pmix_data_type_t type)
 984 {
 985     *dest = (pmix_byte_object_t*)malloc(sizeof(pmix_byte_object_t));
 986     if (NULL == *dest) {
 987         return PMIX_ERR_OUT_OF_RESOURCE;
 988     }
 989     (*dest)->bytes = (char*)malloc(src->size);
 990     memcpy((*dest)->bytes, src->bytes, src->size);
 991     (*dest)->size = src->size;
 992     return PMIX_SUCCESS;
 993 }
 994 
 995 pmix_status_t pmix20_bfrop_copy_pdata(pmix_pdata_t **dest, pmix_pdata_t *src,
 996                                     pmix_data_type_t type)
 997 {
 998     *dest = (pmix_pdata_t*)malloc(sizeof(pmix_pdata_t));
 999     pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
1000     (*dest)->proc.rank = src->proc.rank;
1001     pmix_strncpy((*dest)->key, src->key, PMIX_MAX_KEYLEN);
1002     return pmix20_bfrop_value_xfer(&(*dest)->value, &src->value);
1003 }
1004 
1005 pmix_status_t pmix20_bfrop_copy_pinfo(pmix_proc_info_t **dest, pmix_proc_info_t *src,
1006                                     pmix_data_type_t type)
1007 {
1008     *dest = (pmix_proc_info_t*)malloc(sizeof(pmix_proc_info_t));
1009     pmix_strncpy((*dest)->proc.nspace, src->proc.nspace, PMIX_MAX_NSLEN);
1010     (*dest)->proc.rank = src->proc.rank;
1011     if (NULL != src->hostname) {
1012         (*dest)->hostname = strdup(src->hostname);
1013     }
1014     if (NULL != src->executable_name) {
1015         (*dest)->executable_name = strdup(src->executable_name);
1016     }
1017     (*dest)->pid = src->pid;
1018     (*dest)->exit_code = src->exit_code;
1019     (*dest)->state = src->state;
1020     return PMIX_SUCCESS;
1021 }
1022 
1023 /* the pmix_data_array_t is a little different in that it
1024  * is an array of values, and so we cannot just copy one
1025  * value at a time. So handle all value types here */
1026 pmix_status_t pmix20_bfrop_copy_darray(pmix_data_array_t **dest,
1027                                      pmix_data_array_t *src,
1028                                      pmix_data_type_t type)
1029 {
1030     pmix_data_array_t *p;
1031     size_t n, m;
1032     pmix_status_t rc;
1033     char **prarray, **strarray;
1034     pmix_value_t *pv, *sv;
1035     pmix_app_t *pa, *sa;
1036     pmix_info_t *p1, *s1;
1037     pmix_pdata_t *pd, *sd;
1038     pmix_buffer_t *pb, *sb;
1039     pmix_byte_object_t *pbo, *sbo;
1040     pmix_kval_t *pk, *sk;
1041     pmix_modex_data_t *pm, *sm;
1042     pmix_proc_info_t *pi, *si;
1043     pmix_query_t *pq, *sq;
1044 
1045     p = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
1046     if (NULL == p) {
1047         return PMIX_ERR_NOMEM;
1048     }
1049     p->type = src->type;
1050     p->size = src->size;
1051     if (0 == p->size || NULL == src->array) {
1052         *dest = p;
1053         return PMIX_SUCCESS;
1054     }
1055 
1056     /* process based on type of array element */
1057     switch (src->type) {
1058         case PMIX_UINT8:
1059         case PMIX_INT8:
1060         case PMIX_BYTE:
1061             p->array = (char*)malloc(src->size);
1062             if (NULL == p->array) {
1063                 free(p);
1064                 return PMIX_ERR_NOMEM;
1065             }
1066             memcpy(p->array, src->array, src->size);
1067             break;
1068         case PMIX_UINT16:
1069         case PMIX_INT16:
1070             p->array = (char*)malloc(src->size * sizeof(uint16_t));
1071             if (NULL == p->array) {
1072                 free(p);
1073                 return PMIX_ERR_NOMEM;
1074             }
1075             memcpy(p->array, src->array, src->size * sizeof(uint16_t));
1076             break;
1077         case PMIX_UINT32:
1078         case PMIX_INT32:
1079             p->array = (char*)malloc(src->size * sizeof(uint32_t));
1080             if (NULL == p->array) {
1081                 free(p);
1082                 return PMIX_ERR_NOMEM;
1083             }
1084             memcpy(p->array, src->array, src->size * sizeof(uint32_t));
1085             break;
1086         case PMIX_UINT64:
1087         case PMIX_INT64:
1088             p->array = (char*)malloc(src->size * sizeof(uint64_t));
1089             if (NULL == p->array) {
1090                 free(p);
1091                 return PMIX_ERR_NOMEM;
1092             }
1093             memcpy(p->array, src->array, src->size * sizeof(uint64_t));
1094             break;
1095         case PMIX_BOOL:
1096             p->array = (char*)malloc(src->size * sizeof(bool));
1097             if (NULL == p->array) {
1098                 free(p);
1099                 return PMIX_ERR_NOMEM;
1100             }
1101             memcpy(p->array, src->array, src->size * sizeof(bool));
1102             break;
1103         case PMIX_SIZE:
1104             p->array = (char*)malloc(src->size * sizeof(size_t));
1105             if (NULL == p->array) {
1106                 free(p);
1107                 return PMIX_ERR_NOMEM;
1108             }
1109             memcpy(p->array, src->array, src->size * sizeof(size_t));
1110             break;
1111         case PMIX_PID:
1112             p->array = (char*)malloc(src->size * sizeof(pid_t));
1113             if (NULL == p->array) {
1114                 free(p);
1115                 return PMIX_ERR_NOMEM;
1116             }
1117             memcpy(p->array, src->array, src->size * sizeof(pid_t));
1118             break;
1119         case PMIX_STRING:
1120             p->array = (char**)malloc(src->size * sizeof(char*));
1121             if (NULL == p->array) {
1122                 free(p);
1123                 return PMIX_ERR_NOMEM;
1124             }
1125             prarray = (char**)p->array;
1126             strarray = (char**)src->array;
1127             for (n=0; n < src->size; n++) {
1128                 if (NULL != strarray[n]) {
1129                     prarray[n] = strdup(strarray[n]);
1130                 }
1131             }
1132             break;
1133         case PMIX_INT:
1134         case PMIX_UINT:
1135             p->array = (char*)malloc(src->size * sizeof(int));
1136             if (NULL == p->array) {
1137                 free(p);
1138                 return PMIX_ERR_NOMEM;
1139             }
1140             memcpy(p->array, src->array, src->size * sizeof(int));
1141             break;
1142         case PMIX_FLOAT:
1143             p->array = (char*)malloc(src->size * sizeof(float));
1144             if (NULL == p->array) {
1145                 free(p);
1146                 return PMIX_ERR_NOMEM;
1147             }
1148             memcpy(p->array, src->array, src->size * sizeof(float));
1149             break;
1150         case PMIX_DOUBLE:
1151             p->array = (char*)malloc(src->size * sizeof(double));
1152             if (NULL == p->array) {
1153                 free(p);
1154                 return PMIX_ERR_NOMEM;
1155             }
1156             memcpy(p->array, src->array, src->size * sizeof(double));
1157             break;
1158         case PMIX_TIMEVAL:
1159             p->array = (struct timeval*)malloc(src->size * sizeof(struct timeval));
1160             if (NULL == p->array) {
1161                 free(p);
1162                 return PMIX_ERR_NOMEM;
1163             }
1164             memcpy(p->array, src->array, src->size * sizeof(struct timeval));
1165             break;
1166         case PMIX_TIME:
1167             p->array = (time_t*)malloc(src->size * sizeof(time_t));
1168             if (NULL == p->array) {
1169                 free(p);
1170                 return PMIX_ERR_NOMEM;
1171             }
1172             memcpy(p->array, src->array, src->size * sizeof(time_t));
1173             break;
1174         case PMIX_STATUS:
1175             p->array = (pmix_status_t*)malloc(src->size * sizeof(pmix_status_t));
1176             if (NULL == p->array) {
1177                 free(p);
1178                 return PMIX_ERR_NOMEM;
1179             }
1180             memcpy(p->array, src->array, src->size * sizeof(pmix_status_t));
1181             break;
1182         case PMIX_VALUE:
1183             PMIX_VALUE_CREATE(p->array, src->size);
1184             if (NULL == p->array) {
1185                 free(p);
1186                 return PMIX_ERR_NOMEM;
1187             }
1188             pv = (pmix_value_t*)p->array;
1189             sv = (pmix_value_t*)src->array;
1190             for (n=0; n < src->size; n++) {
1191                 if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(&pv[n], &sv[n]))) {
1192                     PMIX_VALUE_FREE(pv, src->size);
1193                     free(p);
1194                     return rc;
1195                 }
1196             }
1197             break;
1198         case PMIX_PROC:
1199             PMIX_PROC_CREATE(p->array, src->size);
1200             if (NULL == p->array) {
1201                 free(p);
1202                 return PMIX_ERR_NOMEM;
1203             }
1204             memcpy(p->array, src->array, src->size * sizeof(pmix_proc_t));
1205             break;
1206         case PMIX_PROC_RANK:
1207             p->array = (char*)malloc(src->size * sizeof(pmix_rank_t));
1208             if (NULL == p->array) {
1209                 free(p);
1210                 return PMIX_ERR_NOMEM;
1211             }
1212             memcpy(p->array, src->array, src->size * sizeof(pmix_proc_t));
1213             break;
1214         case PMIX_APP:
1215             PMIX_APP_CREATE(p->array, src->size);
1216             if (NULL == p->array) {
1217                 free(p);
1218                 return PMIX_ERR_NOMEM;
1219             }
1220             pa = (pmix_app_t*)p->array;
1221             sa = (pmix_app_t*)src->array;
1222             for (n=0; n < src->size; n++) {
1223                 if (NULL != sa[n].cmd) {
1224                     pa[n].cmd = strdup(sa[n].cmd);
1225                 }
1226                 if (NULL != sa[n].argv) {
1227                     pa[n].argv = pmix_argv_copy(sa[n].argv);
1228                 }
1229                 if (NULL != sa[n].env) {
1230                     pa[n].env = pmix_argv_copy(sa[n].env);
1231                 }
1232                 if (NULL != sa[n].cwd) {
1233                     pa[n].cwd = strdup(sa[n].cwd);
1234                 }
1235                 pa[n].maxprocs = sa[n].maxprocs;
1236                 if (0 < sa[n].ninfo && NULL != sa[n].info) {
1237                     PMIX_INFO_CREATE(pa[n].info, sa[n].ninfo);
1238                     if (NULL == pa[n].info) {
1239                         PMIX_APP_FREE(pa, p->size);
1240                         free(p);
1241                         return PMIX_ERR_NOMEM;
1242                     }
1243                     pa[n].ninfo = sa[n].ninfo;
1244                     for (m=0; m < pa[n].ninfo; m++) {
1245                         PMIX_INFO_XFER(&pa[n].info[m], &sa[n].info[m]);
1246                     }
1247                 }
1248             }
1249             break;
1250         case PMIX_INFO:
1251             PMIX_INFO_CREATE(p->array, src->size);
1252             if (NULL == p->array) {
1253                 free(p);
1254                 return PMIX_ERR_NOMEM;
1255             }
1256             p1 = (pmix_info_t*)p->array;
1257             s1 = (pmix_info_t*)src->array;
1258             for (n=0; n < src->size; n++) {
1259                 PMIX_INFO_LOAD(&p1[n], s1[n].key, &s1[n].value.data.flag, s1[n].value.type);
1260             }
1261             break;
1262         case PMIX_PDATA:
1263             PMIX_PDATA_CREATE(p->array, src->size);
1264             if (NULL == p->array) {
1265                 free(p);
1266                 return PMIX_ERR_NOMEM;
1267             }
1268             pd = (pmix_pdata_t*)p->array;
1269             sd = (pmix_pdata_t*)src->array;
1270             for (n=0; n < src->size; n++) {
1271                 PMIX_PDATA_LOAD(&pd[n], &sd[n].proc, sd[n].key, &sd[n].value.data, sd[n].value.type);
1272             }
1273             break;
1274         case PMIX_BUFFER:
1275             p->array = (pmix_buffer_t*)malloc(src->size * sizeof(pmix_buffer_t));
1276             if (NULL == p->array) {
1277                 free(p);
1278                 return PMIX_ERR_NOMEM;
1279             }
1280             pb = (pmix_buffer_t*)p->array;
1281             sb = (pmix_buffer_t*)src->array;
1282             for (n=0; n < src->size; n++) {
1283                 PMIX_CONSTRUCT(&pb[n], pmix_buffer_t);
1284                 pmix20_bfrop_copy_payload(&pb[n], &sb[n]);
1285             }
1286             break;
1287         case PMIX_BYTE_OBJECT:
1288         case PMIX_COMPRESSED_STRING:
1289             p->array = (pmix_byte_object_t*)malloc(src->size * sizeof(pmix_byte_object_t));
1290             if (NULL == p->array) {
1291                 free(p);
1292                 return PMIX_ERR_NOMEM;
1293             }
1294             pbo = (pmix_byte_object_t*)p->array;
1295             sbo = (pmix_byte_object_t*)src->array;
1296             for (n=0; n < src->size; n++) {
1297                 if (NULL != sbo[n].bytes && 0 < sbo[n].size) {
1298                     pbo[n].size = sbo[n].size;
1299                     pbo[n].bytes = (char*)malloc(pbo[n].size);
1300                     memcpy(pbo[n].bytes, sbo[n].bytes, pbo[n].size);
1301                 } else {
1302                     pbo[n].bytes = NULL;
1303                     pbo[n].size = 0;
1304                 }
1305             }
1306             break;
1307         case PMIX_KVAL:
1308             p->array = (pmix_kval_t*)calloc(src->size , sizeof(pmix_kval_t));
1309             if (NULL == p->array) {
1310                 free(p);
1311                 return PMIX_ERR_NOMEM;
1312             }
1313             pk = (pmix_kval_t*)p->array;
1314             sk = (pmix_kval_t*)src->array;
1315             for (n=0; n < src->size; n++) {
1316                 if (NULL != sk[n].key) {
1317                     pk[n].key = strdup(sk[n].key);
1318                 }
1319                 if (NULL != sk[n].value) {
1320                     PMIX_VALUE_CREATE(pk[n].value, 1);
1321                     if (NULL == pk[n].value) {
1322                         PMIX_VALUE_FREE(pk[n].value, 1);
1323                         free(p);
1324                         return PMIX_ERR_NOMEM;
1325                     }
1326                     if (PMIX_SUCCESS != (rc = pmix20_bfrop_value_xfer(pk[n].value, sk[n].value))) {
1327                         PMIX_VALUE_FREE(pk[n].value, 1);
1328                         free(p);
1329                         return rc;
1330                     }
1331                 }
1332             }
1333             break;
1334         case PMIX_MODEX:
1335             PMIX_MODEX_CREATE(p->array, src->size);
1336             if (NULL == p->array) {
1337                 free(p);
1338                 return PMIX_ERR_NOMEM;
1339             }
1340             pm = (pmix_modex_data_t*)p->array;
1341             sm = (pmix_modex_data_t*)src->array;
1342             for (n=0; n < src->size; n++) {
1343                 memcpy(&pm[n], &sm[n], sizeof(pmix_modex_data_t));
1344                 if (NULL != sm[n].blob && 0 < sm[n].size) {
1345                     pm[n].blob = (uint8_t*)malloc(sm[n].size);
1346                     if (NULL == pm[n].blob) {
1347                         PMIX_MODEX_FREE(pm, src->size);
1348                         free(p);
1349                         return PMIX_ERR_NOMEM;
1350                     }
1351                     memcpy(pm[n].blob, sm[n].blob, sm[n].size);
1352                     pm[n].size = sm[n].size;
1353                 } else {
1354                     pm[n].blob = NULL;
1355                     pm[n].size = 0;
1356                 }
1357             }
1358             break;
1359         case PMIX_PERSIST:
1360             p->array = (pmix_persistence_t*)malloc(src->size * sizeof(pmix_persistence_t));
1361             if (NULL == p->array) {
1362                 free(p);
1363                 return PMIX_ERR_NOMEM;
1364             }
1365             memcpy(p->array, src->array, src->size * sizeof(pmix_persistence_t));
1366             break;
1367         case PMIX_POINTER:
1368             p->array = (char**)malloc(src->size * sizeof(char*));
1369             prarray = (char**)p->array;
1370             strarray = (char**)src->array;
1371             for (n=0; n < src->size; n++) {
1372                 prarray[n] = strarray[n];
1373             }
1374             break;
1375         case PMIX_SCOPE:
1376             p->array = (pmix_scope_t*)malloc(src->size * sizeof(pmix_scope_t));
1377             if (NULL == p->array) {
1378                 free(p);
1379                 return PMIX_ERR_NOMEM;
1380             }
1381             memcpy(p->array, src->array, src->size * sizeof(pmix_scope_t));
1382             break;
1383         case PMIX_DATA_RANGE:
1384             p->array = (pmix_data_range_t*)malloc(src->size * sizeof(pmix_data_range_t));
1385             if (NULL == p->array) {
1386                 free(p);
1387                 return PMIX_ERR_NOMEM;
1388             }
1389             memcpy(p->array, src->array, src->size * sizeof(pmix_data_range_t));
1390             break;
1391         case PMIX_COMMAND:
1392             p->array = (pmix_cmd_t*)malloc(src->size * sizeof(pmix_cmd_t));
1393             if (NULL == p->array) {
1394                 free(p);
1395                 return PMIX_ERR_NOMEM;
1396             }
1397             memcpy(p->array, src->array, src->size * sizeof(pmix_cmd_t));
1398             break;
1399         case PMIX_INFO_DIRECTIVES:
1400             p->array = (pmix_info_directives_t*)malloc(src->size * sizeof(pmix_info_directives_t));
1401             if (NULL == p->array) {
1402                 free(p);
1403                 return PMIX_ERR_NOMEM;
1404             }
1405             memcpy(p->array, src->array, src->size * sizeof(pmix_info_directives_t));
1406             break;
1407         case PMIX_PROC_INFO:
1408             PMIX_PROC_INFO_CREATE(p->array, src->size);
1409             if (NULL == p->array) {
1410                 free(p);
1411                 return PMIX_ERR_NOMEM;
1412             }
1413             pi = (pmix_proc_info_t*)p->array;
1414             si = (pmix_proc_info_t*)src->array;
1415             for (n=0; n < src->size; n++) {
1416                 memcpy(&pi[n].proc, &si[n].proc, sizeof(pmix_proc_t));
1417                 if (NULL != si[n].hostname) {
1418                     pi[n].hostname = strdup(si[n].hostname);
1419                 } else {
1420                     pi[n].hostname = NULL;
1421                 }
1422                 if (NULL != si[n].executable_name) {
1423                     pi[n].executable_name = strdup(si[n].executable_name);
1424                 } else {
1425                     pi[n].executable_name = NULL;
1426                 }
1427                 pi[n].pid = si[n].pid;
1428                 pi[n].exit_code = si[n].exit_code;
1429                 pi[n].state = si[n].state;
1430             }
1431             break;
1432         case PMIX_DATA_ARRAY:
1433             free(p);
1434             return PMIX_ERR_NOT_SUPPORTED;  // don't support iterative arrays
1435         case PMIX_QUERY:
1436             PMIX_QUERY_CREATE(p->array, src->size);
1437             if (NULL == p->array) {
1438                 free(p);
1439                 return PMIX_ERR_NOMEM;
1440             }
1441             pq = (pmix_query_t*)p->array;
1442             sq = (pmix_query_t*)src->array;
1443             for (n=0; n < src->size; n++) {
1444                 if (NULL != sq[n].keys) {
1445                     pq[n].keys = pmix_argv_copy(sq[n].keys);
1446                 }
1447                 if (NULL != sq[n].qualifiers && 0 < sq[n].nqual) {
1448                     PMIX_INFO_CREATE(pq[n].qualifiers, sq[n].nqual);
1449                     if (NULL == pq[n].qualifiers) {
1450                         PMIX_INFO_FREE(pq[n].qualifiers, sq[n].nqual);
1451                         free(p);
1452                         return PMIX_ERR_NOMEM;
1453                     }
1454                     for (m=0; m < sq[n].nqual; m++) {
1455                         PMIX_INFO_XFER(&pq[n].qualifiers[m], &sq[n].qualifiers[m]);
1456                     }
1457                     pq[n].nqual = sq[n].nqual;
1458                 } else {
1459                     pq[n].qualifiers = NULL;
1460                     pq[n].nqual = 0;
1461                 }
1462             }
1463             break;
1464         default:
1465             free(p);
1466             return PMIX_ERR_UNKNOWN_DATA_TYPE;
1467     }
1468 
1469     (*dest) = p;
1470     return PMIX_SUCCESS;
1471 }
1472 
1473 pmix_status_t pmix20_bfrop_copy_query(pmix_query_t **dest,
1474                                     pmix_query_t *src,
1475                                     pmix_data_type_t type)
1476 {
1477     pmix_status_t rc;
1478 
1479     *dest = (pmix_query_t*)malloc(sizeof(pmix_query_t));
1480     if (NULL != src->keys) {
1481         (*dest)->keys = pmix_argv_copy(src->keys);
1482     }
1483     (*dest)->nqual = src->nqual;
1484     if (NULL != src->qualifiers) {
1485         if (PMIX_SUCCESS != (rc = pmix20_bfrop_copy_info(&((*dest)->qualifiers), src->qualifiers, PMIX_INFO))) {
1486             free(*dest);
1487             return rc;
1488         }
1489     }
1490     return PMIX_SUCCESS;
1491 }
1492 
1493 /**** DEPRECATED ****/
1494 pmix_status_t pmix20_bfrop_copy_array(pmix_info_array_t **dest,
1495                                     pmix_info_array_t *src,
1496                                     pmix_data_type_t type)
1497 {
1498     pmix_info_t *d1, *s1;
1499 
1500     *dest = (pmix_info_array_t*)malloc(sizeof(pmix_info_array_t));
1501     (*dest)->size = src->size;
1502     (*dest)->array = (pmix_info_t*)malloc(src->size * sizeof(pmix_info_t));
1503     d1 = (pmix_info_t*)(*dest)->array;
1504     s1 = (pmix_info_t*)src->array;
1505     memcpy(d1, s1, src->size * sizeof(pmix_info_t));
1506     return PMIX_SUCCESS;
1507 }
1508 /*******************/