static MME_ERROR createTransportInfo(const char *name, TransportInfo_t **tpInfo_p)
{
const char portName[] = "MMEHostReplyPort#0";
TransportInfo_t *tpInfo;
EMBX_ERROR err;
/* Allocate space for the transport descriptor */
tpInfo = EMBX_OS_MemAlloc(sizeof(TransportInfo_t));
if (!tpInfo) {
return MME_NOMEM;
}
memset(tpInfo, 0, sizeof(TransportInfo_t));
/* Open a transport handle */
err = EMBX_OpenTransport(name, &tpInfo->handle);
if (EMBX_SUCCESS != err) {
goto error_recovery;
}
/* Create the reply port. */
memcpy(tpInfo->replyPortName, portName, sizeof(portName));
/* MULTIHOST support */
do {
MME_Info(MME_INFO_MANAGER, (" EMBX_CreatePort(), port name <%s>...\n",
tpInfo->replyPortName));
/* Create the reply port. This port is purely synchronous (it only receives
* messages that are replies to outstanding messages) and as such does not
* need its own management thread.
*/
err = EMBX_CreatePort(tpInfo->handle, tpInfo->replyPortName, &tpInfo->replyPort);
} while (EMBX_ALREADY_BIND == err &&
tpInfo->replyPortName[sizeof(portName)-2]++ < '9');
if (EMBX_SUCCESS != err) {
goto error_recovery;
}
*tpInfo_p = tpInfo;
return MME_SUCCESS;
error_recovery:
if (tpInfo->handle) {
err = EMBX_CloseTransport(tpInfo->handle);
MME_Assert(EMBX_SUCCESS == err);
}
EMBX_OS_MemFree(tpInfo);
return MME_EMBX_ERROR;
}
MME_ERROR MME_RegisterTransport(const char *transportName)
{
const char portName[] = "MMECompanionAdmin#0";
EMBX_ERROR err;
if (NULL == transportName) {
return MME_INVALID_ARGUMENT;
}
if (NULL == manager) {
return MME_DRIVER_NOT_INITIALIZED;
}
MME_Info(MME_INFO_MANAGER, ("EMBX_OpenTransport(), name <%s>...\n", transportName));
/* Open the transport. */
err = EMBX_OpenTransport(transportName, &manager->transportHandle);
MME_Info(MME_INFO_MANAGER, ("EMBX_OpenTransport() - handle %d\n", manager->transportHandle));
if (EMBX_SUCCESS != err) {
MME_Info(MME_INFO_MANAGER, ("Failed to open EMBX_OpenTransport() - EMBX err %d\n", err));
return MME_INVALID_ARGUMENT;
}
/* Create the administration port. */
memcpy(manager->adminPortName, portName, sizeof(portName));
do {
MME_Info(MME_INFO_MANAGER, (" EMBX_CreatePort(), port name <%s>...\n",
manager->adminPortName));
err = EMBX_CreatePort(manager->transportHandle,
manager->adminPortName, &manager->adminPort);
} while (EMBX_ALREADY_BIND == err &&
manager->adminPortName[sizeof(portName)-2]++ < '9');
if (err != EMBX_SUCCESS) {
MME_Info(MME_INFO_MANAGER, ("EMBX_CreatePort(%s) failed - error %d\n", manager->adminPortName, err));
EMBX_CloseTransport(manager->transportHandle);
manager->transportHandle = 0;
return MME_INVALID_ARGUMENT;
}
MME_Info(MME_INFO_MANAGER, ("EMBX_CreatePort(%s) handle 0x%08x\n", manager->adminPortName, manager->adminPort));
manager->managerRunning = 1;
return MME_SUCCESS;
}
int main()
{
EMBX_TRANSPORT hTrans;
EMBX_PORT bufferpool, consumer, mypoolconnection;
EMBX_ERROR err;
int i;
embxRuntimeInit();
err = EMBX_OpenTransport("shm", &hTrans);
assert(EMBX_SUCCESS == err);
/* Create the port which will hold the pool of work buffers */
err = EMBX_CreatePort(hTrans, "bufferpool", &bufferpool);
assert(EMBX_SUCCESS == err);
/* Make a connection to the port we just created so we can inject
* empty buffers onto the port's queue as part of the initialization
*/
err = EMBX_Connect(hTrans, "bufferpool", &mypoolconnection);
assert(EMBX_SUCCESS == err);
/* Now wait for the consumer port to come into existence and
* make a connection to it.
*/
err = EMBX_ConnectBlock(hTrans, "consumer", &consumer);
assert(EMBX_SUCCESS == err);
/* Inject empty buffers into the buffer pool */
for(i=0;i<BUFFER_POOL_SIZE;i++)
{
EMBX_VOID *buffer;
err = EMBX_Alloc(hTrans, BUFFER_SIZE, &buffer);
assert(EMBX_SUCCESS == err);
/* Send empty buffer to the buffer pool port */
err = EMBX_SendMessage(mypoolconnection, buffer, 0);
assert(EMBX_SUCCESS == err);
}
/* We don't need our connection to the buffer pool anymore
* so close it down.
*/
EMBX_ClosePort(mypoolconnection);
for(i=0;i<100;i++)
{
EMBX_RECEIVE_EVENT ev;
EMBX_UINT buffersize;
/* Jabber ... */
printf("producer: Issuing message %d of 100\n", i+1);
/* Get an empty buffer from the pool */
err = EMBX_ReceiveBlock(bufferpool, &ev);
assert(EMBX_SUCCESS == err);
/* The event size field does not represent the actual
* size of the buffer in this case, hence if you need
* to find that out use the following. However in this
* case where all the buffers are the same known size
* it wouldn't be necessary expect as self checking debug.
*/
err = EMBX_GetBufferSize(ev.data, &buffersize);
assert(EMBX_SUCCESS == err);
/* Do something to fill the buffer with stuff to be used
* by the consumer...... use your imagination ......
*/
/* Now send the buffer to the consumer with the real amount
* of data in the buffer as the size argument (this can be
* less than the buffer size). For this example we assume
* the whole buffer contains valid data.
*/
err = EMBX_SendMessage(consumer, ev.data, buffersize);
assert(EMBX_SUCCESS == err);
}
/* Shut the communication system down. This has the side effect
* of causing the consumer to also close down, almost certainly
* before outstanding messages have been processed.
*/
EMBX_ClosePort(bufferpool);
EMBX_ClosePort(consumer);
EMBX_CloseTransport(hTrans);
EMBX_Deinit();
return 0;
}
int run_test(void)
{
EMBX_ERROR res;
EMBX_TPINFO tpinfo1;
EMBX_BOOL bFailed;
EMBX_TRANSPORT tp;
EMBX_PORT localPort,remotePort;
EMBX_VOID *buffer1,*buffer2;
EMBX_FACTORY factory;
bFailed = EMBX_FALSE;
tp = EMBX_INVALID_HANDLE_VALUE;
buffer1 = buffer2 = 0;
/* Test 1 */
res = EMBX_SendMessage(EMBX_INVALID_HANDLE_VALUE, buffer1, 0);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test1 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
res = EMBX_RegisterTransport(EMBXLB_loopback_factory,&loopback_config,sizeof(EMBXLB_Config_t),&factory);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Transport Registration failed, res = %s, exiting\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 2 */
res = EMBX_Init();
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test2 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 3 */
res = EMBX_GetFirstTransport(&tpinfo1);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test3 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 4 */
res = EMBX_OpenTransport(tpinfo1.name, &tp);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test4 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 5 */
res = EMBX_CreatePort(tp, "testport", &localPort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test5 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 6 */
res = EMBX_Connect(tp, "testport", &remotePort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test6 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 7 */
res = EMBX_Alloc(tp, BUFFER_SIZE, &buffer1);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test7 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 8 */
res = EMBX_SendMessage(tp, buffer1, 0);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test8 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 9 */
res = EMBX_SendMessage(localPort, buffer1, 0);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test9 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 10 */
res = EMBX_SendMessage(remotePort, 0, 0);
if(res != EMBX_INVALID_ARGUMENT)
{
EMBX_Info(EMBX_TRUE, ("Test10 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 11 */
res = EMBX_SendMessage(remotePort, buffer1, BUFFER_SIZE+1);
if(res != EMBX_INVALID_ARGUMENT)
{
EMBX_Info(EMBX_TRUE, ("Test11 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 12 */
res = EMBX_SendMessage(remotePort, buffer1, BUFFER_SIZE);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test12 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 13 - Ensure this allocation happens before buffer1 gets free'd
* when the port is closed, so buffer1 and buffer2 will not point to
* the same memory which is important for later tests.
*/
res = EMBX_Alloc(tp, BUFFER_SIZE, &buffer2);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test13 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 14 */
res = EMBX_ClosePort(localPort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test14 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 15 - buffer1 has been freed by test14 so should be garbage */
res = EMBX_SendMessage(remotePort, buffer1, 0);
if(res != EMBX_INVALID_ARGUMENT)
{
EMBX_Info(EMBX_TRUE, ("Test15 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 16 */
res = EMBX_SendMessage(remotePort, buffer2, BUFFER_SIZE);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test16 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 17 */
res = EMBX_ClosePort(remotePort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test17 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 18 */
res = EMBX_CloseTransport(tp);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test18 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 19 */
res = EMBX_Deinit();
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test19 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* These test a different code path to the identical tests done before
* EMBX_Init.
*/
/* Test 20 - Depends on buffer2 not having been freed so we get through
* to checking the state of the driver.
*/
res = EMBX_SendMessage(remotePort, buffer2, 0);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test20 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 21 */
res = EMBX_UnregisterTransport(factory);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test21 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
return bFailed?-1:0;
skip_remaining_tests:
EMBX_Info(EMBX_TRUE, ("Skipping Remaining Tests\n"));
return -1;
}
int run_test(void)
{
EMBX_UINT i;
EMBX_ERROR res;
EMBX_TPINFO tpinfo1;
EMBX_BOOL bFailed;
EMBX_PORT localPort,remotePort;
EMBX_VOID *buffer1;
EMBX_FACTORY factory;
EMBX_RECEIVE_EVENT ev;
bFailed = EMBX_FALSE;
buffer1 = 0;
/* Test 1 */
res = EMBX_ReceiveBlock(EMBX_INVALID_HANDLE_VALUE, &ev);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test1 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
res = EMBX_RegisterTransport(EMBXLB_loopback_factory, &loopback_config, sizeof(EMBXLB_Config_t), &factory);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Transport Registration failed, res = %s, exiting\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 2 */
res = EMBX_Init();
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test2 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 3 */
res = EMBX_GetFirstTransport(&tpinfo1);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test3 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 4 */
res = EMBX_OpenTransport(tpinfo1.name, &tp);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test4 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 5 */
res = EMBX_CreatePort(tp, "testport", &localPort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test5 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 6 */
res = EMBX_Connect(tp, "testport", &remotePort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test6 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 7 */
res = EMBX_ReceiveBlock(tp, &ev);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test7 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 8 */
res = EMBX_ReceiveBlock(remotePort, &ev);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test8 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 9 */
res = EMBX_ReceiveBlock(localPort, 0);
if(res != EMBX_INVALID_ARGUMENT)
{
EMBX_Info(EMBX_TRUE, ("Test9 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 10 */
res = EMBX_Alloc(tp, BUFFER_SIZE, &buffer1);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test10 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
for(i=0;i<BUFFER_SIZE;i++)
{
((unsigned char *)buffer1)[i] = (unsigned char)i;
}
/* Test 11 */
res = EMBX_SendMessage(remotePort, buffer1, BUFFER_SIZE);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test11 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 12 */
res = EMBX_ReceiveBlock(localPort, &ev);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test12 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
if(ev.handle != EMBX_INVALID_HANDLE_VALUE ||
ev.offset != 0 ||
ev.type != EMBX_REC_MESSAGE ||
ev.size != BUFFER_SIZE)
{
EMBX_Info(EMBX_TRUE, ("Test13 failed, event structure incorrect\n"));
goto skip_remaining_tests;
}
for(i=0;i<ev.size;i++)
{
if( ((unsigned char *)ev.data)[i] != (unsigned char)i )
{
EMBX_Info(EMBX_TRUE, ("Test13 failed, buffer contents incorrect\n"));
bFailed = EMBX_TRUE;
break;
}
}
/* Test 13 */
res = EMBX_Free(ev.data);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test13 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
if(!EMBX_OS_ThreadCreate(send_thread, (void *)remotePort, EMBX_DEFAULT_THREAD_PRIORITY, "send"))
{
EMBX_Info(EMBX_TRUE, ("Unable to create thread\n"));
goto skip_remaining_tests;
}
/* Test 14 */
res = EMBX_ReceiveBlock(localPort, &ev);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test14 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
if(ev.handle != EMBX_INVALID_HANDLE_VALUE ||
ev.offset != 0 ||
ev.type != EMBX_REC_MESSAGE ||
ev.size != BUFFER_SIZE)
{
EMBX_Info(EMBX_TRUE, ("Test15 failed, event structure incorrect\n"));
goto skip_remaining_tests;
}
/* Test 15 */
res = EMBX_Free(ev.data);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test15 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 16 */
res = EMBX_ClosePort(remotePort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test16 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 17 */
res = EMBX_ClosePort(localPort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test17 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 18 */
res = EMBX_CloseTransport(tp);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test18 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 19 */
res = EMBX_Deinit();
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test19 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* These test a different code path to the identical tests done before
* EMBX_Init
*/
/* Test 20 */
res = EMBX_ReceiveBlock(localPort, &ev);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test20 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 21 */
res = EMBX_UnregisterTransport(factory);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test21 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
return bFailed?-1:0;
skip_remaining_tests:
EMBX_Info(EMBX_TRUE, ("Skipping Remaining Tests\n"));
return -1;
}
static MME_ERROR RemoteTransformer_GetTransformerCapability(
Transformer_t *transformer,
const char *name, MME_TransformerCapability_t * capability)
{
RemoteTransformer_t *remoteTransformer = (RemoteTransformer_t *) transformer;
MME_ERROR res = MME_NOMEM;
EMBX_TRANSPORT hdl;
EMBX_PORT replyPort;
int n, messageSize;
TransformerCapabilityMessage *message;
EMBX_RECEIVE_EVENT event;
MME_Assert(remoteTransformer);
MME_Assert(name);
MME_Assert(capability);
hdl = remoteTransformer->super.info->handle;
MME_Assert(hdl);
/* calculate the size of the capability message */
messageSize = sizeof(*message) + capability->TransformerInfoSize;
/* allocate somewhere to store the message we are about to send */
message = allocBuffer(remoteTransformer, messageSize);
if (0 == message) {
return MME_NOMEM;
}
/* create a port to be used to reply to this message */
n = sprintf(message->portName, "MMECapability_0x%x", (unsigned) message);
MME_Assert(n < EMBX_MAX_PORT_NAME);
if (EMBX_SUCCESS != EMBX_CreatePort(hdl, message->portName, &replyPort)) {
goto error_recovery_alloc;
}
/* populate the rest of the message */
message->id = TMESSID_CAPABILITY;
message->messageSize = messageSize;
strncpy(message->transformerType, name, MME_MAX_TRANSFORMER_NAME);
message->transformerType[MME_MAX_TRANSFORMER_NAME - 1] = '\0';
message->capability = *capability;
/* send the message and wait for a reply */
if (EMBX_SUCCESS != EMBX_SendMessage(remoteTransformer->adminPort,
message, sizeof(*message)) ||
EMBX_SUCCESS != EMBX_ReceiveBlock(replyPort, &event)) {
goto error_recovery_createport;
}
message = event.data;
MME_Assert(event.type == EMBX_REC_MESSAGE);
MME_Assert(event.size >= messageSize);
MME_Assert(message->id == TMESSID_CAPABILITY);
MME_Assert(message->messageSize == messageSize);
/* fill in the rest of the message */
res = message->result;
message->capability.TransformerInfo_p = capability->TransformerInfo_p;
*capability = message->capability;
memcpy(capability->TransformerInfo_p, message+1, capability->TransformerInfoSize);
/* fall into the clean up code */
error_recovery_createport:
(void) EMBX_ClosePort(replyPort);
error_recovery_alloc:
(void) freeBuffer(remoteTransformer, message);
return res;
}
static MME_ERROR RemoteTransformer_Init(Transformer_t* transformer,
const char* name,
MME_TransformerInitParams_t * params,
MME_TransformerHandle_t handle,
EMBX_BOOL createThread)
{
RemoteTransformer_t *remoteTransformer = (RemoteTransformer_t *) transformer;
EMBX_ERROR err;
EMBX_RECEIVE_EVENT event;
TransformerInitMessage *message = NULL;
char receiverThreadName[EMBX_MAX_PORT_NAME+1];
int messageSize,n;
MME_ERROR result, res;
result = MME_NOMEM;
remoteTransformer->super.handle = handle;
/* TODO: We should take a copy of our (transformer specific) parameters. These might
* be deallocated once the transformer is initialized.
*/
remoteTransformer->super.initParams = *params;
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: initialising '%s'\n", name));
/* Create the reply port. We use the unique handle to create a unique reply port name.*/
n = sprintf(remoteTransformer->replyPort.name, "MMEReply_0x%x", handle);
MME_Assert(n < EMBX_MAX_PORT_NAME);
err = EMBX_CreatePort(remoteTransformer->super.info->handle,
remoteTransformer->replyPort.name, &remoteTransformer->replyPort.port);
if (EMBX_SUCCESS != err) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Cannot create port '%s'\n",
remoteTransformer->replyPort.name));
goto embx_error_recovery;
}
remoteTransformer->replyPort.valid = 1;
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Created port '%s', port 0x%08x\n",
remoteTransformer->replyPort.name,
(unsigned) remoteTransformer->replyPort.port));
/* Create the init message */
res = createInitMessage(remoteTransformer, name, params, (EMBX_VOID **) &message);
if (MME_SUCCESS != res) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Cannot create initialisation message\n"));
goto error_recovery;
}
/* Remember size for check of reply message */
messageSize = message->messageSize;
/* Send the message */
err = EMBX_SendMessage(remoteTransformer->adminPort, message, messageSize);
if (err != EMBX_SUCCESS) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Cannot set initialisation message\n"));
goto embx_error_recovery;
}
/* Record ownership tranfer (see error_recovery) */
message = NULL;
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Waiting for initialisation reply\n"));
/* Wait for an answer from the companion */
err = EMBX_ReceiveBlock(remoteTransformer->replyPort.port, &event);
if (EMBX_SUCCESS != err) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Error while waiting for initialisation reply\n"));
goto embx_error_recovery;
}
/* Check if the message is as expected */
message = (TransformerInitMessage *) event.data;
MME_Assert(EMBX_REC_MESSAGE == event.type);
MME_Assert(event.size >= messageSize);
MME_Assert(message && message->id == TMESSID_INIT);
if (MME_SUCCESS != message->result) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Error initialising remote transformer\n"));
res = message->result;
goto error_recovery;
}
/* The MME successfully created its transformer */
strncpy(remoteTransformer->sendPort.name, message->portName, EMBX_MAX_PORT_NAME);
remoteTransformer->sendPort.name[EMBX_MAX_PORT_NAME] = '\0';
remoteTransformer->mmeHandle = message->mmeHandle;
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Connecting to transformer port '%s'\n",
remoteTransformer->sendPort.name));
/* Connect to the MME port */
err = EMBX_ConnectBlock(remoteTransformer->super.info->handle,
remoteTransformer->sendPort.name,
&remoteTransformer->sendPort.port);
if (EMBX_SUCCESS != err) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Cannot connect to port '%s'\n",
remoteTransformer->sendPort.name));
goto embx_error_recovery;
}
remoteTransformer->sendPort.valid = 1;
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Connected to port '%s', port 0x%08x\n",
remoteTransformer->sendPort.name,
(unsigned) remoteTransformer->sendPort.port));
if (createThread) {
/* Create our receiver task for the reply port */
sprintf(receiverThreadName, "HostRec%x", handle);
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Creating receiver thread '%s'\n",
receiverThreadName));
/* TODO: think about whether we want all the receiver threads to have the same priority */
remoteTransformer->receiverThread = EMBX_OS_ThreadCreate(receiverThread,
(void *) remoteTransformer, RECEIVER_TASK_PRIORITY, receiverThreadName);
if (EMBX_INVALID_THREAD == remoteTransformer->receiverThread) {
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Cannot create receiver thread '%s'\n",
receiverThreadName));
res = MME_NOMEM;
goto error_recovery;
}
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: Created receiver thread '%s', thread 0x%08x\n",
receiverThreadName, (unsigned) remoteTransformer->receiverThread));
}
/* Cleanup and exit */
cleanupInitMessage(remoteTransformer, message);
MME_Info(MME_INFO_TRANSFORMER, ("RemoteTransformer_Init: SUCCESS\n"));
return MME_SUCCESS;
embx_error_recovery:
/* As normal error recovery but map the EMBX error code to a MME error code first */
res = (EMBX_NOMEM == err ? MME_NOMEM : MME_EMBX_ERROR);
error_recovery:
if (remoteTransformer->mmeHandle) {
MME_Assert(message);
message->id = TMESSID_TERMINATE;
err = EMBX_SendMessage(remoteTransformer->adminPort, message, message->messageSize);
if (EMBX_SUCCESS == err) {
/* TODO: is blocking really a good idea during error recovery? */
err = EMBX_ReceiveBlock(remoteTransformer->replyPort.port, &event);
message = (EMBX_SUCCESS == err ? event.data : NULL);
}
remoteTransformer->mmeHandle = 0;
}
if (remoteTransformer->sendPort.valid) {
EMBX_ClosePort(remoteTransformer->sendPort.port);
remoteTransformer->sendPort.valid = 0;
}
if (remoteTransformer->replyPort.valid) {
EMBX_ClosePort(remoteTransformer->replyPort.port);
remoteTransformer->replyPort.valid = 0;
}
if (message) {
cleanupInitMessage(remoteTransformer, message);
}
return res;
}
int main()
{
EMBX_TRANSPORT hTrans;
EMBX_PORT consumer, bufferpool;
EMBX_ERROR err;
embxRuntimeInit();
err = EMBX_OpenTransport("shm", &hTrans);
assert(err == EMBX_SUCCESS);
/* Create the port which the consumer will receive work
* messages on.
*/
err = EMBX_CreatePort(hTrans, "consumer", &consumer);
assert(err == EMBX_SUCCESS);
/* Connect to the buffer pool on the producer, we will send
* back finished message buffers to this so the producer can
* re-use them.
*/
err = EMBX_ConnectBlock(hTrans, "bufferpool", &bufferpool);
assert(err == EMBX_SUCCESS);
while(1)
{
EMBX_RECEIVE_EVENT ev;
/* Wait for some work to do */
err = EMBX_ReceiveBlock(consumer, &ev);
if(err != EMBX_SUCCESS)
{
/* Assume, for the purposes of this example
* that this means the producer wants to close
* down. Hence clean up the transport and close
* down EMBX.
*/
EMBX_ClosePort(bufferpool);
EMBX_ClosePort(consumer);
EMBX_CloseTransport(hTrans);
EMBX_Deinit();
exit(1);
}
/* Do some work with the received message data here */
printf("consumer: Processing message\n");
/* Now send the message buffer back, note the zero size
* for the message length, this will prevent any data copying
* on a non shared memory transport.
*/
err = EMBX_SendMessage(bufferpool, ev.data, 0);
if(err != EMBX_SUCCESS)
{
EMBX_ClosePort(bufferpool);
EMBX_ClosePort(consumer);
EMBX_CloseTransport(hTrans);
EMBX_Deinit();
exit(1);
}
}
return 0;
}
int run_test(void)
{
EMBX_UINT i;
EMBX_ERROR res;
EMBX_TPINFO tpinfo1;
EMBX_BOOL bFailed;
EMBX_TRANSPORT tp;
EMBX_PORT localPort,remotePort;
EMBX_HANDLE hObj;
EMBX_FACTORY factory;
EMBX_RECEIVE_EVENT ev;
bFailed = EMBX_FALSE;
tp = EMBX_INVALID_HANDLE_VALUE;
hObj = EMBX_INVALID_HANDLE_VALUE;
/* Test 1 */
res = EMBX_Receive(EMBX_INVALID_HANDLE_VALUE, &ev);
if(res != EMBX_INVALID_PORT)
{
EMBX_Info(EMBX_TRUE, ("Test1 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
res = EMBX_RegisterTransport(EMBXLB_loopback_factory, &loopback_config, sizeof(EMBXLB_Config_t), &factory);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Transport Registration failed, res = %s, exiting\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 2 */
res = EMBX_Init();
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test2 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 3 */
res = EMBX_GetFirstTransport(&tpinfo1);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test3 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 4 */
res = EMBX_OpenTransport(tpinfo1.name, &tp);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test4 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 5 */
res = EMBX_CreatePort(tp, "testport", &localPort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test5 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 6 */
res = EMBX_Connect(tp, "testport", &remotePort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test6 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 7 */
res = EMBX_RegisterObject(tp, object, BUFFER_SIZE, &hObj);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test7 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
for(i=0;i<BUFFER_SIZE;i++)
{
((unsigned char *)object)[i] = (unsigned char)i;
}
/* Test 8 */
res = EMBX_SendObject(remotePort, hObj, 0, BUFFER_SIZE);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test8 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 9 */
res = EMBX_Receive(localPort, &ev);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test9 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
if(ev.handle != hObj || /* This is a specific quirk of the loopback transport */
ev.offset != 0 ||
ev.type != EMBX_REC_OBJECT ||
ev.size != BUFFER_SIZE)
{
EMBX_Info(EMBX_TRUE, ("Test9 failed, event structure incorrect\n"));
goto skip_remaining_tests;
}
for(i=0;i<ev.size;i++)
{
if( ((unsigned char *)ev.data)[i] != (unsigned char)i )
{
EMBX_Info(EMBX_TRUE, ("Test9 failed, buffer contents incorrect\n"));
bFailed = EMBX_TRUE;
break;
}
}
/* Test 10 */
res = EMBX_UpdateObject(remotePort, hObj, 0, BUFFER_SIZE);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test10 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 11 */
res = EMBX_Receive(localPort, &ev);
if(res != EMBX_INVALID_STATUS)
{
EMBX_Info(EMBX_TRUE, ("Test11 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 12 */
res = EMBX_DeregisterObject(tp, hObj);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test12 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
/* Test 13 */
res = EMBX_ClosePort(remotePort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test13 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 14 */
res = EMBX_ClosePort(localPort);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test14 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 15 */
res = EMBX_CloseTransport(tp);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test15 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 16 */
res = EMBX_Deinit();
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test16 failed, res = %s\n",error_strings[res]));
goto skip_remaining_tests;
}
/* Test 17 */
res = EMBX_UnregisterTransport(factory);
if(res != EMBX_SUCCESS)
{
EMBX_Info(EMBX_TRUE, ("Test17 failed, res = %s\n",error_strings[res]));
bFailed = EMBX_TRUE;
}
return bFailed?-1:0;
skip_remaining_tests:
EMBX_Info(EMBX_TRUE, ("Skipping Remaining Tests\n"));
return -1;
}
