This source file includes following definitions.
- pmix12_bfrop_unpack
- pmix12_bfrop_unpack_buffer
- pmix12_bfrop_unpack_bool
- pmix12_bfrop_unpack_int
- pmix12_bfrop_unpack_sizet
- pmix12_bfrop_unpack_pid
- pmix12_bfrop_unpack_byte
- pmix12_bfrop_unpack_int16
- pmix12_bfrop_unpack_int32
- pmix12_bfrop_unpack_datatype
- pmix12_bfrop_unpack_int64
- pmix12_bfrop_unpack_string
- pmix12_bfrop_unpack_float
- pmix12_bfrop_unpack_double
- pmix12_bfrop_unpack_timeval
- pmix12_bfrop_unpack_time
- unpack_val
- pmix12_bfrop_unpack_value
- pmix12_bfrop_unpack_info
- pmix12_bfrop_unpack_pdata
- pmix12_bfrop_unpack_buf
- pmix12_bfrop_unpack_proc
- pmix12_bfrop_unpack_app
- pmix12_bfrop_unpack_kval
- pmix12_bfrop_unpack_array
- pmix12_bfrop_unpack_modex
- pmix12_bfrop_unpack_persist
- pmix12_bfrop_unpack_bo
- pmix12_bfrop_unpack_ptr
- pmix12_bfrop_unpack_scope
- pmix12_bfrop_unpack_status
- pmix12_bfrop_unpack_range
- pmix12_bfrop_unpack_cmd
- pmix12_bfrop_unpack_info_directives
- pmix12_bfrop_unpack_proc_state
- pmix12_bfrop_unpack_darray
- pmix12_bfrop_unpack_proc_info
- pmix12_bfrop_unpack_query
- pmix12_bfrop_unpack_rank
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 
  25 
  26 #include <src/include/pmix_config.h>
  27 
  28 #include "src/util/argv.h"
  29 #include "src/util/error.h"
  30 #include "src/util/output.h"
  31 #include "src/mca/bfrops/base/base.h"
  32 #include "bfrop_v12.h"
  33 #include "internal.h"
  34 
  35 pmix_status_t pmix12_bfrop_unpack(pmix_buffer_t *buffer,
  36                                   void *dst, int32_t *num_vals,
  37                                   pmix_data_type_t type)
  38 {
  39     pmix_status_t rc, ret;
  40     int32_t local_num, n=1;
  41     pmix_data_type_t local_type;
  42     pmix_pointer_array_t *regtypes = &mca_bfrops_v12_component.types;
  43 
  44     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
  45                         "pmix12_bfrop_unpack: for type %d", (int)type);
  46 
  47     
  48     if (NULL == buffer || NULL == dst || NULL == num_vals) {
  49         PMIX_ERROR_LOG(PMIX_ERR_BAD_PARAM);
  50         return PMIX_ERR_BAD_PARAM;
  51     }
  52 
  53     
  54 
  55 
  56     if (0 == *num_vals) {
  57         pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
  58                             "pmix12_bfrop_unpack: inadequate space ( %p, %p, %lu, %d )\n",
  59                        (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
  60         PMIX_ERROR_LOG(PMIX_ERR_UNPACK_INADEQUATE_SPACE);
  61         return PMIX_ERR_UNPACK_INADEQUATE_SPACE;
  62     }
  63 
  64     
  65 
  66 
  67 
  68 
  69 
  70 
  71 
  72 
  73     if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
  74         if (PMIX_SUCCESS != (rc = pmix12_bfrop_get_data_type(regtypes, buffer, &local_type))) {
  75             *num_vals = 0;
  76             
  77 
  78             return rc;
  79         }
  80         if (PMIX_INT32 != local_type) { 
  81             *num_vals = 0;
  82             PMIX_ERROR_LOG(PMIX_ERR_UNPACK_FAILURE);
  83             return PMIX_ERR_UNPACK_FAILURE;
  84         }
  85     }
  86 
  87     n=1;
  88     if (PMIX_SUCCESS != (rc = pmix12_bfrop_unpack_int32(regtypes, buffer, &local_num, &n, PMIX_INT32))) {
  89         *num_vals = 0;
  90         
  91 
  92         PMIX_ERROR_LOG(rc);
  93         return rc;
  94     }
  95 
  96     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
  97                         "pmix12_bfrop_unpack: found %d values for %d provided storage",
  98                         local_num, *num_vals);
  99 
 100     
 101 
 102 
 103 
 104 
 105     if (local_num > *num_vals) {
 106         local_num = *num_vals;
 107         pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 108                             "pmix12_bfrop_unpack: inadequate space ( %p, %p, %lu, %d )\n",
 109                             (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
 110         ret = PMIX_ERR_UNPACK_INADEQUATE_SPACE;
 111     } else {  
 112         *num_vals = local_num;  
 113         ret = PMIX_SUCCESS;
 114     }
 115 
 116     
 117     if (PMIX_SUCCESS != (rc = pmix12_bfrop_unpack_buffer(regtypes, buffer, dst, &local_num, type))) {
 118         PMIX_ERROR_LOG(rc);
 119         *num_vals = 0;
 120         ret = rc;
 121     }
 122 
 123     return ret;
 124 }
 125 
 126 pmix_status_t pmix12_bfrop_unpack_buffer(pmix_pointer_array_t *regtypes,
 127                                          pmix_buffer_t *buffer, void *dst, int32_t *num_vals,
 128                                          pmix_data_type_t type)
 129 {
 130     pmix_status_t rc;
 131     pmix_data_type_t local_type, v1type;
 132 
 133     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_buffer( %p, %p, %lu, %d )\n",
 134                    (void*)buffer, dst, (long unsigned int)*num_vals, (int)type);
 135 
 136     
 137     switch (type) {
 138         case PMIX_COMMAND:
 139             v1type = PMIX_UINT32;
 140             break;
 141         case PMIX_SCOPE:
 142         case PMIX_DATA_RANGE:
 143             v1type = PMIX_UINT;
 144             break;
 145         case PMIX_PROC_RANK:
 146         case PMIX_PERSIST:
 147         case PMIX_STATUS:
 148             v1type = PMIX_INT;
 149             break;
 150         default:
 151             v1type = type;
 152     }
 153 
 154     
 155     if (PMIX_BFROP_BUFFER_FULLY_DESC == buffer->type) {
 156         if (PMIX_SUCCESS != (rc = pmix12_bfrop_get_data_type(regtypes, buffer, &local_type))) {
 157             PMIX_ERROR_LOG(rc);
 158             return rc;
 159         }
 160         
 161         if (v1type != local_type) {
 162             pmix_output_verbose(1, pmix_bfrops_base_framework.framework_output,
 163                                 "PMIX bfrop:unpack: got type %d when expecting type %d", local_type, v1type);
 164             return PMIX_ERR_PACK_MISMATCH;
 165         }
 166     }
 167     PMIX_BFROPS_UNPACK_TYPE(rc, buffer, dst, num_vals, v1type, regtypes);
 168 
 169     return rc;
 170 }
 171 
 172 
 173 
 174 
 175 
 176 
 177 
 178 pmix_status_t pmix12_bfrop_unpack_bool(pmix_pointer_array_t *regtypes,
 179                                        pmix_buffer_t *buffer, void *dest,
 180                                        int32_t *num_vals, pmix_data_type_t type)
 181 {
 182     int32_t i;
 183     uint8_t *src;
 184     bool *dst;
 185 
 186     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_bool * %d\n", (int)*num_vals);
 187     
 188     if (pmix_bfrop_too_small(buffer, *num_vals)) {
 189         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 190     }
 191 
 192     
 193     src = (uint8_t*)buffer->unpack_ptr;
 194     dst = (bool*)dest;
 195 
 196     for (i=0; i < *num_vals; i++) {
 197         if (src[i]) {
 198             dst[i] = true;
 199         } else {
 200             dst[i] = false;
 201         }
 202     }
 203 
 204     
 205     buffer->unpack_ptr += *num_vals;
 206 
 207     return PMIX_SUCCESS;
 208 }
 209 
 210 
 211 
 212 
 213 pmix_status_t pmix12_bfrop_unpack_int(pmix_pointer_array_t *regtypes,
 214                                       pmix_buffer_t *buffer, void *dest,
 215                                       int32_t *num_vals, pmix_data_type_t type)
 216 {
 217     pmix_status_t ret;
 218     pmix_data_type_t remote_type;
 219 
 220     if (PMIX_SUCCESS != (ret = pmix12_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
 221         return ret;
 222     }
 223 
 224     if (remote_type == BFROP_TYPE_INT) {
 225         
 226         
 227         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_INT))) {
 228         }
 229     } else {
 230         
 231         PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, int, remote_type, ret);
 232     }
 233 
 234     return ret;
 235 }
 236 
 237 
 238 
 239 
 240 pmix_status_t pmix12_bfrop_unpack_sizet(pmix_pointer_array_t *regtypes,
 241                                         pmix_buffer_t *buffer, void *dest,
 242                                         int32_t *num_vals, pmix_data_type_t type)
 243 {
 244     pmix_status_t ret;
 245     pmix_data_type_t remote_type;
 246 
 247     if (PMIX_SUCCESS != (ret = pmix12_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
 248         return ret;
 249     }
 250 
 251     if (remote_type == BFROP_TYPE_SIZE_T) {
 252         
 253         
 254         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_SIZE_T))) {
 255         }
 256     } else {
 257         
 258         PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, size_t, remote_type, ret);
 259     }
 260 
 261     return ret;
 262 }
 263 
 264 
 265 
 266 
 267 pmix_status_t pmix12_bfrop_unpack_pid(pmix_pointer_array_t *regtypes,
 268                                       pmix_buffer_t *buffer, void *dest,
 269                                       int32_t *num_vals, pmix_data_type_t type)
 270 {
 271     pmix_status_t ret;
 272     pmix_data_type_t remote_type;
 273 
 274     if (PMIX_SUCCESS != (ret = pmix12_bfrop_get_data_type(regtypes, buffer, &remote_type))) {
 275         return ret;
 276     }
 277 
 278     if (remote_type == BFROP_TYPE_PID_T) {
 279         
 280         
 281         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_PID_T))) {
 282         }
 283     } else {
 284         
 285         PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, pid_t, remote_type, ret);
 286     }
 287 
 288     return ret;
 289 }
 290 
 291 
 292 
 293 
 294 
 295 
 296 
 297 pmix_status_t pmix12_bfrop_unpack_byte(pmix_pointer_array_t *regtypes,
 298                                        pmix_buffer_t *buffer, void *dest,
 299                                        int32_t *num_vals, pmix_data_type_t type)
 300 {
 301     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_byte * %d\n", (int)*num_vals);
 302     
 303     if (pmix_bfrop_too_small(buffer, *num_vals)) {
 304         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 305     }
 306 
 307     
 308     memcpy(dest, buffer->unpack_ptr, *num_vals);
 309 
 310     
 311     buffer->unpack_ptr += *num_vals;
 312 
 313     return PMIX_SUCCESS;
 314 }
 315 
 316 pmix_status_t pmix12_bfrop_unpack_int16(pmix_pointer_array_t *regtypes,
 317                                         pmix_buffer_t *buffer, void *dest,
 318                                         int32_t *num_vals, pmix_data_type_t type)
 319 {
 320     int32_t i;
 321     uint16_t tmp, *desttmp = (uint16_t*) dest;
 322 
 323     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_int16 * %d\n", (int)*num_vals);
 324     
 325     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 326         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 327     }
 328 
 329     
 330     for (i = 0; i < (*num_vals); ++i) {
 331         memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
 332         tmp = pmix_ntohs(tmp);
 333         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 334         buffer->unpack_ptr += sizeof(tmp);
 335     }
 336 
 337     return PMIX_SUCCESS;
 338 }
 339 
 340 pmix_status_t pmix12_bfrop_unpack_int32(pmix_pointer_array_t *regtypes,
 341                                         pmix_buffer_t *buffer, void *dest,
 342                                         int32_t *num_vals, pmix_data_type_t type)
 343 {
 344     int32_t i;
 345     uint32_t tmp, *desttmp = (uint32_t*) dest;
 346 
 347     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output, "pmix12_bfrop_unpack_int32 * %d\n", (int)*num_vals);
 348     
 349     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 350         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 351     }
 352 
 353     
 354     for (i = 0; i < (*num_vals); ++i) {
 355         memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
 356         tmp = ntohl(tmp);
 357         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 358         buffer->unpack_ptr += sizeof(tmp);
 359     }
 360 
 361     return PMIX_SUCCESS;
 362 }
 363 
 364 pmix_status_t pmix12_bfrop_unpack_datatype(pmix_pointer_array_t *regtypes,
 365                                            pmix_buffer_t *buffer, void *dest,
 366                                            int32_t *num_vals, pmix_data_type_t type)
 367 {
 368     return pmix12_bfrop_unpack_int32(regtypes, buffer, dest, num_vals, type);
 369 }
 370 
 371 pmix_status_t pmix12_bfrop_unpack_int64(pmix_pointer_array_t *regtypes,
 372                                         pmix_buffer_t *buffer, void *dest,
 373                                         int32_t *num_vals, pmix_data_type_t type)
 374 {
 375     int32_t i;
 376     uint64_t tmp, *desttmp = (uint64_t*) dest;
 377 
 378     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 379                         "pmix12_bfrop_unpack_int64 * %d\n", (int)*num_vals);
 380     
 381     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 382         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 383     }
 384 
 385     
 386     for (i = 0; i < (*num_vals); ++i) {
 387         memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
 388         tmp = pmix_ntoh64(tmp);
 389         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 390         buffer->unpack_ptr += sizeof(tmp);
 391     }
 392 
 393     return PMIX_SUCCESS;
 394 }
 395 
 396 pmix_status_t pmix12_bfrop_unpack_string(pmix_pointer_array_t *regtypes,
 397                                          pmix_buffer_t *buffer, void *dest,
 398                                          int32_t *num_vals, pmix_data_type_t type)
 399 {
 400     pmix_status_t ret;
 401     int32_t i, len, n=1;
 402     char **sdest = (char**) dest;
 403 
 404     for (i = 0; i < (*num_vals); ++i) {
 405         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int32(regtypes, buffer,
 406                                                              &len, &n, PMIX_INT32))) {
 407             return ret;
 408         }
 409         if (0 ==  len) {   
 410             sdest[i] = NULL;
 411         } else {
 412             sdest[i] = (char*)malloc(len);
 413             if (NULL == sdest[i]) {
 414                 return PMIX_ERR_OUT_OF_RESOURCE;
 415             }
 416             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer,
 417                                                                 sdest[i], &len,
 418                                                                 PMIX_BYTE))) {
 419                 return ret;
 420             }
 421         }
 422     }
 423 
 424     return PMIX_SUCCESS;
 425 }
 426 
 427 pmix_status_t pmix12_bfrop_unpack_float(pmix_pointer_array_t *regtypes,
 428                                         pmix_buffer_t *buffer, void *dest,
 429                                         int32_t *num_vals, pmix_data_type_t type)
 430 {
 431     int32_t i, n;
 432     float *desttmp = (float*) dest, tmp;
 433     pmix_status_t ret;
 434     char *convert;
 435 
 436     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 437                         "pmix12_bfrop_unpack_float * %d\n", (int)*num_vals);
 438     
 439     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(float))) {
 440         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 441     }
 442 
 443     
 444     for (i = 0; i < (*num_vals); ++i) {
 445         n=1;
 446         convert = NULL;
 447         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer,
 448                                                               &convert, &n, PMIX_STRING))) {
 449             return ret;
 450         }
 451         if (NULL != convert) {
 452             tmp = strtof(convert, NULL);
 453             memcpy(&desttmp[i], &tmp, sizeof(tmp));
 454             free(convert);
 455         }
 456     }
 457     return PMIX_SUCCESS;
 458 }
 459 
 460 pmix_status_t pmix12_bfrop_unpack_double(pmix_pointer_array_t *regtypes,
 461                                          pmix_buffer_t *buffer, void *dest,
 462                                          int32_t *num_vals, pmix_data_type_t type)
 463 {
 464     int32_t i, n;
 465     double *desttmp = (double*) dest, tmp;
 466     pmix_status_t ret;
 467     char *convert;
 468 
 469     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 470                         "pmix12_bfrop_unpack_double * %d\n", (int)*num_vals);
 471     
 472     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(double))) {
 473         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 474     }
 475 
 476     
 477     for (i = 0; i < (*num_vals); ++i) {
 478         n=1;
 479         convert = NULL;
 480         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer,
 481                                                               &convert, &n,
 482                                                               PMIX_STRING))) {
 483             return ret;
 484         }
 485         if (NULL != convert) {
 486             tmp = strtod(convert, NULL);
 487             memcpy(&desttmp[i], &tmp, sizeof(tmp));
 488             free(convert);
 489         }
 490     }
 491     return PMIX_SUCCESS;
 492 }
 493 
 494 pmix_status_t pmix12_bfrop_unpack_timeval(pmix_pointer_array_t *regtypes,
 495                                           pmix_buffer_t *buffer, void *dest,
 496                                           int32_t *num_vals, pmix_data_type_t type)
 497 {
 498     int32_t i, n;
 499     int64_t tmp[2];
 500     struct timeval *desttmp = (struct timeval *) dest, tt;
 501     pmix_status_t ret;
 502 
 503     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 504                         "pmix12_bfrop_unpack_timeval * %d\n", (int)*num_vals);
 505     
 506     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(struct timeval))) {
 507         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 508     }
 509 
 510     
 511     for (i = 0; i < (*num_vals); ++i) {
 512         n=2;
 513         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int64(regtypes, buffer,
 514                                                              tmp, &n, PMIX_INT64))) {
 515             return ret;
 516         }
 517         tt.tv_sec = tmp[0];
 518         tt.tv_usec = tmp[1];
 519         memcpy(&desttmp[i], &tt, sizeof(tt));
 520     }
 521     return PMIX_SUCCESS;
 522 }
 523 
 524 pmix_status_t pmix12_bfrop_unpack_time(pmix_pointer_array_t *regtypes,
 525                                        pmix_buffer_t *buffer, void *dest,
 526                                        int32_t *num_vals, pmix_data_type_t type)
 527 {
 528     int32_t i, n;
 529     time_t *desttmp = (time_t *) dest, tmp;
 530     pmix_status_t ret;
 531     uint64_t ui64;
 532 
 533     
 534 
 535 
 536 
 537     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 538                         "pmix12_bfrop_unpack_time * %d\n", (int)*num_vals);
 539     
 540     if (pmix_bfrop_too_small(buffer, (*num_vals)*(sizeof(uint64_t)))) {
 541         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 542     }
 543 
 544     
 545     for (i = 0; i < (*num_vals); ++i) {
 546         n=1;
 547         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int64(regtypes, buffer,
 548                                                              &ui64, &n, PMIX_UINT64))) {
 549             return ret;
 550         }
 551         tmp = (time_t)ui64;
 552         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 553     }
 554     return PMIX_SUCCESS;
 555 }
 556 
 557 
 558 
 559 
 560 
 561 
 562 
 563 static pmix_status_t unpack_val(pmix_pointer_array_t *regtypes,
 564                                 pmix_buffer_t *buffer, pmix_value_t *val)
 565 {
 566     int32_t m;
 567     pmix_status_t ret;
 568 
 569     m = 1;
 570     switch (val->type) {
 571     case PMIX_BOOL:
 572         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.flag, &m, PMIX_BOOL))) {
 573             return ret;
 574         }
 575         break;
 576     case PMIX_BYTE:
 577         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.byte, &m, PMIX_BYTE))) {
 578             return ret;
 579         }
 580         break;
 581     case PMIX_STRING:
 582         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.string, &m, PMIX_STRING))) {
 583             return ret;
 584         }
 585         break;
 586     case PMIX_SIZE:
 587         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.size, &m, PMIX_SIZE))) {
 588             return ret;
 589         }
 590         break;
 591     case PMIX_PID:
 592         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.pid, &m, PMIX_PID))) {
 593             return ret;
 594         }
 595         break;
 596     case PMIX_INT:
 597         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.integer, &m, PMIX_INT))) {
 598             return ret;
 599         }
 600         break;
 601     case PMIX_INT8:
 602         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int8, &m, PMIX_INT8))) {
 603             return ret;
 604         }
 605         break;
 606     case PMIX_INT16:
 607         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int16, &m, PMIX_INT16))) {
 608             return ret;
 609         }
 610         break;
 611     case PMIX_INT32:
 612         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int32, &m, PMIX_INT32))) {
 613             return ret;
 614         }
 615         break;
 616     case PMIX_INT64:
 617         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.int64, &m, PMIX_INT64))) {
 618             return ret;
 619         }
 620         break;
 621     case PMIX_UINT:
 622         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint, &m, PMIX_UINT))) {
 623             return ret;
 624         }
 625         break;
 626     case PMIX_UINT8:
 627         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint8, &m, PMIX_UINT8))) {
 628             return ret;
 629         }
 630         break;
 631     case PMIX_UINT16:
 632         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint16, &m, PMIX_UINT16))) {
 633             return ret;
 634         }
 635         break;
 636     case PMIX_UINT32:
 637         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint32, &m, PMIX_UINT32))) {
 638             return ret;
 639         }
 640         break;
 641     case PMIX_UINT64:
 642         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.uint64, &m, PMIX_UINT64))) {
 643             return ret;
 644         }
 645         break;
 646     case PMIX_FLOAT:
 647         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.fval, &m, PMIX_FLOAT))) {
 648             return ret;
 649         }
 650         break;
 651     case PMIX_DOUBLE:
 652         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.dval, &m, PMIX_DOUBLE))) {
 653             return ret;
 654         }
 655         break;
 656     case PMIX_TIMEVAL:
 657         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.tv, &m, PMIX_TIMEVAL))) {
 658             return ret;
 659         }
 660         break;
 661     case PMIX_INFO_ARRAY:
 662         
 663 
 664         val->data.darray = (pmix_data_array_t*)calloc(1, sizeof(pmix_data_array_t));
 665         val->data.darray->type = PMIX_INFO_ARRAY;
 666         val->data.darray->size = m;
 667         
 668         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.darray->array, &m, PMIX_INFO_ARRAY))) {
 669             return ret;
 670         }
 671         break;
 672     case PMIX_BYTE_OBJECT:
 673         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, &val->data.bo, &m, PMIX_BYTE_OBJECT))) {
 674             return ret;
 675         }
 676         break;
 677     default:
 678         pmix_output(0, "UNPACK-PMIX-VALUE: UNSUPPORTED TYPE");
 679         return PMIX_ERROR;
 680     }
 681 
 682     return PMIX_SUCCESS;
 683 }
 684 
 685 pmix_status_t pmix12_bfrop_unpack_value(pmix_pointer_array_t *regtypes,
 686                                         pmix_buffer_t *buffer, void *dest,
 687                                         int32_t *num_vals, pmix_data_type_t type)
 688 {
 689     pmix_value_t *ptr;
 690     int32_t i, m, n;
 691     pmix_status_t ret;
 692     int v1type;
 693 
 694     ptr = (pmix_value_t *) dest;
 695     n = *num_vals;
 696 
 697     for (i = 0; i < n; ++i) {
 698         
 699         m=1;
 700         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
 701             return ret;
 702         }
 703         
 704 
 705 
 706         ptr[i].type = pmix12_v1_to_v2_datatype(v1type);
 707         
 708         if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i])) ) {
 709             return ret;
 710         }
 711     }
 712     return PMIX_SUCCESS;
 713 }
 714 
 715 pmix_status_t pmix12_bfrop_unpack_info(pmix_pointer_array_t *regtypes,
 716                                        pmix_buffer_t *buffer, void *dest,
 717                                        int32_t *num_vals, pmix_data_type_t type)
 718 {
 719     pmix_info_t *ptr;
 720     int32_t i, n, m;
 721     pmix_status_t ret;
 722     char *tmp;
 723     int v1type;
 724 
 725     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 726                         "pmix12_bfrop_unpack: %d info", *num_vals);
 727 
 728     ptr = (pmix_info_t *) dest;
 729     n = *num_vals;
 730 
 731     for (i = 0; i < n; ++i) {
 732         memset(ptr[i].key, 0, sizeof(ptr[i].key));
 733         memset(&ptr[i].value, 0, sizeof(pmix_value_t));
 734         
 735         m=1;
 736         tmp = NULL;
 737         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
 738             return ret;
 739         }
 740         if (NULL == tmp) {
 741             return PMIX_ERROR;
 742         }
 743         pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
 744         free(tmp);
 745         
 746 
 747 
 748         m=1;
 749         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
 750             return ret;
 751         }
 752         
 753 
 754 
 755         ptr[i].value.type = pmix12_v1_to_v2_datatype(v1type);
 756         pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 757                             "pmix12_bfrop_unpack: info type %d", ptr[i].value.type);
 758         m=1;
 759         if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i].value))) {
 760             return ret;
 761         }
 762     }
 763     return PMIX_SUCCESS;
 764 }
 765 
 766 pmix_status_t pmix12_bfrop_unpack_pdata(pmix_pointer_array_t *regtypes,
 767                                         pmix_buffer_t *buffer, void *dest,
 768                                         int32_t *num_vals, pmix_data_type_t type)
 769 {
 770     pmix_pdata_t *ptr;
 771     int32_t i, n, m;
 772     pmix_status_t ret;
 773     char *tmp;
 774     int v1type;
 775 
 776     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 777                         "pmix12_bfrop_unpack: %d pdata", *num_vals);
 778 
 779     ptr = (pmix_pdata_t *) dest;
 780     n = *num_vals;
 781 
 782     for (i = 0; i < n; ++i) {
 783         PMIX_PDATA_CONSTRUCT(&ptr[i]);
 784         
 785         m=1;
 786         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_proc(regtypes, buffer, &ptr[i].proc, &m, PMIX_PROC))) {
 787             return ret;
 788         }
 789         
 790         m=1;
 791         tmp = NULL;
 792         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
 793             return ret;
 794         }
 795         if (NULL == tmp) {
 796             return PMIX_ERROR;
 797         }
 798         pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
 799         free(tmp);
 800         
 801 
 802 
 803         m=1;
 804         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
 805             return ret;
 806         }
 807         
 808 
 809 
 810         ptr[i].value.type = pmix12_v1_to_v2_datatype(v1type);
 811         pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 812                             "pmix12_bfrop_unpack: pdata type %d", ptr[i].value.type);
 813         m=1;
 814         if (PMIX_SUCCESS != (ret = unpack_val(regtypes, buffer, &ptr[i].value))) {
 815             return ret;
 816         }
 817     }
 818     return PMIX_SUCCESS;
 819 }
 820 
 821 pmix_status_t pmix12_bfrop_unpack_buf(pmix_pointer_array_t *regtypes,
 822                                       pmix_buffer_t *buffer, void *dest,
 823                                       int32_t *num_vals, pmix_data_type_t type)
 824 {
 825     pmix_buffer_t *ptr;
 826     int32_t i, n, m;
 827     pmix_status_t ret;
 828     size_t nbytes;
 829 
 830     ptr = (pmix_buffer_t *) dest;
 831     n = *num_vals;
 832 
 833     for (i = 0; i < n; ++i) {
 834         
 835         m=1;
 836         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &nbytes, &m, PMIX_SIZE))) {
 837             return ret;
 838         }
 839         m = nbytes;
 840         
 841         if (0 < nbytes) {
 842             ptr[i].base_ptr = (char*)malloc(nbytes);
 843             
 844             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer, ptr[i].base_ptr, &m, PMIX_BYTE))) {
 845                 return ret;
 846             }
 847         }
 848         ptr[i].pack_ptr = ptr[i].base_ptr + m;
 849         ptr[i].unpack_ptr = ptr[i].base_ptr;
 850         ptr[i].bytes_allocated = nbytes;
 851         ptr[i].bytes_used = m;
 852     }
 853     return PMIX_SUCCESS;
 854 }
 855 
 856 pmix_status_t pmix12_bfrop_unpack_proc(pmix_pointer_array_t *regtypes,
 857                                        pmix_buffer_t *buffer, void *dest,
 858                                        int32_t *num_vals, pmix_data_type_t type)
 859 {
 860     pmix_proc_t *ptr;
 861     int32_t i, n, m;
 862     pmix_status_t ret;
 863     char *tmp;
 864 
 865     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 866                         "pmix12_bfrop_unpack: %d procs", *num_vals);
 867 
 868     ptr = (pmix_proc_t *) dest;
 869     n = *num_vals;
 870 
 871     for (i = 0; i < n; ++i) {
 872         pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 873                             "pmix12_bfrop_unpack: init proc[%d]", i);
 874         memset(&ptr[i], 0, sizeof(pmix_proc_t));
 875         
 876         m=1;
 877         tmp = NULL;
 878         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
 879             return ret;
 880         }
 881         if (NULL == tmp) {
 882             return PMIX_ERROR;
 883         }
 884         pmix_strncpy(ptr[i].nspace, tmp, PMIX_MAX_NSLEN);
 885         free(tmp);
 886         
 887         m=1;
 888         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &ptr[i].rank, &m, PMIX_INT))) {
 889             return ret;
 890         }
 891         
 892 
 893         if (INT32_MAX == ptr[i].rank) {
 894             ptr[i].rank = PMIX_RANK_UNDEF;
 895         } else if (INT32_MAX-1 == ptr[i].rank) {
 896             ptr[i].rank = PMIX_RANK_WILDCARD;
 897         }
 898     }
 899     return PMIX_SUCCESS;
 900 }
 901 
 902 pmix_status_t pmix12_bfrop_unpack_app(pmix_pointer_array_t *regtypes,
 903                                       pmix_buffer_t *buffer, void *dest,
 904                                       int32_t *num_vals, pmix_data_type_t type)
 905 {
 906     pmix_app_t *ptr;
 907     int32_t i, k, n, m;
 908     pmix_status_t ret;
 909     int32_t nval;
 910     char *tmp;
 911     int argc;
 912 
 913     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 914                         "pmix12_bfrop_unpack: %d apps", *num_vals);
 915 
 916     ptr = (pmix_app_t *) dest;
 917     n = *num_vals;
 918 
 919     for (i = 0; i < n; ++i) {
 920         
 921         PMIX_APP_CONSTRUCT(&ptr[i]);
 922         
 923         m=1;
 924         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &ptr[i].cmd, &m, PMIX_STRING))) {
 925             return ret;
 926         }
 927         
 928         m=1;
 929         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &argc, &m, PMIX_INT))) {
 930             return ret;
 931         }
 932         
 933         for (k=0; k < argc; k++) {
 934             m=1;
 935             tmp = NULL;
 936             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
 937                 return ret;
 938             }
 939             if (NULL == tmp) {
 940                 return PMIX_ERROR;
 941             }
 942             pmix_argv_append_nosize(&ptr[i].argv, tmp);
 943             free(tmp);
 944         }
 945         
 946         m=1;
 947         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int32(regtypes, buffer, &nval, &m, PMIX_INT32))) {
 948             return ret;
 949         }
 950         for (k=0; k < nval; k++) {
 951             m=1;
 952             tmp = NULL;
 953             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &tmp, &m, PMIX_STRING))) {
 954                 return ret;
 955             }
 956             if (NULL == tmp) {
 957                 return PMIX_ERROR;
 958             }
 959             pmix_argv_append_nosize(&ptr[i].env, tmp);
 960             free(tmp);
 961         }
 962         
 963         m=1;
 964         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &ptr[i].maxprocs, &m, PMIX_INT))) {
 965             return ret;
 966         }
 967         
 968         m=1;
 969         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].ninfo, &m, PMIX_SIZE))) {
 970             return ret;
 971         }
 972         if (0 < ptr[i].ninfo) {
 973             PMIX_INFO_CREATE(ptr[i].info, ptr[i].ninfo);
 974             m = ptr[i].ninfo;
 975             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_info(regtypes, buffer, ptr[i].info, &m, PMIX_INFO))) {
 976                 return ret;
 977             }
 978         }
 979     }
 980     return PMIX_SUCCESS;
 981 }
 982 
 983 pmix_status_t pmix12_bfrop_unpack_kval(pmix_pointer_array_t *regtypes,
 984                                        pmix_buffer_t *buffer, void *dest,
 985                                        int32_t *num_vals, pmix_data_type_t type)
 986 {
 987     pmix_kval_t *ptr;
 988     int32_t i, n, m;
 989     pmix_status_t ret;
 990 
 991     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 992                         "pmix12_bfrop_unpack: %d kvals", *num_vals);
 993 
 994     ptr = (pmix_kval_t*) dest;
 995     n = *num_vals;
 996 
 997     for (i = 0; i < n; ++i) {
 998         PMIX_CONSTRUCT(&ptr[i], pmix_kval_t);
 999         
1000         m = 1;
1001         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_string(regtypes, buffer, &ptr[i].key, &m, PMIX_STRING))) {
1002             PMIX_ERROR_LOG(ret);
1003             return ret;
1004         }
1005         
1006         ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
1007         
1008         m = 1;
1009         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_value(regtypes, buffer, ptr[i].value, &m, PMIX_VALUE))) {
1010             PMIX_ERROR_LOG(ret);
1011             return ret;
1012         }
1013     }
1014     return PMIX_SUCCESS;
1015 }
1016 
1017 pmix_status_t pmix12_bfrop_unpack_array(pmix_pointer_array_t *regtypes,
1018                                         pmix_buffer_t *buffer, void *dest,
1019                                         int32_t *num_vals, pmix_data_type_t type)
1020 {
1021     pmix_info_array_t *ptr;
1022     int32_t i, n, m;
1023     pmix_status_t ret;
1024 
1025     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1026                         "pmix12_bfrop_unpack: %d info arrays", *num_vals);
1027 
1028     ptr = (pmix_info_array_t*) dest;
1029     n = *num_vals;
1030 
1031     for (i = 0; i < n; ++i) {
1032         pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1033                             "pmix12_bfrop_unpack: init array[%d]", i);
1034         memset(&ptr[i], 0, sizeof(pmix_info_array_t));
1035         
1036         m=1;
1037         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1038             return ret;
1039         }
1040         if (0 < ptr[i].size) {
1041             ptr[i].array = (pmix_info_t*)malloc(ptr[i].size * sizeof(pmix_info_t));
1042             m=ptr[i].size;
1043             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_value(regtypes, buffer, ptr[i].array, &m, PMIX_INFO))) {
1044                 return ret;
1045             }
1046         }
1047     }
1048     return PMIX_SUCCESS;
1049 }
1050 
1051 pmix_status_t pmix12_bfrop_unpack_modex(pmix_pointer_array_t *regtypes,
1052                                         pmix_buffer_t *buffer, void *dest,
1053                                         int32_t *num_vals, pmix_data_type_t type)
1054 {
1055     pmix_modex_data_t *ptr;
1056     int32_t i, n, m;
1057     pmix_status_t ret;
1058 
1059     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1060                         "pmix12_bfrop_unpack: %d modex", *num_vals);
1061 
1062     ptr = (pmix_modex_data_t *) dest;
1063     n = *num_vals;
1064 
1065     for (i = 0; i < n; ++i) {
1066         memset(&ptr[i], 0, sizeof(pmix_modex_data_t));
1067         
1068         m=1;
1069         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1070             return ret;
1071         }
1072         if (0 < ptr[i].size) {
1073             ptr[i].blob = (uint8_t*)malloc(ptr[i].size * sizeof(uint8_t));
1074             m=ptr[i].size;
1075             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer, ptr[i].blob, &m, PMIX_UINT8))) {
1076                 return ret;
1077             }
1078         }
1079     }
1080     return PMIX_SUCCESS;
1081 }
1082 
1083 
1084 pmix_status_t pmix12_bfrop_unpack_persist(pmix_pointer_array_t *regtypes,
1085                                           pmix_buffer_t *buffer, void *dest,
1086                                           int32_t *num_vals, pmix_data_type_t type)
1087 {
1088     return pmix12_bfrop_unpack_int(regtypes, buffer, dest, num_vals, PMIX_INT);
1089 }
1090 
1091 pmix_status_t pmix12_bfrop_unpack_bo(pmix_pointer_array_t *regtypes,
1092                                      pmix_buffer_t *buffer, void *dest,
1093                                      int32_t *num_vals, pmix_data_type_t type)
1094 {
1095     pmix_byte_object_t *ptr;
1096     int32_t i, n, m;
1097     pmix_status_t ret;
1098 
1099     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
1100                         "pmix12_bfrop_unpack: %d byte_object", *num_vals);
1101 
1102     ptr = (pmix_byte_object_t *) dest;
1103     n = *num_vals;
1104 
1105     for (i = 0; i < n; ++i) {
1106         memset(&ptr[i], 0, sizeof(pmix_byte_object_t));
1107         
1108         m=1;
1109         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_sizet(regtypes, buffer, &ptr[i].size, &m, PMIX_SIZE))) {
1110             return ret;
1111         }
1112         if (0 < ptr[i].size) {
1113             ptr[i].bytes = (char*)malloc(ptr[i].size * sizeof(char));
1114             m=ptr[i].size;
1115             if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_byte(regtypes, buffer, ptr[i].bytes, &m, PMIX_BYTE))) {
1116                 return ret;
1117             }
1118         }
1119     }
1120     return PMIX_SUCCESS;
1121 }
1122 
1123 pmix_status_t pmix12_bfrop_unpack_ptr(pmix_pointer_array_t *regtypes,
1124                                       pmix_buffer_t *buffer, void *dest,
1125                                       int32_t *num_vals, pmix_data_type_t type)
1126 {
1127     return PMIX_ERR_NOT_SUPPORTED;
1128 }
1129 
1130 pmix_status_t pmix12_bfrop_unpack_scope(pmix_pointer_array_t *regtypes,
1131                                         pmix_buffer_t *buffer, void *dest,
1132                                         int32_t *num_vals, pmix_data_type_t type)
1133 {
1134     return PMIX_ERR_NOT_SUPPORTED;
1135 }
1136 
1137 pmix_status_t pmix12_bfrop_unpack_status(pmix_pointer_array_t *regtypes,
1138                                          pmix_buffer_t *buffer, void *dest,
1139                                          int32_t *num_vals, pmix_data_type_t type)
1140 {
1141     return PMIX_ERR_NOT_SUPPORTED;
1142 }
1143 
1144 pmix_status_t pmix12_bfrop_unpack_range(pmix_pointer_array_t *regtypes,
1145                                         pmix_buffer_t *buffer, void *dest,
1146                                         int32_t *num_vals, pmix_data_type_t type)
1147 {
1148     return PMIX_ERR_NOT_SUPPORTED;
1149 }
1150 
1151 pmix_status_t pmix12_bfrop_unpack_cmd(pmix_pointer_array_t *regtypes,
1152                                       pmix_buffer_t *buffer, void *dest,
1153                                       int32_t *num_vals, pmix_data_type_t type)
1154 {
1155     return PMIX_ERR_NOT_SUPPORTED;
1156 }
1157 
1158 pmix_status_t pmix12_bfrop_unpack_info_directives(pmix_pointer_array_t *regtypes,
1159                                                   pmix_buffer_t *buffer, void *dest,
1160                                                   int32_t *num_vals, pmix_data_type_t type)
1161 {
1162     return PMIX_ERR_NOT_SUPPORTED;
1163 }
1164 
1165 pmix_status_t pmix12_bfrop_unpack_proc_state(pmix_pointer_array_t *regtypes,
1166                                              pmix_buffer_t *buffer, void *dest,
1167                                              int32_t *num_vals, pmix_data_type_t type)
1168 {
1169     return PMIX_ERR_NOT_SUPPORTED;
1170 }
1171 
1172 pmix_status_t pmix12_bfrop_unpack_darray(pmix_pointer_array_t *regtypes,
1173                                          pmix_buffer_t *buffer, void *dest,
1174                                          int32_t *num_vals, pmix_data_type_t type)
1175 {
1176     return PMIX_ERR_NOT_SUPPORTED;
1177 }
1178 
1179 pmix_status_t pmix12_bfrop_unpack_proc_info(pmix_pointer_array_t *regtypes,
1180                                             pmix_buffer_t *buffer, void *dest,
1181                                             int32_t *num_vals, pmix_data_type_t type)
1182 {
1183     return PMIX_ERR_NOT_SUPPORTED;
1184 }
1185 
1186 pmix_status_t pmix12_bfrop_unpack_query(pmix_pointer_array_t *regtypes,
1187                                         pmix_buffer_t *buffer, void *dest,
1188                                         int32_t *num_vals, pmix_data_type_t type)
1189 {
1190     return PMIX_ERR_NOT_SUPPORTED;
1191 }
1192 
1193 pmix_status_t pmix12_bfrop_unpack_rank(pmix_pointer_array_t *regtypes,
1194                                        pmix_buffer_t *buffer, void *dest,
1195                                        int32_t *num_vals, pmix_data_type_t type)
1196 {
1197     return PMIX_ERR_NOT_SUPPORTED;
1198 }