309 строки
8.5 KiB
C
309 строки
8.5 KiB
C
|
/*
|
||
|
|
* Copyright (c) 2004-2005 The Trustees of Indiana University.
|
||
|
|
* All rights reserved.
|
||
|
|
* Copyright (c) 2004-2005 The Trustees of the University of Tennessee.
|
||
|
|
* All rights reserved.
|
||
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
||
|
|
* University of Stuttgart. All rights reserved.
|
||
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
||
|
|
* All rights reserved.
|
||
|
|
* $COPYRIGHT$
|
||
|
|
*
|
||
|
|
* Additional copyrights may follow
|
||
|
|
*
|
||
|
|
* $HEADER$
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "orte_config.h"
|
||
|
|
|
||
|
|
#include <sys/types.h>
|
||
|
|
#ifdef HAVE_NETINET_IN_H
|
||
|
|
#include <netinet/in.h>
|
||
|
|
#endif
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include "mca/errmgr/errmgr.h"
|
||
|
|
|
||
|
|
#include "dps/dps_internal.h"
|
||
|
|
|
||
|
|
|
||
|
|
int orte_dps_unpack(orte_buffer_t *buffer, void *dst, size_t *num_vals,
|
||
|
|
orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int ret=ORTE_SUCCESS, rc=ORTE_SUCCESS;
|
||
|
|
size_t local_num;
|
||
|
|
|
||
|
|
/* check for error */
|
||
|
|
if (NULL == buffer || NULL == dst || NULL == num_vals || 0 > *num_vals ||
|
||
|
|
type >= orte_value_array_get_size(&orte_dps_types)) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM);
|
||
|
|
return ORTE_ERR_BAD_PARAM;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* if user provides a zero for num_vals, then there is no storage allocated
|
||
|
|
* so return an appropriate error
|
||
|
|
*/
|
||
|
|
if (0 == *num_vals) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_UNPACK_INADEQUATE_SPACE);
|
||
|
|
return ORTE_UNPACK_INADEQUATE_SPACE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Unpack the stored number of values
|
||
|
|
* REMINDER: it is possible that the buffer is corrupted and that
|
||
|
|
* the DPS will *think* there is a proper size_t variable at the
|
||
|
|
* beginning of the unpack region - but that the value is bogus (e.g., just
|
||
|
|
* a byte field in a string array that so happens to have a value that
|
||
|
|
* matches the size_t data type flag). Therefore, this error check is
|
||
|
|
* NOT completely safe. This is true for ALL unpack functions, not just
|
||
|
|
* size_t as used here.
|
||
|
|
*/
|
||
|
|
if (ORTE_SUCCESS != (
|
||
|
|
rc = orte_dps_unpack_sizet(buffer, &local_num, 1, ORTE_SIZE))) {
|
||
|
|
ORTE_ERROR_LOG(rc);
|
||
|
|
*num_vals = 0;
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* if the storage provided is inadequate, set things up
|
||
|
|
* to unpack as much as we can and to return an error code
|
||
|
|
* indicating that everything was not unpacked - the buffer
|
||
|
|
* is left in a state where it can not be further unpacked.
|
||
|
|
*/
|
||
|
|
if (local_num > *num_vals) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_UNPACK_INADEQUATE_SPACE);
|
||
|
|
local_num = *num_vals;
|
||
|
|
ret = ORTE_UNPACK_INADEQUATE_SPACE;
|
||
|
|
} else if (local_num < *num_vals) { /* more than enough storage */
|
||
|
|
*num_vals = local_num; /* let the user know how many we actually unpacked */
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Unpack the value(s) */
|
||
|
|
if (ORTE_SUCCESS != (rc = orte_dps_unpack_buffer(buffer, dst, local_num, type))) {
|
||
|
|
ORTE_ERROR_LOG(rc);
|
||
|
|
*num_vals = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ORTE_SUCCESS != ret) {
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
int orte_dps_unpack_buffer(orte_buffer_t *buffer, void *dst, size_t num_vals,
|
||
|
|
orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int rc;
|
||
|
|
orte_dps_type_info_t *info;
|
||
|
|
orte_data_type_t local_type;
|
||
|
|
|
||
|
|
/* Unpack the data type and check it for compatibility */
|
||
|
|
if (ORTE_SUCCESS != (rc = orte_dps_get_data_type(buffer, &local_type))) {
|
||
|
|
ORTE_ERROR_LOG(rc);
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
/* if the data types don't match, then return an error */
|
||
|
|
if (type != local_type) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_PACK_MISMATCH);
|
||
|
|
return ORTE_PACK_MISMATCH;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Lookup the unpack function for this type and call it */
|
||
|
|
|
||
|
|
info = orte_value_array_get_item(&orte_dps_types, type);
|
||
|
|
if (ORTE_SUCCESS != (rc = info->odti_unpack_fn(buffer, dst, num_vals, type))) {
|
||
|
|
ORTE_ERROR_LOG(rc);
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* UNPACK GENERIC SYSTEM TYPES */
|
||
|
|
|
||
|
|
/*
|
||
|
|
* NULL
|
||
|
|
*/
|
||
|
|
int orte_dps_unpack_null(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int rc;
|
||
|
|
|
||
|
|
/* Turn around and unpack the real type */
|
||
|
|
if (ORTE_SUCCESS != (rc = orte_dps_unpack_byte(buffer, dest, num_vals, ORTE_BYTE))) {
|
||
|
|
ORTE_ERROR_LOG(rc);
|
||
|
|
}
|
||
|
|
|
||
|
|
return rc;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* BOOL
|
||
|
|
*/
|
||
|
|
int orte_dps_unpack_bool(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
/* Turn around and unpack the real type */
|
||
|
|
if (ORTE_SUCCESS != (
|
||
|
|
ret = orte_dps_unpack_buffer(buffer, dest, num_vals, DPS_TYPE_BOOL))) {
|
||
|
|
ORTE_ERROR_LOG(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* INT
|
||
|
|
*/
|
||
|
|
int orte_dps_unpack_int(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
/* Turn around and unpack the real type */
|
||
|
|
if (ORTE_SUCCESS != (
|
||
|
|
ret = orte_dps_unpack_buffer(buffer, dest, num_vals, DPS_TYPE_INT))) {
|
||
|
|
ORTE_ERROR_LOG(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* SIZE_T
|
||
|
|
*/
|
||
|
|
int orte_dps_unpack_sizet(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
|
||
|
|
/* Turn around and unpack the real type */
|
||
|
|
if (ORTE_SUCCESS != (
|
||
|
|
ret = orte_dps_unpack_buffer(buffer, dest, num_vals, DPS_TYPE_SIZE_T))) {
|
||
|
|
ORTE_ERROR_LOG(ret);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* UNPACK FUNCTIONS FOR NON-GENERIC SYSTEM TYPES */
|
||
|
|
|
||
|
|
/*
|
||
|
|
* BYTE, CHAR, INT8
|
||
|
|
*/
|
||
|
|
int orte_dps_unpack_byte(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
/* check to see if there's enough data in buffer */
|
||
|
|
if (orte_dps_too_small(buffer, num_vals) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_UNPACK_READ_PAST_END_OF_BUFFER);
|
||
|
|
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* unpack the data */
|
||
|
|
memcpy(dest, buffer->unpack_ptr, num_vals);
|
||
|
|
|
||
|
|
/* update buffer pointer */
|
||
|
|
buffer->unpack_ptr += num_vals;
|
||
|
|
|
||
|
|
return ORTE_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
int orte_dps_unpack_int16(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
size_t i;
|
||
|
|
uint16_t tmp, *desttmp = (uint16_t*) dest;
|
||
|
|
|
||
|
|
/* check to see if there's enough data in buffer */
|
||
|
|
if (orte_dps_too_small(buffer, num_vals*sizeof(tmp)) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_UNPACK_READ_PAST_END_OF_BUFFER);
|
||
|
|
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* unpack the data */
|
||
|
|
for (i = 0; i < num_vals; ++i) {
|
||
|
|
tmp = ntohs(desttmp[i]);
|
||
|
|
memcpy(&desttmp[i], &tmp, sizeof(tmp));
|
||
|
|
}
|
||
|
|
buffer->unpack_ptr += num_vals * sizeof(tmp);
|
||
|
|
|
||
|
|
return ORTE_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
int orte_dps_unpack_int32(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
size_t i;
|
||
|
|
uint32_t tmp, *desttmp = (uint32_t*) dest;
|
||
|
|
|
||
|
|
/* check to see if there's enough data in buffer */
|
||
|
|
if (orte_dps_too_small(buffer, num_vals*sizeof(tmp)) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_UNPACK_READ_PAST_END_OF_BUFFER);
|
||
|
|
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* unpack the data */
|
||
|
|
for (i = 0; i < num_vals; ++i) {
|
||
|
|
tmp = ntohl(desttmp[i]);
|
||
|
|
memcpy(&tmp, &desttmp[i], sizeof(tmp));
|
||
|
|
}
|
||
|
|
buffer->unpack_ptr += num_vals * sizeof(tmp);
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
int orte_dps_unpack_int64(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
size_t i;
|
||
|
|
uint32_t tmp, *desttmp = (uint32_t*) dest;
|
||
|
|
|
||
|
|
num_vals *= 2;
|
||
|
|
|
||
|
|
/* check to see if there's enough data in buffer */
|
||
|
|
if (orte_dps_too_small(buffer, num_vals*sizeof(tmp)) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_UNPACK_READ_PAST_END_OF_BUFFER);
|
||
|
|
return ORTE_UNPACK_READ_PAST_END_OF_BUFFER;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* unpack the data */
|
||
|
|
for (i = 0; i < num_vals; ++i) {
|
||
|
|
tmp = ntohl(desttmp[i]);
|
||
|
|
memcpy(&tmp, &desttmp[i], sizeof(tmp));
|
||
|
|
}
|
||
|
|
buffer->unpack_ptr += num_vals * sizeof(tmp);
|
||
|
|
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
int orte_dps_unpack_string(orte_buffer_t *buffer, void *dest,
|
||
|
|
size_t num_vals, orte_data_type_t type)
|
||
|
|
{
|
||
|
|
int ret;
|
||
|
|
size_t i, len;
|
||
|
|
char **sdest = (char**) dest;
|
||
|
|
|
||
|
|
for (i = 0; i < num_vals; ++i) {
|
||
|
|
if (ORTE_SUCCESS != (ret = orte_dps_unpack_sizet(buffer, &len, 1, ORTE_SIZE))) {
|
||
|
|
ORTE_ERROR_LOG(ret);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
sdest[i] = malloc(len);
|
||
|
|
if (NULL == sdest[i]) {
|
||
|
|
ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE);
|
||
|
|
return ORTE_ERR_OUT_OF_RESOURCE;
|
||
|
|
}
|
||
|
|
if (ORTE_SUCCESS != (ret = orte_dps_unpack_byte(buffer, sdest[i], len, ORTE_BYTE))) {
|
||
|
|
ORTE_ERROR_LOG(ret);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return ORTE_SUCCESS;
|
||
|
|
}
|