/*---------------------------------------------------------------------------*/
na_return_t
NA_Mem_handle_create_segments(na_class_t *na_class, struct na_segment *segments,
na_size_t segment_count, unsigned long flags,
na_mem_handle_t *mem_handle)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!segments) {
NA_LOG_ERROR("NULL pointer to segments");
ret = NA_INVALID_PARAM;
goto done;
}
if (!segment_count) {
NA_LOG_ERROR("NULL segment count");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->mem_handle_create_segments) {
NA_LOG_ERROR("mem_handle_create_segments plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->mem_handle_create_segments(na_class, segments,
segment_count, flags, mem_handle);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Addr_to_string(na_class_t *na_class, char *buf, na_size_t *buf_size,
na_addr_t addr)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
/* buf can be NULL */
if (!buf_size) {
NA_LOG_ERROR("NULL buffer size");
ret = NA_INVALID_PARAM;
goto done;
}
if (addr == NA_ADDR_NULL) {
NA_LOG_ERROR("NULL addr");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->addr_to_string) {
NA_LOG_ERROR("addr_to_string plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->addr_to_string(na_class, buf, buf_size, addr);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Addr_self(na_class_t *na_class, na_addr_t *addr)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!addr) {
NA_LOG_ERROR("NULL pointer to na_addr_t");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->addr_self) {
NA_LOG_ERROR("addr_self plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->addr_self(na_class, addr);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Cancel(na_class_t *na_class, na_context_t *context, na_op_id_t op_id)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
if (op_id == NA_OP_ID_NULL) {
NA_LOG_ERROR("NULL operation ID");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->cancel) {
NA_LOG_ERROR("cancel plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->cancel(na_class, context, op_id);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Addr_dup(na_class_t *na_class, na_addr_t addr, na_addr_t *new_addr)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (addr == NA_ADDR_NULL) {
NA_LOG_ERROR("NULL addr");
ret = NA_INVALID_PARAM;
goto done;
}
if (!new_addr) {
NA_LOG_ERROR("NULL pointer to NA addr");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->addr_dup) {
NA_LOG_ERROR("addr_dup plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->addr_dup(na_class, addr, new_addr);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Mem_handle_create(na_class_t *na_class, void *buf, na_size_t buf_size,
unsigned long flags, na_mem_handle_t *mem_handle)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf) {
NA_LOG_ERROR("NULL buffer");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf_size) {
NA_LOG_ERROR("NULL buffer size");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->mem_handle_create) {
NA_LOG_ERROR("mem_handle_create plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->mem_handle_create(na_class, buf, buf_size, flags,
mem_handle);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Mem_handle_free(na_class_t *na_class, na_mem_handle_t mem_handle)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (mem_handle == NA_MEM_HANDLE_NULL) {
NA_LOG_ERROR("NULL memory handle");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->mem_handle_free) {
NA_LOG_ERROR("mem_handle_free plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->mem_handle_free(na_class, mem_handle);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_class_t *
NA_Initialize(const char *info_string, na_bool_t listen)
{
na_class_t *na_class = NULL;
struct na_info *na_info = NULL;
unsigned int plugin_index = 0;
unsigned int plugin_count = 0;
na_bool_t plugin_found = NA_FALSE;
na_return_t ret;
plugin_count = sizeof(na_class_info) / sizeof(na_class_info[0]) - 1;
ret = na_info_parse(info_string, &na_info);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not parse host string");
goto done;
}
#ifdef NA_DEBUG
na_info_print(na_info);
#endif
while (plugin_index < plugin_count) {
na_bool_t verified = NA_FALSE;
verified = na_class_info[plugin_index]->check_protocol(
na_info->protocol_name);
if (verified) {
/* Take the first plugin that supports the protocol */
if (!na_info->class_name) {
plugin_found = NA_TRUE;
break;
}
/* Otherwise try to use the plugin name */
if (strcmp(na_class_info[plugin_index]->class_name,
na_info->class_name) == 0) {
plugin_found = NA_TRUE;
break;
}
}
plugin_index++;
}
if (!plugin_found) {
NA_LOG_ERROR("No suitable plugin was found");
goto done;
}
/* Initialize lookup mutex */
hg_thread_mutex_init(&na_addr_lookup_mutex_g);
na_class = na_class_info[plugin_index]->initialize(na_info, listen);
done:
na_info_free(na_info);
return na_class;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Addr_lookup(na_class_t *na_class, na_context_t *context, na_cb_t callback,
void *arg, const char *name, na_op_id_t *op_id)
{
char *name_string = NULL;
char *short_name = NULL;
na_op_id_t na_op_id;
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
if (!name) {
NA_LOG_ERROR("Lookup name is NULL");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->addr_lookup) {
NA_LOG_ERROR("addr_lookup plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
/* Copy name and work from that */
name_string = strdup(name);
if (!name_string) {
NA_LOG_ERROR("Could not duplicate string");
ret = NA_NOMEM_ERROR;
goto done;
}
/* If NA class name was specified, we can remove the name here:
* ie. bmi+tcp://hostname:port -> tcp://hostname:port */
if (strstr(name_string, "+") != NULL)
strtok_r(name_string, "+", &short_name);
else
short_name = name_string;
ret = na_class->addr_lookup(na_class, context, callback, arg, short_name,
&na_op_id);
if (ret != NA_SUCCESS) {
goto done;
}
if (op_id && op_id != NA_OP_ID_IGNORE) *op_id = na_op_id;
done:
free(name_string);
return ret;
}
/*---------------------------------------------------------------------------*/
static na_return_t
na_test_send_finalize(struct na_test_lat_info *na_test_lat_info)
{
char *send_buf = NULL, *recv_buf = NULL;
void *send_buf_data, *recv_buf_data;
hg_request_t *recv_request = NULL;
na_size_t unexpected_header_size =
NA_Msg_get_unexpected_header_size(na_test_lat_info->na_class);
na_size_t buf_size =
(unexpected_header_size) ? unexpected_header_size + 1 : 1;
na_return_t ret = NA_SUCCESS;
/* Prepare send_buf */
send_buf = NA_Msg_buf_alloc(na_test_lat_info->na_class, buf_size,
&send_buf_data);
NA_Msg_init_unexpected(na_test_lat_info->na_class, send_buf, buf_size);
/* Prepare recv buf */
recv_buf = NA_Msg_buf_alloc(na_test_lat_info->na_class, buf_size,
&recv_buf_data);
memset(recv_buf, 0, buf_size);
recv_request = hg_request_create(na_test_lat_info->request_class);
/* Post recv */
ret = NA_Msg_recv_expected(na_test_lat_info->na_class,
na_test_lat_info->context, na_test_recv_expected_cb, recv_request,
recv_buf, buf_size, recv_buf_data, na_test_lat_info->target_addr, 0,
NA_TEST_TAG_DONE, NA_OP_ID_IGNORE);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("NA_Msg_recv_expected() failed");
goto done;
}
/* Post send */
ret = NA_Msg_send_unexpected(na_test_lat_info->na_class,
na_test_lat_info->context, NULL, NULL, send_buf, buf_size,
send_buf_data, na_test_lat_info->target_addr, 0, NA_TEST_TAG_DONE,
NA_OP_ID_IGNORE);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("NA_Msg_send_unexpected() failed");
goto done;
}
hg_request_wait(recv_request, NA_MAX_IDLE_TIME, NULL);
done:
/* Clean up resources */
hg_request_destroy(recv_request);
NA_Msg_buf_free(na_test_lat_info->na_class, send_buf, send_buf_data);
NA_Msg_buf_free(na_test_lat_info->na_class, recv_buf, recv_buf_data);
return ret;
}
/*---------------------------------------------------------------------------*/
na_context_t *
NA_Context_create(na_class_t *na_class)
{
na_return_t ret = NA_SUCCESS;
struct na_private_context *na_private_context = NULL;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
na_private_context = (struct na_private_context *) malloc(
sizeof(struct na_private_context));
if (!na_private_context) {
NA_LOG_ERROR("Could not allocate context");
ret = NA_NOMEM_ERROR;
goto done;
}
if (na_class->context_create) {
ret = na_class->context_create(na_class,
&na_private_context->context.plugin_context);
if (ret != NA_SUCCESS) {
goto done;
}
}
/* Initialize completion queue */
na_private_context->completion_queue = hg_queue_new();
if (!na_private_context->completion_queue) {
NA_LOG_ERROR("Could not create completion queue");
ret = NA_NOMEM_ERROR;
goto done;
}
/* Initialize completion queue mutex/cond */
hg_thread_mutex_init(&na_private_context->completion_queue_mutex);
hg_thread_cond_init(&na_private_context->completion_queue_cond);
/* Initialize progress mutex/cond */
hg_thread_mutex_init(&na_private_context->progress_mutex);
hg_thread_cond_init(&na_private_context->progress_cond);
na_private_context->progressing = NA_FALSE;
done:
if (ret != NA_SUCCESS) {
free(na_private_context);
na_private_context = NULL;
}
return (na_context_t *) na_private_context;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Context_destroy(na_class_t *na_class, na_context_t *context)
{
struct na_private_context *na_private_context =
(struct na_private_context *) context;
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!context) goto done;
/* Check that completion queue is empty now */
hg_thread_mutex_lock(&na_private_context->completion_queue_mutex);
if (!hg_queue_is_empty(na_private_context->completion_queue)) {
NA_LOG_ERROR("Completion queue should be empty");
ret = NA_PROTOCOL_ERROR;
hg_thread_mutex_unlock(&na_private_context->completion_queue_mutex);
goto done;
}
if (na_class->context_destroy) {
ret = na_class->context_destroy(na_class,
na_private_context->context.plugin_context);
if (ret != NA_SUCCESS) {
goto done;
}
}
/* Destroy completion queue */
hg_queue_free(na_private_context->completion_queue);
na_private_context->completion_queue = NULL;
hg_thread_mutex_unlock(&na_private_context->completion_queue_mutex);
/* Destroy completion queue mutex/cond */
hg_thread_mutex_destroy(&na_private_context->completion_queue_mutex);
hg_thread_cond_destroy(&na_private_context->completion_queue_cond);
/* Destroy progress mutex/cond */
hg_thread_mutex_destroy(&na_private_context->progress_mutex);
hg_thread_cond_destroy(&na_private_context->progress_cond);
free(na_private_context);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Msg_recv_expected(na_class_t *na_class, na_context_t *context,
na_cb_t callback, void *arg, void *buf, na_size_t buf_size,
na_addr_t source, na_tag_t tag, na_op_id_t *op_id)
{
na_op_id_t na_op_id;
na_return_t ret;
assert(na_class);
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
ret = na_class->msg_recv_expected(na_class, context, callback, arg, buf,
buf_size, source, tag, &na_op_id);
if (ret != NA_SUCCESS) {
goto done;
}
if (op_id && op_id != NA_OP_ID_IGNORE) *op_id = na_op_id;
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Get(na_class_t *na_class, na_context_t *context, na_cb_t callback, void *arg,
na_mem_handle_t local_mem_handle, na_offset_t local_offset,
na_mem_handle_t remote_mem_handle, na_offset_t remote_offset,
na_size_t data_size, na_addr_t remote_addr, na_op_id_t *op_id)
{
na_op_id_t na_op_id;
na_return_t ret;
assert(na_class);
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
ret = na_class->get(na_class, context, callback, arg, local_mem_handle,
local_offset, remote_mem_handle, remote_offset, data_size,
remote_addr, &na_op_id);
if (ret != NA_SUCCESS) {
goto done;
}
if (op_id && op_id != NA_OP_ID_IGNORE) *op_id = na_op_id;
done:
return ret;
}
/*---------------------------------------------------------------------------*/
static na_return_t
na_test_target_lookup(struct na_test_lat_info *na_test_lat_info)
{
struct na_test_target_lookup_arg request_args = { 0 };
hg_request_t *request = NULL;
na_return_t ret = NA_SUCCESS;
request = hg_request_create(na_test_lat_info->request_class);
request_args.addr_ptr = &na_test_lat_info->target_addr;
request_args.request = request;
/* Forward call to remote addr and get a new request */
ret = NA_Addr_lookup(na_test_lat_info->na_class, na_test_lat_info->context,
na_test_target_lookup_cb, &request_args,
na_test_lat_info->na_test_info.target_name, NA_OP_ID_IGNORE);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not lookup address");
goto done;
}
/* Wait for request to be marked completed */
hg_request_wait(request, NA_MAX_IDLE_TIME, NULL);
done:
hg_request_destroy(request);
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
na_cb_completion_add(na_context_t *context,
na_cb_t callback, struct na_cb_info *callback_info,
na_plugin_cb_t plugin_callback, void *plugin_callback_args)
{
struct na_private_context *na_private_context =
(struct na_private_context *) context;
na_return_t ret = NA_SUCCESS;
struct na_cb_completion_data *completion_data = NULL;
assert(context);
completion_data = (struct na_cb_completion_data *)
malloc(sizeof(struct na_cb_completion_data));
if (!completion_data) {
NA_LOG_ERROR("Could not allocate completion data struct");
ret = NA_NOMEM_ERROR;
goto done;
}
completion_data->callback = callback;
completion_data->callback_info = callback_info;
completion_data->plugin_callback = plugin_callback;
completion_data->plugin_callback_args = plugin_callback_args;
hg_thread_mutex_lock(&na_private_context->completion_queue_mutex);
if (!hg_queue_push_head(na_private_context->completion_queue,
(hg_queue_value_t) completion_data)) {
NA_LOG_ERROR("Could not push completion data to completion queue");
ret = NA_NOMEM_ERROR;
hg_thread_mutex_unlock(
&na_private_context->completion_queue_mutex);
goto done;
}
/* Callback is pushed to the completion queue when something completes
* so wake up anyone waiting in the trigger */
hg_thread_cond_signal(&na_private_context->completion_queue_cond);
hg_thread_mutex_unlock(&na_private_context->completion_queue_mutex);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Msg_recv_unexpected(na_class_t *na_class, na_context_t *context,
na_cb_t callback, void *arg, void *buf, na_size_t buf_size,
na_op_id_t *op_id)
{
na_op_id_t na_op_id;
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf) {
NA_LOG_ERROR("NULL buffer");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf_size) {
NA_LOG_ERROR("NULL buffer size");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->msg_recv_unexpected) {
NA_LOG_ERROR("msg_recv_unexpected plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->msg_recv_unexpected(na_class, context, callback, arg, buf,
buf_size, &na_op_id);
if (ret != NA_SUCCESS) {
goto done;
}
if (op_id && op_id != NA_OP_ID_IGNORE) *op_id = na_op_id;
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_bool_t
NA_Addr_is_self(na_class_t *na_class, na_addr_t addr)
{
na_bool_t ret = NA_FALSE;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
goto done;
}
if (!na_class->addr_is_self) {
NA_LOG_ERROR("addr_is_self plugin callback is not defined");
goto done;
}
ret = na_class->addr_is_self(na_class, addr);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_size_t
NA_Msg_get_max_unexpected_size(na_class_t *na_class)
{
na_size_t ret = 0;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
goto done;
}
if (!na_class->msg_get_max_unexpected_size) {
NA_LOG_ERROR("msg_get_max_unexpected_size plugin callback is not defined");
goto done;
}
ret = na_class->msg_get_max_unexpected_size(na_class);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_tag_t
NA_Msg_get_max_tag(na_class_t *na_class)
{
na_tag_t ret = 0;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
goto done;
}
if (!na_class->msg_get_max_tag) {
NA_LOG_ERROR("msg_get_max_tag plugin callback is not defined");
goto done;
}
ret = na_class->msg_get_max_tag(na_class);
done:
return ret;
}
static int
ack_expected_recv_cb(const struct na_cb_info *callback_info)
{
struct na_test_params *params = (struct na_test_params *) callback_info->arg;
na_return_t ret = NA_SUCCESS;
unsigned int i;
na_bool_t error = 0;
if (callback_info->ret != NA_SUCCESS) {
return ret;
}
printf("Bulk transfer complete\n");
/* Check bulk buf */
for (i = 0; i < params->bulk_size; i++) {
if (params->bulk_buf[i] != 0) {
printf("Error detected in bulk transfer, bulk_buf[%u] = %u,\t"
" was expecting %d!\n", i, params->bulk_buf[i], 0);
error = 1;
break;
}
}
if (!error) printf("Successfully reset %zu bytes!\n",
(size_t) params->bulk_size * sizeof(int));
ret = NA_Mem_deregister(params->na_class, params->local_mem_handle);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not deregister memory");
goto done;
}
ret = NA_Mem_handle_free(params->na_class, params->local_mem_handle);
if (ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not free memory handle");
goto done;
}
test_bulk_done_g = 1;
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Get(na_class_t *na_class, na_context_t *context, na_cb_t callback, void *arg,
na_mem_handle_t local_mem_handle, na_offset_t local_offset,
na_mem_handle_t remote_mem_handle, na_offset_t remote_offset,
na_size_t data_size, na_addr_t remote_addr, na_op_id_t *op_id)
{
na_op_id_t na_op_id;
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!context) {
NA_LOG_ERROR("NULL context");
ret = NA_INVALID_PARAM;
goto done;
}
if (local_mem_handle == NA_MEM_HANDLE_NULL) {
NA_LOG_ERROR("NULL memory handle");
ret = NA_INVALID_PARAM;
goto done;
}
if (remote_mem_handle == NA_MEM_HANDLE_NULL) {
NA_LOG_ERROR("NULL memory handle");
ret = NA_INVALID_PARAM;
goto done;
}
if (!data_size) {
NA_LOG_ERROR("NULL data size");
ret = NA_INVALID_PARAM;
goto done;
}
if (remote_addr == NA_ADDR_NULL) {
NA_LOG_ERROR("NULL addr");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->get) {
NA_LOG_ERROR("get plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->get(na_class, context, callback, arg, local_mem_handle,
local_offset, remote_mem_handle, remote_offset, data_size,
remote_addr, &na_op_id);
if (ret != NA_SUCCESS) {
goto done;
}
if (op_id && op_id != NA_OP_ID_IGNORE) *op_id = na_op_id;
done:
return ret;
}
/*---------------------------------------------------------------------------*/
void
na_test_get_config(char *addr_name, na_size_t len)
{
FILE *config = NULL;
config = fopen(MERCURY_TESTING_TEMP_DIRECTORY HG_TEST_CONFIG_FILE_NAME, "r");
if (!config) {
NA_LOG_ERROR("Could not open config file from: %s",
MERCURY_TESTING_TEMP_DIRECTORY HG_TEST_CONFIG_FILE_NAME);
exit(1);
}
if (fgets(addr_name, (int) len, config) == NULL) {
NA_LOG_ERROR("Could not retrieve config name");
fclose(config);
exit(1);
}
/* This prevents retaining the newline, if any */
addr_name[strlen(addr_name) - 1] = '\0';
fclose(config);
}
/*---------------------------------------------------------------------------*/
na_size_t
NA_Mem_handle_get_serialize_size(na_class_t *na_class,
na_mem_handle_t mem_handle)
{
na_size_t ret = 0;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
goto done;
}
/* mem_handle parameter is optional */
if (!na_class->mem_handle_get_serialize_size) {
NA_LOG_ERROR("mem_handle_get_serialize_size plugin callback is not defined");
goto done;
}
ret = na_class->mem_handle_get_serialize_size(na_class, mem_handle);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
void
na_test_set_config(const char *addr_name)
{
FILE *config = NULL;
config = fopen(MERCURY_TESTING_TEMP_DIRECTORY HG_TEST_CONFIG_FILE_NAME, "w+");
if (!config) {
NA_LOG_ERROR("Could not open config file from: %s",
MERCURY_TESTING_TEMP_DIRECTORY HG_TEST_CONFIG_FILE_NAME);
exit(1);
}
fprintf(config, "%s\n", addr_name);
fclose(config);
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Mem_handle_serialize(na_class_t *na_class, void *buf, na_size_t buf_size,
na_mem_handle_t mem_handle)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf) {
NA_LOG_ERROR("NULL buffer");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf_size) {
NA_LOG_ERROR("NULL buffer size");
ret = NA_INVALID_PARAM;
goto done;
}
if (mem_handle == NA_MEM_HANDLE_NULL) {
NA_LOG_ERROR("NULL memory handle");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->mem_handle_serialize) {
NA_LOG_ERROR("mem_handle_serialize plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->mem_handle_serialize(na_class, buf, buf_size, mem_handle);
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Mem_handle_deserialize(na_class_t *na_class, na_mem_handle_t *mem_handle,
const void *buf, na_size_t buf_size)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (!mem_handle) {
NA_LOG_ERROR("NULL pointer to memory handle");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf) {
NA_LOG_ERROR("NULL buffer");
ret = NA_INVALID_PARAM;
goto done;
}
if (!buf_size) {
NA_LOG_ERROR("NULL buffer size");
ret = NA_INVALID_PARAM;
goto done;
}
if (!na_class->mem_handle_deserialize) {
NA_LOG_ERROR("mem_handle_deserialize plugin callback is not defined");
ret = NA_PROTOCOL_ERROR;
goto done;
}
ret = na_class->mem_handle_deserialize(na_class, mem_handle, buf, buf_size);
done:
return ret;
}
/* NA test routines */
static int
test_msg_forward(struct na_test_params *params)
{
na_return_t na_ret;
int ret = EXIT_SUCCESS;
/* Send a message to addr */
NA_Msg_init_unexpected(params->na_class, params->send_buf,
params->send_buf_len);
sprintf(params->send_buf +
NA_Msg_get_unexpected_header_size(params->na_class), "Hello Server!");
/* Preposting response */
na_ret = NA_Msg_recv_expected(params->na_class, params->context,
msg_expected_recv_cb, params, params->recv_buf, params->recv_buf_len,
params->recv_buf_plugin_data, params->server_addr, 0,
NA_TEST_SEND_TAG + 1, NA_OP_ID_IGNORE);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not prepost recv of expected message");
ret = EXIT_FAILURE;
goto done;
}
na_ret = NA_Msg_send_unexpected(params->na_class, params->context,
msg_unexpected_send_cb, params, params->send_buf, params->send_buf_len,
params->send_buf_plugin_data, params->server_addr, 0, NA_TEST_SEND_TAG,
NA_OP_ID_IGNORE);
if (na_ret != NA_SUCCESS) {
NA_LOG_ERROR("Could not start send of unexpected message");
ret = EXIT_FAILURE;
goto done;
}
done:
return ret;
}
/*---------------------------------------------------------------------------*/
na_return_t
NA_Mem_unpublish(na_class_t *na_class, na_mem_handle_t mem_handle)
{
na_return_t ret = NA_SUCCESS;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
ret = NA_INVALID_PARAM;
goto done;
}
if (mem_handle == NA_MEM_HANDLE_NULL) {
NA_LOG_ERROR("NULL memory handle");
ret = NA_INVALID_PARAM;
goto done;
}
if (na_class->mem_unpublish) {
/* Optional */
ret = na_class->mem_unpublish(na_class, mem_handle);
}
done:
return ret;
}
/*---------------------------------------------------------------------------*/
const char *
NA_Get_class_name(na_class_t *na_class)
{
const char *ret = NULL;
if (!na_class) {
NA_LOG_ERROR("NULL NA class");
goto done;
}
ret = na_class->class_name;
done:
return ret;
}
