void forwardMessage(struct ClientNode *client)
{
char handle[MAX_HANDLE_LENGTH];
uint8_t *index = (uint8_t *) client->packetData;
switch (client->packetData->flag) {
case FLAG_MSG_REQ:
index += kChatHeaderSize;
break;
case FLAG_MSG_ACK:
index += kChatHeaderSize + sizeof(uint32_t);
break;
default:
fprintf(stderr, "ERROR: Unknown forwarding packet scheme %d\n", client->packetData->flag);
return;
break;
}
uint8_t handleSize = *index;
memcpy(handle, index+1, handleSize);
handle[handleSize] = '\0';
struct ClientNode *destClient = clientNamed(handle);
if (destClient == NULL) {
respondToClient(client, FLAG_MSG_ERR, index, handleSize+1);
return;
}
ssize_t bytesSent;
if ((bytesSent = sendErr(destClient->clientSocket, client->packetData, client->packetLength, 0)) < 0) {
perror("forwardMessage:send");
}
}
void * startDispatchServer(void * args) {
int stop = 0;
int msgSize;
struct netMsg received;
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGTERM);
sigaddset(&set, SIGINT);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
pthread_sigmask(SIG_BLOCK, &set, NULL);
//Those calls allow to uninstall the termination handler in this thread,
//it is however a rather inelegant way to do it,
//there must be some other way to achieve this.
//get the message queue id :
sendLog(DEBUG, "dispatch thread started");
dispatchReq = *(mqd_t*) args;
for (stop = 0; stop != STOP;) {
msgSize = mq_receive(dispatchReq, (void*) &received,
sizeof(struct netMsg), NULL);
if (msgSize == -1) {
sendErr(DEBUG, "dispatch mq_receive", errno);
if (errno == EINTR) {
continue; //we were interupted because a siqnal was caught
} else {
stop = STOP; //There is probably some other crapy error, exit.
continue;
}
}
switch (received.dest) {
case REST:
transmit(socketRestClient, received.data, received.msgSize);
break;
case SENSORS:
sendLog(DEBUG, "Sending message to sensors");
transmit(socketSensorClient, received.data, received.msgSize);
break;
case RESTUP:
//Init rest Server Socket
if(startUpdateSender() != -1){
sendLog(DEBUG, "Sending message to sensors up");
transmit(socketRestServer, received.data, received.msgSize);
//Destroy socket for sender
/* fermeture de la connection */
shutdown(socketRestServer, 2);
close(socketRestServer);
}
break;
default:
sendLog(WARNING,
"dispatch msg, unexpected message dest received : %d",
received.dest);
}
free(received.data); //Allocated in sendNetMsg()
}
return NULL;
}
void MailServer::clientReceivedData(boost::shared_ptr<std::string> data)
{
// DEBUG("Digesting received data: " << *data);
try
{
// the parser will notify the server of completed messages through the delegate method
parser_.digest(data);
}
catch(ConversionException& e)
{
sendErr(socket_id_);
}
}
void MailServer::handleSend(const SendMessage& msg)
{
try
{
try
{
DEBUG("PERSISTING SEND");
fileManager_->persistSendMessage(msg);
DEBUG("PERSISTED SEND");
sendOk(socket_id_);
}
catch(const FileManagerException& e)
{
DEBUG(e.what());
sendErr(socket_id_);
}
}
catch(const NetworkException& e)
{
DEBUG("Failed to send reply for sendMessage request, because " << e.what());
sendErr(socket_id_);
}
}
void respondToClient(struct ClientNode *client, HeaderFlag flag, uint8_t *data, ssize_t dataLen)
{
struct ChatHeader responseHeader;
responseHeader.sequenceNumber = ntohl(client->packetData->sequenceNumber);
responseHeader.checksum = ntohs(client->packetData->checksum);
responseHeader.flag = flag;
uint8_t *packet = makePacket(responseHeader, data, dataLen);
ssize_t packetLength = kChatHeaderSize + dataLen;
ssize_t bytesSent;
if ((bytesSent = sendErr(client->clientSocket, packet, packetLength, 0)) < 0) {
perror("respondToClient:send");
}
free(packet);
}
int sendNetMsg(int destination, int len, char * msg) {
struct netMsg newMsg = { .dest = destination, .msgSize = len, };
if (dispatchReq == 0) {
sendLog(DEBUG, "dispatch mq not opened yet"); //I don't think this is actually possible.
return -1;
}
//Allocate enough memory to copy the msg,
//so that the original buffer can be freed after this function call.
//this memory will be freed once the message is read.
newMsg.data = malloc(len);
memcpy(newMsg.data, msg, len);
if (mq_send(dispatchReq, (void*) &newMsg, sizeof(struct netMsg), 0)) {
sendErr(WARNING, "mq_send dispatch request failed", errno);
return -1;
}
return 0;
}
int ServerItem::sendPackage(int index)
{
if (fp == NULL) {
return -2;
}
char *data = (char *)malloc(blksize + 4);
if (index != packageIndex + 1)
fseek(fp, (int)(index - 1) * blksize, 0);
package *op = (package *)data;
op->opCode = htons(TFTP_OP_DATA);
op->code = htons((unsigned short)index);
int ret = fread(data + 4, 1, blksize, fp);
if (ret < 0) {
int ret = sendErr(TFTP_ERR_UNDEFINED);
}
else {
if (ret < blksize) {
finished = true;
}
int rett = mySend(data, ret + 4);
if (rett < 0) {
finished = false;
}
else {
if (finished) {
packageIndex = index;
}
}
string x = string();
x.append(inet_ntoa(addr.sin_addr));
x.append(" Package sent: \t");
char aa[5];
itoa(rett, aa, 10);
x.append(aa);
logMessage((char *)x.c_str());
packageIndex = index;
}
return 0;
}
void MailServer::messageReceived(int sd, boost::shared_ptr<Message> msg)
{
DEBUG("A message has been dispatched!");
// Don't accept messages from users that aren't authenticated yet.
if( msg->getType() != Message::MessageTypeLogin &&
msg->getType() != Message::MessageTypeQuit &&
loginManager_.isLoggedIn() == false)
{
sendErr(sd);
return;
}
switch( msg->getType() )
{
case Message::MessageTypeSend:
handleSend(static_cast<SendMessage&>(*msg));
break;
case Message::MessageTypeList:
handleList(static_cast<ListMessage&>(*msg));
break;
case Message::MessageTypeRead:
handleRead(static_cast<ReadMessage&>(*msg));
break;
case Message::MessageTypeDel:
handleDel(static_cast<DelMessage&>(*msg));
break;
case Message::MessageTypeQuit:
handleQuit(static_cast<QuitMessage&>(*msg));
break;
case Message::MessageTypeLogin:
handleLogin(static_cast<LoginMessage&>(*msg));
break;
case Message::MessageTypeInvalid:
default:
DEBUG("Ignoring: An invalid/unknown message type was received. Code: [" << (*msg).getType() << "].");
break;
}
}
ServerItem::ServerItem(SOCKET *socket, SOCKADDR_IN addr, char *message, int length)
{
fileError = false;
blksize = 512;
finished = false;
this->socket = socket;
this->addr = addr;
package *pac = (package *)message;
unsigned short op = ntohs(pac->opCode);
int i = 2;
for (i = 2; i < length; i++) {
if (message[i] == 0) {
break;
}
}
filename = (char *)malloc(i - 1);
strcpy(filename, message + 2);
strcpy(mode, message + 2 + strlen(filename) + 1);
int index = 2 + strlen(filename) + 1 + strlen(mode) + 1;
while (index < length) {
char *x = (char *)malloc(strlen(message + index) + 1);
index += strlen(x) + 1;
char *y = (char *)malloc(strlen(message + index) + 1);
index += strlen(y) + 1;
if (strcmp(x, "blksize") == 0) {
sscanf(y, "%d", &blksize);
}
}
if (op == TFTP_OP_READ || op == TFTP_OP_WRITE) {
string x = string();
x.append(inet_ntoa(addr.sin_addr));
x.append(" Client connected");
logMessage((char *)x.c_str());
}
if (op == TFTP_OP_READ) {
fp = fopen(filename, "r");
int err = errno;
if (fp == NULL) {
if (err == EACCES) {
sendErr(TFTP_ERR_ACCESS_DENIED);
}
else if (err == ENOENT) {
sendErr(TFTP_ERR_FILE_NOT_FOUND);
}
else if (err == EEXIST) {
sendErr(TFTP_ERR_FILE_ALREADY_EXISTS);
}
else {
sendErr(TFTP_ERR_UNDEFINED);
}
fileError = true;
}
else {
sendPackage(1);
}
}
else if (op == TFTP_OP_WRITE) {
fp = fopen(filename, "w");
int err = errno;
if (fp == NULL) {
if (err == EACCES) {
sendErr(TFTP_ERR_ACCESS_DENIED);
}
else if (err == ENOENT) {
sendErr(TFTP_ERR_FILE_NOT_FOUND);
}
else if (err == EEXIST) {
sendErr(TFTP_ERR_FILE_ALREADY_EXISTS);
}
else {
sendErr(TFTP_ERR_UNDEFINED);
}
fileError = true;
}
else {
sendACK(0);
packageIndex = 0;
}
}
else {
sendErr(TFTP_ERR_UNEXPECTED_OPCODE);
}
}
