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