This source file includes following definitions.
- opal_dss_unpack
- opal_dss_unpack_buffer
- opal_dss_unpack_bool
- opal_dss_unpack_int
- opal_dss_unpack_sizet
- opal_dss_unpack_pid
- opal_dss_unpack_null
- opal_dss_unpack_byte
- opal_dss_unpack_int16
- opal_dss_unpack_int32
- opal_dss_unpack_int64
- opal_dss_unpack_string
- opal_dss_unpack_float
- opal_dss_unpack_double
- opal_dss_unpack_timeval
- opal_dss_unpack_time
- opal_dss_unpack_data_type
- opal_dss_unpack_byte_object
- opal_dss_unpack_pstat
- unpack_disk_stats
- unpack_net_stats
- opal_dss_unpack_node_stat
- opal_dss_unpack_value
- opal_dss_unpack_buffer_contents
- opal_dss_unpack_name
- opal_dss_unpack_jobid
- opal_dss_unpack_vpid
- opal_dss_unpack_status
- opal_dss_unpack_envar
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 
  18 
  19 
  20 
  21 
  22 
  23 
  24 #include "opal_config.h"
  25 #include "opal/types.h"
  26 #include "opal/util/error.h"
  27 #include "opal/util/output.h"
  28 #include "opal/dss/dss_internal.h"
  29 
  30 int opal_dss_unpack(opal_buffer_t *buffer, void *dst, int32_t *num_vals,
  31                     opal_data_type_t type)
  32 {
  33     int rc, ret;
  34     int32_t local_num, n=1;
  35     opal_data_type_t local_type;
  36 
  37     
  38     if (NULL == buffer || NULL == dst || NULL == num_vals) {
  39         return OPAL_ERR_BAD_PARAM;
  40     }
  41 
  42     
  43 
  44 
  45     if (0 == *num_vals) {
  46         OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack: inadequate space ( %p, %p, %lu, %d )\n",
  47                        (void*)buffer, dst, (long unsigned int)*num_vals, (int)type ) );
  48         return OPAL_ERR_UNPACK_INADEQUATE_SPACE;
  49     }
  50 
  51     
  52 
  53 
  54 
  55 
  56 
  57 
  58 
  59 
  60     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
  61         if (OPAL_SUCCESS != (
  62             rc = opal_dss_get_data_type(buffer, &local_type))) {
  63             *num_vals = 0;
  64             return rc;
  65         }
  66         if (OPAL_INT32 != local_type) { 
  67             *num_vals = 0;
  68             return OPAL_ERR_UNPACK_FAILURE;
  69         }
  70     }
  71 
  72     n=1;
  73     if (OPAL_SUCCESS != (rc = opal_dss_unpack_int32(buffer, &local_num, &n, OPAL_INT32))) {
  74         *num_vals = 0;
  75         return rc;
  76     }
  77 
  78     
  79 
  80 
  81 
  82 
  83     if (local_num > *num_vals) {
  84         local_num = *num_vals;
  85         OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack: inadequate space ( %p, %p, %lu, %d )\n",
  86                        (void*)buffer, dst, (long unsigned int)*num_vals, (int)type ) );
  87         ret = OPAL_ERR_UNPACK_INADEQUATE_SPACE;
  88     } else {  
  89         *num_vals = local_num;  
  90         ret = OPAL_SUCCESS;
  91     }
  92 
  93     
  94     if (OPAL_SUCCESS != (rc = opal_dss_unpack_buffer(buffer, dst, &local_num, type))) {
  95         *num_vals = 0;
  96         ret = rc;
  97     }
  98 
  99     return ret;
 100 }
 101 
 102 int opal_dss_unpack_buffer(opal_buffer_t *buffer, void *dst, int32_t *num_vals,
 103                     opal_data_type_t type)
 104 {
 105     int rc;
 106     opal_data_type_t local_type;
 107     opal_dss_type_info_t *info;
 108 
 109     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_buffer( %p, %p, %lu, %d )\n",
 110                    (void*)buffer, dst, (long unsigned int)*num_vals, (int)type ) );
 111 
 112     
 113     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
 114         if (OPAL_SUCCESS != (rc = opal_dss_get_data_type(buffer, &local_type))) {
 115             return rc;
 116         }
 117         
 118         if (type != local_type) {
 119             opal_output(0, "OPAL dss:unpack: got type %d when expecting type %d", local_type, type);
 120             return OPAL_ERR_PACK_MISMATCH;
 121         }
 122     }
 123 
 124     
 125 
 126     if (NULL == (info = (opal_dss_type_info_t*)opal_pointer_array_get_item(&opal_dss_types, type))) {
 127         return OPAL_ERR_UNPACK_FAILURE;
 128     }
 129 
 130     return info->odti_unpack_fn(buffer, dst, num_vals, type);
 131 }
 132 
 133 
 134 
 135 
 136 
 137 
 138 
 139 int opal_dss_unpack_bool(opal_buffer_t *buffer, void *dest,
 140                          int32_t *num_vals, opal_data_type_t type)
 141 {
 142     int ret;
 143     opal_data_type_t remote_type;
 144 
 145     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
 146         
 147         if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
 148             return ret;
 149         }
 150     } else {
 151         if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
 152             return ret;
 153         }
 154     }
 155 
 156     if (remote_type == DSS_TYPE_BOOL) {
 157         
 158         
 159         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_BOOL))) {
 160         }
 161     } else {
 162         
 163         UNPACK_SIZE_MISMATCH(bool, remote_type, ret);
 164     }
 165     return ret;
 166 }
 167 
 168 
 169 
 170 
 171 int opal_dss_unpack_int(opal_buffer_t *buffer, void *dest,
 172                         int32_t *num_vals, opal_data_type_t type)
 173 {
 174     int ret;
 175     opal_data_type_t remote_type;
 176 
 177     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
 178         
 179         if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
 180             return ret;
 181         }
 182     } else {
 183         if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
 184             return ret;
 185         }
 186     }
 187 
 188     if (remote_type == DSS_TYPE_INT) {
 189         
 190         
 191         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_INT))) {
 192         }
 193     } else {
 194         
 195         UNPACK_SIZE_MISMATCH(int, remote_type, ret);
 196     }
 197 
 198     return ret;
 199 }
 200 
 201 
 202 
 203 
 204 int opal_dss_unpack_sizet(opal_buffer_t *buffer, void *dest,
 205                           int32_t *num_vals, opal_data_type_t type)
 206 {
 207     int ret;
 208     opal_data_type_t remote_type;
 209 
 210     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
 211         
 212         if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
 213             return ret;
 214         }
 215     } else {
 216         if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
 217             return ret;
 218         }
 219     }
 220 
 221     if (remote_type == DSS_TYPE_SIZE_T) {
 222         
 223         
 224         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_SIZE_T))) {
 225         }
 226     } else {
 227         
 228         UNPACK_SIZE_MISMATCH(size_t, remote_type, ret);
 229     }
 230 
 231     return ret;
 232 }
 233 
 234 
 235 
 236 
 237 int opal_dss_unpack_pid(opal_buffer_t *buffer, void *dest,
 238                         int32_t *num_vals, opal_data_type_t type)
 239 {
 240     int ret;
 241     opal_data_type_t remote_type;
 242 
 243     if (OPAL_DSS_BUFFER_FULLY_DESC == buffer->type) {
 244         
 245         if (OPAL_SUCCESS != (ret = opal_dss_peek_type(buffer, &remote_type))) {
 246             return ret;
 247         }
 248     } else {
 249         if (OPAL_SUCCESS != (ret = opal_dss_get_data_type(buffer, &remote_type))) {
 250             return ret;
 251         }
 252     }
 253 
 254     if (remote_type == DSS_TYPE_PID_T) {
 255         
 256         
 257         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, DSS_TYPE_PID_T))) {
 258         }
 259     } else {
 260         
 261         UNPACK_SIZE_MISMATCH(pid_t, remote_type, ret);
 262     }
 263 
 264     return ret;
 265 }
 266 
 267 
 268 
 269 
 270 
 271 
 272 
 273 int opal_dss_unpack_null(opal_buffer_t *buffer, void *dest,
 274                          int32_t *num_vals, opal_data_type_t type)
 275 {
 276     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_null * %d\n", (int)*num_vals ) );
 277     
 278     if (opal_dss_too_small(buffer, *num_vals)) {
 279         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 280     }
 281 
 282     
 283     memcpy(dest, buffer->unpack_ptr, *num_vals);
 284 
 285     
 286     buffer->unpack_ptr += *num_vals;
 287 
 288     return OPAL_SUCCESS;
 289 }
 290 
 291 
 292 
 293 
 294 int opal_dss_unpack_byte(opal_buffer_t *buffer, void *dest,
 295                          int32_t *num_vals, opal_data_type_t type)
 296 {
 297     OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_byte * %d\n", (int)*num_vals ) );
 298     
 299     if (opal_dss_too_small(buffer, *num_vals)) {
 300         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 301     }
 302 
 303     
 304     memcpy(dest, buffer->unpack_ptr, *num_vals);
 305 
 306     
 307     buffer->unpack_ptr += *num_vals;
 308 
 309     return OPAL_SUCCESS;
 310 }
 311 
 312 int opal_dss_unpack_int16(opal_buffer_t *buffer, void *dest,
 313                           int32_t *num_vals, opal_data_type_t type)
 314 {
 315     int32_t i;
 316     uint16_t tmp, *desttmp = (uint16_t*) dest;
 317 
 318    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_int16 * %d\n", (int)*num_vals ) );
 319     
 320     if (opal_dss_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 321         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 322     }
 323 
 324     
 325     for (i = 0; i < (*num_vals); ++i) {
 326         memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
 327         tmp = ntohs(tmp);
 328         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 329         buffer->unpack_ptr += sizeof(tmp);
 330     }
 331 
 332     return OPAL_SUCCESS;
 333 }
 334 
 335 int opal_dss_unpack_int32(opal_buffer_t *buffer, void *dest,
 336                           int32_t *num_vals, opal_data_type_t type)
 337 {
 338     int32_t i;
 339     uint32_t tmp, *desttmp = (uint32_t*) dest;
 340 
 341    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_int32 * %d\n", (int)*num_vals ) );
 342     
 343     if (opal_dss_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 344         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 345     }
 346 
 347     
 348     for (i = 0; i < (*num_vals); ++i) {
 349         memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
 350         tmp = ntohl(tmp);
 351         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 352         buffer->unpack_ptr += sizeof(tmp);
 353     }
 354 
 355     return OPAL_SUCCESS;
 356 }
 357 
 358 int opal_dss_unpack_int64(opal_buffer_t *buffer, void *dest,
 359                           int32_t *num_vals, opal_data_type_t type)
 360 {
 361     int32_t i;
 362     uint64_t tmp, *desttmp = (uint64_t*) dest;
 363 
 364    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_int64 * %d\n", (int)*num_vals ) );
 365     
 366     if (opal_dss_too_small(buffer, (*num_vals)*sizeof(tmp))) {
 367         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 368     }
 369 
 370     
 371     for (i = 0; i < (*num_vals); ++i) {
 372         memcpy( &(tmp), buffer->unpack_ptr, sizeof(tmp) );
 373         tmp = ntoh64(tmp);
 374         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 375         buffer->unpack_ptr += sizeof(tmp);
 376     }
 377 
 378     return OPAL_SUCCESS;
 379 }
 380 
 381 int opal_dss_unpack_string(opal_buffer_t *buffer, void *dest,
 382                            int32_t *num_vals, opal_data_type_t type)
 383 {
 384     int ret;
 385     int32_t i, len, n=1;
 386     char **sdest = (char**) dest;
 387 
 388     for (i = 0; i < (*num_vals); ++i) {
 389         if (OPAL_SUCCESS != (ret = opal_dss_unpack_int32(buffer, &len, &n, OPAL_INT32))) {
 390             return ret;
 391         }
 392         if (0 ==  len) {   
 393             sdest[i] = NULL;
 394         } else {
 395         sdest[i] = (char*)malloc(len);
 396             if (NULL == sdest[i]) {
 397                 return OPAL_ERR_OUT_OF_RESOURCE;
 398             }
 399             if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, sdest[i], &len, OPAL_BYTE))) {
 400                 return ret;
 401             }
 402         }
 403     }
 404 
 405     return OPAL_SUCCESS;
 406 }
 407 
 408 int opal_dss_unpack_float(opal_buffer_t *buffer, void *dest,
 409                           int32_t *num_vals, opal_data_type_t type)
 410 {
 411     int32_t i, n;
 412     float *desttmp = (float*) dest, tmp;
 413     int ret;
 414     char *convert;
 415 
 416    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_float * %d\n", (int)*num_vals ) );
 417     
 418     if (opal_dss_too_small(buffer, (*num_vals)*sizeof(float))) {
 419         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 420     }
 421 
 422     
 423     for (i = 0; i < (*num_vals); ++i) {
 424         n=1;
 425         if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &convert, &n, OPAL_STRING))) {
 426             return ret;
 427         }
 428         if (NULL == convert) {
 429             return OPAL_ERR_UNPACK_FAILURE;
 430         }
 431         tmp = strtof(convert, NULL);
 432         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 433         free(convert);
 434         convert = NULL;
 435     }
 436     return OPAL_SUCCESS;
 437 }
 438 
 439 int opal_dss_unpack_double(opal_buffer_t *buffer, void *dest,
 440                            int32_t *num_vals, opal_data_type_t type)
 441 {
 442     int32_t i, n;
 443     double *desttmp = (double*) dest, tmp;
 444     int ret;
 445     char *convert;
 446 
 447    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_double * %d\n", (int)*num_vals ) );
 448     
 449     if (opal_dss_too_small(buffer, (*num_vals)*sizeof(double))) {
 450         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 451     }
 452 
 453     
 454     for (i = 0; i < (*num_vals); ++i) {
 455         n=1;
 456         if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &convert, &n, OPAL_STRING))) {
 457             return ret;
 458         }
 459         if (NULL == convert) {
 460             return OPAL_ERR_UNPACK_FAILURE;
 461         }
 462         tmp = strtod(convert, NULL);
 463         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 464         free(convert);
 465         convert = NULL;
 466     }
 467     return OPAL_SUCCESS;
 468 }
 469 
 470 int opal_dss_unpack_timeval(opal_buffer_t *buffer, void *dest,
 471                             int32_t *num_vals, opal_data_type_t type)
 472 {
 473     int32_t i, n;
 474     int64_t tmp[2];
 475     struct timeval *desttmp = (struct timeval *) dest, tt;
 476     int ret;
 477 
 478    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_timeval * %d\n", (int)*num_vals ) );
 479     
 480     if (opal_dss_too_small(buffer, (*num_vals)*sizeof(struct timeval))) {
 481         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 482     }
 483 
 484     
 485     for (i = 0; i < (*num_vals); ++i) {
 486         n=2;
 487         if (OPAL_SUCCESS != (ret = opal_dss_unpack_int64(buffer, tmp, &n, OPAL_INT64))) {
 488             return ret;
 489         }
 490         tt.tv_sec = tmp[0];
 491         tt.tv_usec = tmp[1];
 492         memcpy(&desttmp[i], &tt, sizeof(tt));
 493     }
 494     return OPAL_SUCCESS;
 495 }
 496 
 497 int opal_dss_unpack_time(opal_buffer_t *buffer, void *dest,
 498                          int32_t *num_vals, opal_data_type_t type)
 499 {
 500     int32_t i, n;
 501     time_t *desttmp = (time_t *) dest, tmp;
 502     int ret;
 503     uint64_t ui64;
 504 
 505     
 506 
 507 
 508 
 509    OPAL_OUTPUT( ( opal_dss_verbose, "opal_dss_unpack_time * %d\n", (int)*num_vals ) );
 510     
 511    if (opal_dss_too_small(buffer, (*num_vals)*(sizeof(uint64_t)))) {
 512         return OPAL_ERR_UNPACK_READ_PAST_END_OF_BUFFER;
 513     }
 514 
 515     
 516     for (i = 0; i < (*num_vals); ++i) {
 517         n=1;
 518         if (OPAL_SUCCESS != (ret = opal_dss_unpack_int64(buffer, &ui64, &n, OPAL_UINT64))) {
 519             return ret;
 520         }
 521         tmp = (time_t)ui64;
 522         memcpy(&desttmp[i], &tmp, sizeof(tmp));
 523     }
 524     return OPAL_SUCCESS;
 525 }
 526 
 527 
 528 
 529 
 530 
 531 
 532 
 533 int opal_dss_unpack_data_type(opal_buffer_t *buffer, void *dest, int32_t *num_vals,
 534                              opal_data_type_t type)
 535 {
 536      
 537     return opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_DATA_TYPE_T);
 538 }
 539 
 540 
 541 
 542 
 543 int opal_dss_unpack_byte_object(opal_buffer_t *buffer, void *dest, int32_t *num,
 544                              opal_data_type_t type)
 545 {
 546     int ret;
 547     int32_t i, n, m=1;
 548     opal_byte_object_t **dbyteptr;
 549 
 550     dbyteptr = (opal_byte_object_t**)dest;
 551     n = *num;
 552     for(i=0; i<n; i++) {
 553         
 554         dbyteptr[i] = (opal_byte_object_t*)malloc(sizeof(opal_byte_object_t));
 555         if (NULL == dbyteptr[i]) {
 556             return OPAL_ERR_OUT_OF_RESOURCE;
 557         }
 558 
 559         
 560         if (OPAL_SUCCESS != (ret = opal_dss_unpack_int32(buffer, &(dbyteptr[i]->size), &m, OPAL_INT32))) {
 561             return ret;
 562         }
 563         if (0 < dbyteptr[i]->size) {
 564             dbyteptr[i]->bytes = (uint8_t*)malloc(dbyteptr[i]->size);
 565             if (NULL == dbyteptr[i]->bytes) {
 566                 return OPAL_ERR_OUT_OF_RESOURCE;
 567             }
 568             if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, (dbyteptr[i]->bytes),
 569                                             &(dbyteptr[i]->size), OPAL_BYTE))) {
 570                 return ret;
 571             }
 572         } else {
 573             
 574             dbyteptr[i]->bytes = NULL;
 575         }
 576     }
 577 
 578     return OPAL_SUCCESS;
 579 }
 580 
 581 
 582 
 583 
 584 int opal_dss_unpack_pstat(opal_buffer_t *buffer, void *dest,
 585                           int32_t *num_vals, opal_data_type_t type)
 586 {
 587     opal_pstats_t **ptr;
 588     int32_t i, n, m;
 589     int ret;
 590     char *cptr;
 591 
 592     ptr = (opal_pstats_t **) dest;
 593     n = *num_vals;
 594 
 595     for (i = 0; i < n; ++i) {
 596         
 597         ptr[i] = OBJ_NEW(opal_pstats_t);
 598         if (NULL == ptr[i]) {
 599             return OPAL_ERR_OUT_OF_RESOURCE;
 600         }
 601         m=1;
 602         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &cptr, &m, OPAL_STRING))) {
 603             OPAL_ERROR_LOG(ret);
 604             return ret;
 605         }
 606         memmove(ptr[i]->node, cptr, strlen(cptr));
 607         free(cptr);
 608         m=1;
 609         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->rank, &m, OPAL_INT32))) {
 610             OPAL_ERROR_LOG(ret);
 611             return ret;
 612         }
 613         m=1;
 614         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->pid, &m, OPAL_PID))) {
 615             OPAL_ERROR_LOG(ret);
 616             return ret;
 617         }
 618         m=1;
 619         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &cptr, &m, OPAL_STRING))) {
 620             OPAL_ERROR_LOG(ret);
 621             return ret;
 622         }
 623         memmove(ptr[i]->cmd, cptr, strlen(cptr));
 624         free(cptr);
 625         m=1;
 626         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->state[0], &m, OPAL_BYTE))) {
 627             OPAL_ERROR_LOG(ret);
 628             return ret;
 629         }
 630         m=1;
 631         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->time, &m, OPAL_TIMEVAL))) {
 632             OPAL_ERROR_LOG(ret);
 633             return ret;
 634         }
 635         m=1;
 636         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->priority, &m, OPAL_INT32))) {
 637             OPAL_ERROR_LOG(ret);
 638             return ret;
 639         }
 640         m=1;
 641         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->num_threads, &m, OPAL_INT16))) {
 642             OPAL_ERROR_LOG(ret);
 643             return ret;
 644         }
 645         m=1;
 646         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->pss, &m, OPAL_FLOAT))) {
 647             OPAL_ERROR_LOG(ret);
 648             return ret;
 649         }
 650         m=1;
 651         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->vsize, &m, OPAL_FLOAT))) {
 652             OPAL_ERROR_LOG(ret);
 653             return ret;
 654         }
 655         m=1;
 656         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->rss, &m, OPAL_FLOAT))) {
 657             OPAL_ERROR_LOG(ret);
 658             return ret;
 659         }
 660         m=1;
 661         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->peak_vsize, &m, OPAL_FLOAT))) {
 662             OPAL_ERROR_LOG(ret);
 663             return ret;
 664         }
 665         m=1;
 666         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->processor, &m, OPAL_INT16))) {
 667             OPAL_ERROR_LOG(ret);
 668             return ret;
 669         }
 670         m=1;
 671         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->sample_time, &m, OPAL_TIMEVAL))) {
 672             OPAL_ERROR_LOG(ret);
 673             return ret;
 674         }
 675     }
 676 
 677     return OPAL_SUCCESS;
 678 }
 679 
 680 static int unpack_disk_stats(opal_buffer_t *buffer, opal_node_stats_t *ns)
 681 {
 682     int32_t i, m, n;
 683     int ret;
 684     opal_diskstats_t *dk;
 685     uint64_t i64;
 686 
 687     
 688     m=1;
 689     if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &n, &m, OPAL_INT32))) {
 690         OPAL_ERROR_LOG(ret);
 691         return ret;
 692     }
 693     
 694     for (i=0; i < n; i++) {
 695         dk = OBJ_NEW(opal_diskstats_t);
 696         assert(dk);
 697         m=1;
 698         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &dk->disk, &m, OPAL_STRING))) {
 699             OPAL_ERROR_LOG(ret);
 700             OBJ_RELEASE(dk);
 701             return ret;
 702         }
 703         m=1;
 704         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 705             OPAL_ERROR_LOG(ret);
 706             OBJ_RELEASE(dk);
 707             return ret;
 708         }
 709         dk->num_reads_completed = i64;
 710         m=1;
 711         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 712             OPAL_ERROR_LOG(ret);
 713             OBJ_RELEASE(dk);
 714             return ret;
 715         }
 716         dk->num_reads_merged = i64;
 717         m=1;
 718         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 719             OPAL_ERROR_LOG(ret);
 720             OBJ_RELEASE(dk);
 721             return ret;
 722         }
 723         dk->num_sectors_read = i64;
 724         m=1;
 725         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 726             OPAL_ERROR_LOG(ret);
 727             OBJ_RELEASE(dk);
 728             return ret;
 729         }
 730         dk->milliseconds_reading = i64;
 731         m=1;
 732         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 733             OPAL_ERROR_LOG(ret);
 734             OBJ_RELEASE(dk);
 735             return ret;
 736         }
 737         dk->num_writes_completed = i64;
 738         m=1;
 739         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 740             OPAL_ERROR_LOG(ret);
 741             OBJ_RELEASE(dk);
 742             return ret;
 743         }
 744         dk->num_writes_merged = i64;
 745         m=1;
 746         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 747             OPAL_ERROR_LOG(ret);
 748             OBJ_RELEASE(dk);
 749             return ret;
 750         }
 751         dk->num_sectors_written = i64;
 752         m=1;
 753         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 754             OPAL_ERROR_LOG(ret);
 755             OBJ_RELEASE(dk);
 756             return ret;
 757         }
 758         dk->milliseconds_writing = i64;
 759         m=1;
 760         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 761             OPAL_ERROR_LOG(ret);
 762             OBJ_RELEASE(dk);
 763             return ret;
 764         }
 765         dk->num_ios_in_progress = i64;
 766         m=1;
 767         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 768             OPAL_ERROR_LOG(ret);
 769             OBJ_RELEASE(dk);
 770             return ret;
 771         }
 772         dk->milliseconds_io = i64;
 773         m=1;
 774         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 775             OPAL_ERROR_LOG(ret);
 776             OBJ_RELEASE(dk);
 777             return ret;
 778         }
 779         dk->weighted_milliseconds_io = i64;
 780         opal_list_append(&ns->diskstats, &dk->super);
 781     }
 782     return OPAL_SUCCESS;
 783 }
 784 
 785 static int unpack_net_stats(opal_buffer_t *buffer, opal_node_stats_t *ns)
 786 {
 787     int32_t i, m, n;
 788     int ret;
 789     opal_netstats_t *net;
 790     uint64_t i64;
 791 
 792     
 793     m=1;
 794     if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &n, &m, OPAL_INT32))) {
 795         OPAL_ERROR_LOG(ret);
 796         return ret;
 797     }
 798     
 799     for (i=0; i < n; i++) {
 800         net = OBJ_NEW(opal_netstats_t);
 801         assert(net);
 802         m=1;
 803         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &net->net_interface, &m, OPAL_STRING))) {
 804             OPAL_ERROR_LOG(ret);
 805             OBJ_RELEASE(net);
 806             return ret;
 807         }
 808         m=1;
 809         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 810             OPAL_ERROR_LOG(ret);
 811             OBJ_RELEASE(net);
 812             return ret;
 813         }
 814         net->num_bytes_recvd = i64;
 815         m=1;
 816         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 817             OPAL_ERROR_LOG(ret);
 818             OBJ_RELEASE(net);
 819             return ret;
 820         }
 821         net->num_packets_recvd = i64;
 822         m=1;
 823         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 824             OPAL_ERROR_LOG(ret);
 825             OBJ_RELEASE(net);
 826             return ret;
 827         }
 828         net->num_recv_errs = i64;
 829         m=1;
 830         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 831             OPAL_ERROR_LOG(ret);
 832             OBJ_RELEASE(net);
 833             return ret;
 834         }
 835         net->num_bytes_sent = i64;
 836         m=1;
 837         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 838             OPAL_ERROR_LOG(ret);
 839             OBJ_RELEASE(net);
 840             return ret;
 841         }
 842         net->num_packets_sent = i64;
 843         m=1;
 844         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &i64, &m, OPAL_UINT64))) {
 845             OPAL_ERROR_LOG(ret);
 846             OBJ_RELEASE(net);
 847             return ret;
 848         }
 849         net->num_send_errs = i64;
 850         opal_list_append(&ns->netstats, &net->super);
 851     }
 852     return OPAL_SUCCESS;
 853 }
 854 
 855 
 856 
 857 
 858 int opal_dss_unpack_node_stat(opal_buffer_t *buffer, void *dest,
 859                               int32_t *num_vals, opal_data_type_t type)
 860 {
 861     opal_node_stats_t **ptr;
 862     int32_t i, n, m;
 863     int ret;
 864 
 865     ptr = (opal_node_stats_t **) dest;
 866     n = *num_vals;
 867 
 868     for (i = 0; i < n; ++i) {
 869         
 870         ptr[i] = OBJ_NEW(opal_node_stats_t);
 871         if (NULL == ptr[i]) {
 872             return OPAL_ERR_OUT_OF_RESOURCE;
 873         }
 874         m=1;
 875         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->la, &m, OPAL_FLOAT))) {
 876             OPAL_ERROR_LOG(ret);
 877             return ret;
 878         }
 879         m=1;
 880         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->la5, &m, OPAL_FLOAT))) {
 881             OPAL_ERROR_LOG(ret);
 882             return ret;
 883         }
 884         m=1;
 885         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->la15, &m, OPAL_FLOAT))) {
 886             OPAL_ERROR_LOG(ret);
 887             return ret;
 888         }
 889         m=1;
 890         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->total_mem, &m, OPAL_FLOAT))) {
 891             OPAL_ERROR_LOG(ret);
 892             return ret;
 893         }
 894         m=1;
 895         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->free_mem, &m, OPAL_FLOAT))) {
 896             OPAL_ERROR_LOG(ret);
 897             return ret;
 898         }
 899         m=1;
 900         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->buffers, &m, OPAL_FLOAT))) {
 901             OPAL_ERROR_LOG(ret);
 902             return ret;
 903         }
 904         m=1;
 905         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->cached, &m, OPAL_FLOAT))) {
 906             OPAL_ERROR_LOG(ret);
 907             return ret;
 908         }
 909         m=1;
 910         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->swap_cached, &m, OPAL_FLOAT))) {
 911             OPAL_ERROR_LOG(ret);
 912             return ret;
 913         }
 914         m=1;
 915         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->swap_total, &m, OPAL_FLOAT))) {
 916             OPAL_ERROR_LOG(ret);
 917             return ret;
 918         }
 919         m=1;
 920         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->swap_free, &m, OPAL_FLOAT))) {
 921             OPAL_ERROR_LOG(ret);
 922             return ret;
 923         }
 924         m=1;
 925         if (OPAL_SUCCESS != (ret = opal_dss_unpack_float(buffer, &ptr[i]->mapped, &m, OPAL_FLOAT))) {
 926             OPAL_ERROR_LOG(ret);
 927             return ret;
 928         }
 929         m=1;
 930         if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->sample_time, &m, OPAL_TIMEVAL))) {
 931             OPAL_ERROR_LOG(ret);
 932             return ret;
 933         }
 934         
 935         if (OPAL_SUCCESS != (ret = unpack_disk_stats(buffer, ptr[i]))) {
 936             OPAL_ERROR_LOG(ret);
 937             return ret;
 938         }
 939         
 940         if (OPAL_SUCCESS != (ret = unpack_net_stats(buffer, ptr[i]))) {
 941             OPAL_ERROR_LOG(ret);
 942             return ret;
 943         }
 944         OBJ_RELEASE(ptr[i]);
 945     }
 946 
 947     return OPAL_SUCCESS;
 948 }
 949 
 950 
 951 
 952 
 953 int opal_dss_unpack_value(opal_buffer_t *buffer, void *dest,
 954                           int32_t *num_vals, opal_data_type_t type)
 955 {
 956     opal_value_t **ptr;
 957     int32_t i, n, m;
 958     int ret;
 959 
 960     ptr = (opal_value_t **) dest;
 961     n = *num_vals;
 962 
 963     for (i = 0; i < n; ++i) {
 964         
 965         ptr[i] = OBJ_NEW(opal_value_t);
 966         if (NULL == ptr[i]) {
 967             return OPAL_ERR_OUT_OF_RESOURCE;
 968         }
 969         
 970         m=1;
 971         if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &ptr[i]->key, &m, OPAL_STRING))) {
 972             return ret;
 973         }
 974         m=1;
 975         if (OPAL_SUCCESS != (ret = opal_dss_unpack_data_type(buffer, &ptr[i]->type, &m, OPAL_DATA_TYPE))) {
 976             return ret;
 977         }
 978         
 979         m=1;
 980         switch (ptr[i]->type) {
 981         case OPAL_BOOL:
 982             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.flag, &m, OPAL_BOOL))) {
 983                 return ret;
 984             }
 985             break;
 986         case OPAL_BYTE:
 987             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.byte, &m, OPAL_BYTE))) {
 988                 return ret;
 989             }
 990             break;
 991         case OPAL_STRING:
 992             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.string, &m, OPAL_STRING))) {
 993                 return ret;
 994             }
 995             break;
 996         case OPAL_SIZE:
 997             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.size, &m, OPAL_SIZE))) {
 998                 return ret;
 999             }
1000             break;
1001         case OPAL_PID:
1002             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.pid, &m, OPAL_PID))) {
1003                 return ret;
1004             }
1005             break;
1006         case OPAL_INT:
1007             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.integer, &m, OPAL_INT))) {
1008                 return ret;
1009             }
1010             break;
1011         case OPAL_INT8:
1012             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int8, &m, OPAL_INT8))) {
1013                 return ret;
1014             }
1015             break;
1016         case OPAL_INT16:
1017             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int16, &m, OPAL_INT16))) {
1018                 return ret;
1019             }
1020             break;
1021         case OPAL_INT32:
1022             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int32, &m, OPAL_INT32))) {
1023                 return ret;
1024             }
1025             break;
1026         case OPAL_INT64:
1027             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.int64, &m, OPAL_INT64))) {
1028                 return ret;
1029             }
1030             break;
1031         case OPAL_UINT:
1032             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint, &m, OPAL_UINT))) {
1033                 return ret;
1034             }
1035             break;
1036         case OPAL_UINT8:
1037             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint8, &m, OPAL_UINT8))) {
1038                 return ret;
1039             }
1040             break;
1041         case OPAL_UINT16:
1042             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint16, &m, OPAL_UINT16))) {
1043                 return ret;
1044             }
1045             break;
1046         case OPAL_UINT32:
1047             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint32, &m, OPAL_UINT32))) {
1048                 return ret;
1049             }
1050             break;
1051         case OPAL_UINT64:
1052             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.uint64, &m, OPAL_UINT64))) {
1053                 return ret;
1054             }
1055             break;
1056         case OPAL_BYTE_OBJECT:
1057             
1058             if (OPAL_SUCCESS != (ret = opal_dss_unpack_int32(buffer, &(ptr[i]->data.bo.size), &m, OPAL_INT32))) {
1059                 return ret;
1060             }
1061             if (0 < ptr[i]->data.bo.size) {
1062                 ptr[i]->data.bo.bytes = (uint8_t*)malloc(ptr[i]->data.bo.size);
1063                 if (NULL == ptr[i]->data.bo.bytes) {
1064                     return OPAL_ERR_OUT_OF_RESOURCE;
1065                 }
1066                 if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, ptr[i]->data.bo.bytes,
1067                                                                 &(ptr[i]->data.bo.size), OPAL_BYTE))) {
1068                     return ret;
1069                 }
1070             } else {
1071                 ptr[i]->data.bo.bytes = NULL;
1072             }
1073             break;
1074         case OPAL_FLOAT:
1075             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.fval, &m, OPAL_FLOAT))) {
1076                 return ret;
1077             }
1078             break;
1079         case OPAL_DOUBLE:
1080             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.dval, &m, OPAL_DOUBLE))) {
1081                 return ret;
1082             }
1083             break;
1084         case OPAL_TIMEVAL:
1085             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.tv, &m, OPAL_TIMEVAL))) {
1086                 return ret;
1087             }
1088             break;
1089         case OPAL_PTR:
1090             
1091             break;
1092         case OPAL_NAME:
1093             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.name, &m, OPAL_NAME))) {
1094                 return ret;
1095             }
1096             break;
1097         case OPAL_STATUS:
1098             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.status, &m, OPAL_INT))) {
1099                 return ret;
1100             }
1101             break;
1102         case OPAL_ENVAR:
1103             if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, &ptr[i]->data.envar, &m, OPAL_ENVAR))) {
1104                 return ret;
1105             }
1106             break;
1107         default:
1108             opal_output(0, "UNPACK-OPAL-VALUE: UNSUPPORTED TYPE %d FOR KEY %s", (int)ptr[i]->type, ptr[i]->key);
1109             return OPAL_ERROR;
1110         }
1111     }
1112 
1113     return OPAL_SUCCESS;
1114 }
1115 
1116 
1117 
1118 
1119 int opal_dss_unpack_buffer_contents(opal_buffer_t *buffer, void *dest,
1120                                     int32_t *num_vals, opal_data_type_t type)
1121 {
1122     opal_buffer_t **ptr;
1123     int32_t i, n, m;
1124     int ret;
1125     size_t nbytes;
1126 
1127     ptr = (opal_buffer_t **) dest;
1128     n = *num_vals;
1129 
1130     for (i = 0; i < n; ++i) {
1131         
1132         ptr[i] = OBJ_NEW(opal_buffer_t);
1133         if (NULL == ptr[i]) {
1134             return OPAL_ERR_OUT_OF_RESOURCE;
1135         }
1136         
1137         m=1;
1138         if (OPAL_SUCCESS != (ret = opal_dss_unpack_sizet(buffer, &nbytes, &m, OPAL_SIZE))) {
1139             return ret;
1140         }
1141         m = nbytes;
1142         
1143         if (0 < nbytes) {
1144             ptr[i]->base_ptr = (char*)malloc(nbytes);
1145             
1146             if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, ptr[i]->base_ptr, &m, OPAL_BYTE))) {
1147                 return ret;
1148             }
1149         }
1150         ptr[i]->pack_ptr = ptr[i]->base_ptr + m;
1151         ptr[i]->unpack_ptr = ptr[i]->base_ptr;
1152         ptr[i]->bytes_allocated = nbytes;
1153         ptr[i]->bytes_used = m;
1154     }
1155     return OPAL_SUCCESS;
1156 }
1157 
1158 
1159 
1160 
1161 int opal_dss_unpack_name(opal_buffer_t *buffer, void *dest,
1162                         int32_t *num_vals, opal_data_type_t type)
1163 {
1164     int rc;
1165     int32_t i, num;
1166     opal_process_name_t* proc;
1167     opal_jobid_t *jobid;
1168     opal_vpid_t *vpid;
1169 
1170     num = *num_vals;
1171 
1172     
1173     jobid = (opal_jobid_t*)malloc(num * sizeof(opal_jobid_t));
1174     if (NULL == jobid) {
1175         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
1176         *num_vals = 0;
1177         return OPAL_ERR_OUT_OF_RESOURCE;
1178     }
1179     
1180     if (OPAL_SUCCESS != (rc =
1181                          opal_dss_unpack_jobid(buffer, jobid, num_vals, OPAL_JOBID))) {
1182         OPAL_ERROR_LOG(rc);
1183         *num_vals = 0;
1184         free(jobid);
1185         return rc;
1186     }
1187 
1188     
1189     vpid = (opal_vpid_t*)malloc(num * sizeof(opal_vpid_t));
1190     if (NULL == vpid) {
1191         OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE);
1192         *num_vals = 0;
1193         free(jobid);
1194         return OPAL_ERR_OUT_OF_RESOURCE;
1195     }
1196     
1197     if (OPAL_SUCCESS != (rc =
1198                          opal_dss_unpack_vpid(buffer, vpid, num_vals, OPAL_VPID))) {
1199         OPAL_ERROR_LOG(rc);
1200         *num_vals = 0;
1201         free(vpid);
1202         free(jobid);
1203         return rc;
1204     }
1205 
1206     
1207     proc = (opal_process_name_t*)dest;
1208     for (i=0; i < num; i++) {
1209         proc->jobid = jobid[i];
1210         proc->vpid = vpid[i];
1211         proc++;
1212     }
1213 
1214     
1215     free(vpid);
1216     free(jobid);
1217 
1218     return OPAL_SUCCESS;
1219 }
1220 
1221 
1222 
1223 
1224 int opal_dss_unpack_jobid(opal_buffer_t *buffer, void *dest,
1225                          int32_t *num_vals, opal_data_type_t type)
1226 {
1227     int ret;
1228 
1229     
1230     if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_JOBID_T))) {
1231         OPAL_ERROR_LOG(ret);
1232     }
1233 
1234     return ret;
1235 }
1236 
1237 
1238 
1239 
1240 int opal_dss_unpack_vpid(opal_buffer_t *buffer, void *dest,
1241                         int32_t *num_vals, opal_data_type_t type)
1242 {
1243     int ret;
1244 
1245     
1246     if (OPAL_SUCCESS != (ret = opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_VPID_T))) {
1247         OPAL_ERROR_LOG(ret);
1248     }
1249 
1250     return ret;
1251 }
1252 
1253 
1254 
1255 
1256 int opal_dss_unpack_status(opal_buffer_t *buffer, void *dest,
1257                            int32_t *num_vals, opal_data_type_t type)
1258 {
1259     int ret;
1260 
1261     
1262     ret = opal_dss_unpack_buffer(buffer, dest, num_vals, OPAL_INT);
1263     if (OPAL_SUCCESS != ret) {
1264         OPAL_ERROR_LOG(ret);
1265     }
1266 
1267     return ret;
1268 }
1269 
1270 
1271 int opal_dss_unpack_envar(opal_buffer_t *buffer, void *dest,
1272                           int32_t *num_vals, opal_data_type_t type)
1273 {
1274     opal_envar_t *ptr;
1275     int32_t i, n, m;
1276     int ret;
1277 
1278     ptr = (opal_envar_t *) dest;
1279     n = *num_vals;
1280 
1281     for (i = 0; i < n; ++i) {
1282         m=1;
1283         if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &ptr[i].envar, &m, OPAL_STRING))) {
1284             OPAL_ERROR_LOG(ret);
1285             return ret;
1286         }
1287         m=1;
1288         if (OPAL_SUCCESS != (ret = opal_dss_unpack_string(buffer, &ptr[i].value, &m, OPAL_STRING))) {
1289             OPAL_ERROR_LOG(ret);
1290             return ret;
1291         }
1292         m=1;
1293         if (OPAL_SUCCESS != (ret = opal_dss_unpack_byte(buffer, &ptr[i].separator, &m, OPAL_BYTE))) {
1294             OPAL_ERROR_LOG(ret);
1295             return ret;
1296         }
1297     }
1298 
1299     return OPAL_SUCCESS;
1300 }