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