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; }