opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v12/unpack.c

/* [<][>][^][v][top][bottom][index][help] */
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  * 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) 2012      Los Alamos National Security, Inc.  All rights reserved.
  13  * Copyright (c) 2014-2019 Intel, Inc.  All rights reserved.
  14  * Copyright (c) 2015-2019 Research Organization for Information Science
  15  *                         and Technology (RIST).  All rights reserved.
  16  * Copyright (c) 2016-2019 Mellanox Technologies, Inc.
  17  *                         All rights reserved.
  18  * Copyright (c) 2016      IBM Corporation.  All rights reserved.
  19  * $COPYRIGHT$
  20  *
  21  * Additional copyrights may follow
  22  *
  23  * $HEADER$
  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     /* check for error */
  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     /* if user provides a zero for num_vals, then there is no storage allocated
  54      * so return an appropriate error
  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     /** Unpack the declared number of values
  65      * REMINDER: it is possible that the buffer is corrupted and that
  66      * the BFROP will *think* there is a proper int32_t variable at the
  67      * beginning of the unpack region - but that the value is bogus (e.g., just
  68      * a byte field in a string array that so happens to have a value that
  69      * matches the int32_t data type flag). Therefore, this error check is
  70      * NOT completely safe. This is true for ALL unpack functions, not just
  71      * int32_t as used here.
  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             /* don't error log here as the user may be unpacking past
  77              * the end of the buffer, which isn't necessarily an error */
  78             return rc;
  79         }
  80         if (PMIX_INT32 != local_type) { /* if the length wasn't first, then error */
  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         /* don't error log here as the user may be unpacking past
  91          * the end of the buffer, which isn't necessarily an error */
  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     /** if the storage provided is inadequate, set things up
 101      * to unpack as much as we can and to return an error code
 102      * indicating that everything was not unpacked - the buffer
 103      * is left in a state where it can not be further unpacked.
 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 {  /** enough or more than enough storage */
 112         *num_vals = local_num;  /** let the user know how many we actually unpacked */
 113         ret = PMIX_SUCCESS;
 114     }
 115 
 116     /** Unpack the value(s) */
 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     /* some v1 types are simply declared differently */
 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     /** Unpack the declared data type */
 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         /* if the data types don't match, then return an error */
 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 /* UNPACK GENERIC SYSTEM TYPES */
 174 
 175 /*
 176  * BOOL
 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     /* check to see if there's enough data in buffer */
 188     if (pmix_bfrop_too_small(buffer, *num_vals)) {
 189         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 190     }
 191 
 192     /* unpack the data */
 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     /* update buffer pointer */
 205     buffer->unpack_ptr += *num_vals;
 206 
 207     return PMIX_SUCCESS;
 208 }
 209 
 210 /*
 211  * INT
 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         /* fast path it if the sizes are the same */
 226         /* Turn around and unpack the real type */
 227         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_INT))) {
 228         }
 229     } else {
 230         /* slow path - types are different sizes */
 231         PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, int, remote_type, ret);
 232     }
 233 
 234     return ret;
 235 }
 236 
 237 /*
 238  * SIZE_T
 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         /* fast path it if the sizes are the same */
 253         /* Turn around and unpack the real type */
 254         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_SIZE_T))) {
 255         }
 256     } else {
 257         /* slow path - types are different sizes */
 258         PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, size_t, remote_type, ret);
 259     }
 260 
 261     return ret;
 262 }
 263 
 264 /*
 265  * PID_T
 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         /* fast path it if the sizes are the same */
 280         /* Turn around and unpack the real type */
 281         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_buffer(regtypes, buffer, dest, num_vals, BFROP_TYPE_PID_T))) {
 282         }
 283     } else {
 284         /* slow path - types are different sizes */
 285         PMIX_BFROP_UNPACK_SIZE_MISMATCH(regtypes, pid_t, remote_type, ret);
 286     }
 287 
 288     return ret;
 289 }
 290 
 291 
 292 /* UNPACK FUNCTIONS FOR NON-GENERIC SYSTEM TYPES */
 293 
 294 /*
 295  * BYTE, CHAR, INT8
 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     /* check to see if there's enough data in buffer */
 303     if (pmix_bfrop_too_small(buffer, *num_vals)) {
 304         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 305     }
 306 
 307     /* unpack the data */
 308     memcpy(dest, buffer->unpack_ptr, *num_vals);
 309 
 310     /* update buffer pointer */
 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     /* check to see if there's enough data in buffer */
 325     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 326         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 327     }
 328 
 329     /* unpack the data */
 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     /* check to see if there's enough data in buffer */
 349     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 350         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 351     }
 352 
 353     /* unpack the data */
 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     /* check to see if there's enough data in buffer */
 381     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 382         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 383     }
 384 
 385     /* unpack the data */
 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) {   /* zero-length string - unpack the NULL */
 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     /* check to see if there's enough data in buffer */
 439     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(float))) {
 440         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 441     }
 442 
 443     /* unpack the data */
 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     /* check to see if there's enough data in buffer */
 472     if (pmix_bfrop_too_small(buffer, (*num_vals)*sizeof(double))) {
 473         return PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 474     }
 475 
 476     /* unpack the data */
 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     /* check to see if there's enough data in buffer */
 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     /* unpack the data */
 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     /* time_t is a system-dependent size, so cast it
 534      * to uint64_t as a generic safe size
 535      */
 536 
 537     pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
 538                         "pmix12_bfrop_unpack_time * %d\n", (int)*num_vals);
 539     /* check to see if there's enough data in buffer */
 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     /* unpack the data */
 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 /* UNPACK FUNCTIONS FOR GENERIC PMIX TYPES */
 559 
 560 /*
 561  * PMIX_VALUE
 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         /* we don't know anything about info array's so we
 663          * have to convert this to a data array */
 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         /* unpack into it */
 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         /* unpack the type */
 699         m=1;
 700         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
 701             return ret;
 702         }
 703         /* convert the type - unfortunately, v1.2 directly packed the int instead of
 704          * using the store_data_type function. This means we lose the translation!
 705          * So get it here */
 706         ptr[i].type = pmix12_v1_to_v2_datatype(v1type);
 707         /* unpack value */
 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         /* unpack key */
 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         /* unpack value - since the value structure is statically-defined
 746          * instead of a pointer in this struct, we directly unpack it to
 747          * avoid the malloc */
 748         m=1;
 749         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
 750             return ret;
 751         }
 752         /* convert the type - unfortunately, v1.2 directly packed the int instead of
 753          * using the store_data_type function. This means we lose the translation!
 754          * So get it here */
 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         /* unpack the proc */
 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         /* unpack key */
 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         /* unpack value - since the value structure is statically-defined
 801          * instead of a pointer in this struct, we directly unpack it to
 802          * avoid the malloc */
 803         m=1;
 804         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &v1type, &m, PMIX_INT))) {
 805             return ret;
 806         }
 807         /* convert the type - unfortunately, v1.2 directly packed the int instead of
 808          * using the store_data_type function. This means we lose the translation!
 809          * So get it here */
 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         /* unpack the number of bytes */
 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         /* setup the buffer's data region */
 841         if (0 < nbytes) {
 842             ptr[i].base_ptr = (char*)malloc(nbytes);
 843             /* unpack the bytes */
 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         /* unpack nspace */
 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         /* unpack the rank */
 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         /* we have to do some conversion here as the definition of rank
 892          * changed from INT32 to UINT32 */
 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         /* initialize the fields */
 921         PMIX_APP_CONSTRUCT(&ptr[i]);
 922         /* unpack cmd */
 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         /* unpack argc */
 928         m=1;
 929         if (PMIX_SUCCESS != (ret = pmix12_bfrop_unpack_int(regtypes, buffer, &argc, &m, PMIX_INT))) {
 930             return ret;
 931         }
 932         /* unpack argv */
 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         /* unpack env */
 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         /* unpack maxprocs */
 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         /* unpack info array */
 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         /* unpack the key */
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         /* allocate the space */
1006         ptr[i].value = (pmix_value_t*)malloc(sizeof(pmix_value_t));
1007         /* unpack the value */
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         /* unpack the size of this array */
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         /* unpack the number of bytes */
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         /* unpack the number of bytes */
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 }
/* [<][>][^][v][top][bottom][index][help] */
root/opal/mca/pmix/pmix4x/pmix/src/mca/bfrops/v12/unpack.c

DEFINITIONS
