PMIX_EXPORT int PMI2_Nameserv_lookup(const char service_name[],
const PMI_keyval_t *info_ptr,
char port[], int portLen)
{
pmix_status_t rc = PMIX_SUCCESS;
int nvals;
pmix_pdata_t pdata[2];
PMI2_CHECK();
if (NULL == service_name || NULL == info_ptr || NULL == port) {
return PMI2_ERR_INVALID_ARG;
}
if (pmi2_singleton) {
return PMI2_FAIL;
}
PMIX_PDATA_CONSTRUCT(&pdata[0]);
PMIX_PDATA_CONSTRUCT(&pdata[1]);
/* pass the service */
(void)strncpy(pdata[0].key, service_name, PMIX_MAX_KEYLEN);
nvals = 1;
/* if provided, add any other value */
if (NULL != info_ptr) {
(void)strncpy(pdata[1].key, info_ptr->key, PMIX_MAX_KEYLEN);
pdata[1].value.type = PMIX_STRING;
pdata[1].value.data.string = info_ptr->val;
nvals = 2;
}
/* lookup the info */
if (PMIX_SUCCESS != (rc = PMIx_Lookup(pdata, nvals, NULL, 0))) {
PMIX_PDATA_DESTRUCT(&pdata[0]);
PMIX_PDATA_DESTRUCT(&pdata[1]);
return convert_err(rc);
}
/* should have received a string back */
if (PMIX_STRING != pdata[0].value.type ||
NULL == pdata[0].value.data.string) {
PMIX_PDATA_DESTRUCT(&pdata[0]);
PMIX_PDATA_DESTRUCT(&pdata[1]);
return PMI2_FAIL;
}
/* return the port */
(void)strncpy(port, pdata[0].value.data.string, portLen);
PMIX_PDATA_DESTRUCT(&pdata[0]);
if (NULL != info_ptr) {
}
PMIX_PDATA_DESTRUCT(&pdata[1]);
return PMI2_SUCCESS;
}
pmix_status_t pmix_bfrops_base_unpack_pdata(pmix_pointer_array_t *regtypes,
pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_pdata_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: %d pdata", *num_vals);
ptr = (pmix_pdata_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_PDATA_CONSTRUCT(&ptr[i]);
/* unpack the proc */
m=1;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &ptr[i].proc, &m, PMIX_PROC, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
/* unpack key */
m=1;
tmp = NULL;
PMIX_BFROPS_UNPACK_TYPE(ret, buffer, &tmp, &m, PMIX_STRING, regtypes);
if (PMIX_SUCCESS != ret) {
return ret;
}
if (NULL == tmp) {
PMIX_ERROR_LOG(PMIX_ERROR);
return PMIX_ERROR;
}
pmix_strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
if (PMIX_SUCCESS != (ret = pmix_bfrop_get_data_type(regtypes, buffer, &ptr[i].value.type))) {
PMIX_ERROR_LOG(ret);
return ret;
}
pmix_output_verbose(20, pmix_bfrops_base_framework.framework_output,
"pmix_bfrop_unpack: pdata type %d %s", ptr[i].value.type, ptr[i].value.data.string);
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrops_base_unpack_val(regtypes, buffer, &ptr[i].value))) {
PMIX_ERROR_LOG(ret);
return ret;
}
}
return PMIX_SUCCESS;
}
pmix_status_t pmix_bfrop_unpack_pdata(pmix_buffer_t *buffer, void *dest,
int32_t *num_vals, pmix_data_type_t type)
{
pmix_pdata_t *ptr;
int32_t i, n, m;
pmix_status_t ret;
char *tmp;
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: %d pdata", *num_vals);
ptr = (pmix_pdata_t *) dest;
n = *num_vals;
for (i = 0; i < n; ++i) {
PMIX_PDATA_CONSTRUCT(&ptr[i]);
/* unpack the proc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_proc(buffer, &ptr[i].proc, &m, PMIX_PROC))) {
return ret;
}
/* unpack key */
m=1;
tmp = NULL;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_string(buffer, &tmp, &m, PMIX_STRING))) {
return ret;
}
if (NULL == tmp) {
return PMIX_ERROR;
}
(void)strncpy(ptr[i].key, tmp, PMIX_MAX_KEYLEN);
free(tmp);
/* unpack value - since the value structure is statically-defined
* instead of a pointer in this struct, we directly unpack it to
* avoid the malloc */
m=1;
if (PMIX_SUCCESS != (ret = pmix_bfrop_unpack_int(buffer, &ptr[i].value.type, &m, PMIX_INT))) {
return ret;
}
pmix_output_verbose(20, pmix_globals.debug_output,
"pmix_bfrop_unpack: pdata type %d", ptr[i].value.type);
m=1;
if (PMIX_SUCCESS != (ret = unpack_val(buffer, &ptr[i].value))) {
return ret;
}
}
return PMIX_SUCCESS;
}
PMIX_EXPORT int PMI_Lookup_name(const char service_name[], char port[])
{
pmix_status_t rc = PMIX_SUCCESS;
pmix_pdata_t pdata;
PMI_CHECK();
if (NULL == service_name || NULL == port) {
return PMI_ERR_INVALID_ARG;
}
if (pmi_singleton) {
return PMI_FAIL;
}
PMIX_PDATA_CONSTRUCT(&pdata);
/* pass the service */
(void) strncpy(pdata.key, service_name, PMIX_MAX_KEYLEN);
/* PMI-1 doesn't want the nspace back */
if (PMIX_SUCCESS != (rc = PMIx_Lookup(&pdata, 1, NULL, 0))) {
return convert_err(rc);
}
/* should have received a string back */
if (PMIX_STRING != pdata.value.type || NULL == pdata.value.data.string) {
return convert_err(PMIX_ERR_NOT_FOUND);
}
/* return the port - sadly, this API doesn't tell us
* the size of the port array, and so there is a
* potential we could overrun it. As this feature
* isn't widely supported in PMI-1, try being
* conservative */
(void) strncpy(port, pdata.value.data.string, PMIX_MAX_KEYLEN);
PMIX_PDATA_DESTRUCT(&pdata);
return PMIX_SUCCESS;
}
