static uint8_t receiveMessage(struct Message* msg, struct Interface* iface) { struct Hermes* hermes = Identity_check((struct Hermes*) iface->receiverContext); struct Allocator* alloc = Allocator_child(hermes->alloc); receiveMessage2(msg, hermes, alloc); Allocator_free(alloc); return 0; }
int waitForEvent2(Activity *activity, ActivityDescriptor *senderDescriptor, void *buffer, unsigned long length, unsigned int timeout) { //logInfo("[%s] Going to wait for an event...", activity->descriptor->name); //int polling; if (activity->polling == NULL_FILE_DESCRIPTOR) { if ((/* polling */ activity->polling = epoll_create(1)) < 0) { logErr("[%s] Error setting up event waiting: %s", activity->descriptor->name, strerror(errno)); close(activity->polling); activity->polling = NULL_FILE_DESCRIPTOR; return -EFAULT; } struct epoll_event messageQueueEventDescriptor = { .events = EPOLLIN, .data.fd = activity->messageQueue }; if (epoll_ctl(/* polling */ activity->polling, EPOLL_CTL_ADD, messageQueueEventDescriptor.data.fd, &messageQueueEventDescriptor) < 0) { logErr("[%s] Error registering message queue event source: %s", activity->descriptor->name, strerror(errno)); //close(polling); close(activity->polling); activity->polling = NULL_FILE_DESCRIPTOR; return -EFAULT; } } int polling = activity->polling; struct epoll_event firedEvents[1]; int numberOfFiredEvents; numberOfFiredEvents = epoll_wait(polling, firedEvents, 1, timeout); //close(polling); if (numberOfFiredEvents < 0) { logErr("[%s] Error waiting for event: %s", activity->descriptor->name, strerror(errno)); return -EFAULT; } else if (numberOfFiredEvents == 1) { //logInfo("[%s] Message received!", activity->descriptor->name); unsigned long incomingMessageLength = receiveMessage2(activity, senderDescriptor, buffer, length); return incomingMessageLength; } else { //logInfo("[%s] Timeout occured!", activity->descriptor->name); return 0; } } #ifdef __XENO__ #define mq_receive __real_mq_receive #endif int receiveMessage(void *_receiver, char *buffer, unsigned long length) { return receiveMessage2(_receiver, NULL, buffer, length); } //int receiveMessage2(void *_receiver, char *senderName, char *buffer, unsigned long length) { int receiveMessage2(void *_receiver, ActivityDescriptor *senderDescriptor, void *buffer, unsigned long length) { if (!_receiver) { logErr("["__FILE__"] null pointer at receiveMessage(_receiver, ...)!"); return -EFAULT; } int result = 0; Activity *receiver = (Activity *)_receiver; //logInfo("[%s] Going to receive message...", receiver->descriptor->name); //char receiveBuffer[MAX_MESSAGE_LENGTH + 1]; void *receiveBuffer = NULL; if (!(receiveBuffer = malloc(MAX_MESSAGE_LENGTH + 1))) { logErr("[%s] Error allocating receiver buffer: %s", receiver->descriptor->name, strerror(errno)); return -EFAULT; } ssize_t receiveLength; if ((receiveLength = mq_receive(receiver->messageQueue, receiveBuffer, /* sizeof(receiveBuffer) */ MAX_MESSAGE_LENGTH + 1, NULL)) < 0) { if (receiver->messageQueueMode != messageQueue_nonBlocking) { logErr("[%s] Error receiving message: %s", receiver->descriptor->name, strerror(errno)); result = -EFAULT; goto receiveMessage2_out; } } // Copy message length unsigned long messageLength; memcpy(&messageLength, receiveBuffer, sizeof(unsigned long)); // Check length of the receive message if (messageLength > length) { logErr("[%s] Error receiving message: Message longer than expected!", receiver->descriptor->name); result = -EFAULT; goto receiveMessage2_out; } // Copy message memcpy(buffer, receiveBuffer + sizeof(unsigned long), messageLength); result = messageLength; //char *_senderName = NULL; ActivityDescriptor *_senderDescriptor = NULL; if (receiveLength > sizeof(unsigned long) + messageLength) { //_senderName = receiveBuffer + length; _senderDescriptor = receiveBuffer + sizeof(unsigned long) + messageLength; } //if (senderName) { if (senderDescriptor) { // Copy sender name //if (_senderName) { if (_senderDescriptor) { //memcpy(senderName, _senderName, MAX_ACTIVITY_NAME_LENGTH); memcpy(senderDescriptor, _senderDescriptor, sizeof(ActivityDescriptor)); } else { //senderName[0] = '\0'; //memcpy(senderName, UNKNOWN_SENDER_NAME, strlen(UNKNOWN_SENDER_NAME) + 1); memcpy(senderDescriptor, UNKNOWN_SENDER_DESCRIPTOR, sizeof(ActivityDescriptor)); } } //if (_senderName) { if (_senderDescriptor) { //logInfo("[%s] Message received from %s (message length: %u)...", receiver->descriptor->name, _senderName, length); //logInfo("[%s] Message received from %s (message length: %u)...", receiver->descriptor->name, _senderDescriptor->name, length); } else { //logInfo("[%s] Message received (message length: %u)...", receiver->descriptor->name, messageLength); } receiveMessage2_out: free(receiveBuffer); return result; } int sendMessage(ActivityDescriptor receiverDescriptor, char *buffer, unsigned long length, MessagePriority priority) { return sendMessage2(NULL, receiverDescriptor, length, buffer, priority); } int sendMessage2(void *_sender, ActivityDescriptor receiverDescriptor, unsigned long length, void *buffer, MessagePriority priority) { // if (!_sender) { // logErr("["__FILE__"] null pointer at senderMessage(_sender, ...)!"); // // return -EFAULT; // } if (strcmp(receiverDescriptor.name, "<Null activity>") == 0) { return 0; } int result = 0; Activity *sender = (Activity *)_sender; unsigned long sendLength; if (sender) { sendLength = sizeof(ActivityDescriptor) + sizeof(length) + length; } else { sendLength = sizeof(length) + length; } if (sendLength > MAX_MESSAGE_LENGTH) { logErr("[%s] Error sending message: Message too long!", "<Sender>"); return -EFAULT; } char *receiverMessageQueueId = createMessageQueueId(receiverDescriptor.name); mqd_t receiverQueue = mq_open(receiverMessageQueueId, O_WRONLY); free(receiverMessageQueueId); if (receiverQueue < 0) { // If there is no corresponding message queue, the receiver is probably not running if (errno == ENOENT) { logWarn("[%s] %s is not running?!", sender->descriptor->name, receiverDescriptor.name); } else { if (sender) { logErr("[%s] Error opening message queue %s for sending: %s", sender->descriptor->name, receiverDescriptor.name, strerror(errno)); } else { logErr("[%s] Error opening message queue %s for sending: %s", "<Sender>", receiverDescriptor.name, strerror(errno)); } } return -EFAULT; } if (sender) { //logInfo("[%s] Sending message to %s (message length: %u)...", sender->descriptor->name, receiverDescriptor.name, length); } else { //logInfo("[%s] Sending message to %s (message length: %u)...", "<Sender>", receiverDescriptor.name, length); } void *sendBuffer = 0; //if (!(sendBuffer = malloc(MAX_ACTIVITY_NAME_LENGTH + length))) { if (!(sendBuffer = malloc(sendLength))) { logErr("[%s] Error allocating send buffer: %s", sender->descriptor->name, strerror(errno)); result = -EFAULT; goto sendMessage2_out; } // Copy message length memcpy(sendBuffer, &length, sizeof(length)); // Copy message memcpy(sendBuffer + sizeof(length), buffer, length); if (sender) { // Copy sender name //memcpy(sendBuffer + length, sender->descriptor->name, MAX_ACTIVITY_NAME_LENGTH); // copy sender descriptor memcpy(sendBuffer + sizeof(length) + length, sender->descriptor, sizeof(ActivityDescriptor)); //if (mq_send(receiverQueue, sendBuffer, MAX_ACTIVITY_NAME_LENGTH + length, priority) < 0) { if (mq_send(receiverQueue, sendBuffer, sendLength, priority) < 0) { logErr("[%s] Error sending message: %s", sender->descriptor->name, strerror(errno)); result = -EFAULT; goto sendMessage2_out; } } else { if (mq_send(receiverQueue, sendBuffer, sendLength, priority) < 0) { logErr("[%s] Error sending message: %s", "<Sender>", strerror(errno)); result = -EFAULT; goto sendMessage2_out; } } sendMessage2_out: free(sendBuffer); mq_close(receiverQueue); return result; }