/** clientMove - struct containing msgTxt and reciver index - ClientsQueue index of sender */ void handleMsg(struct clientMsg clientMove,int index){ struct gameData data; int i; char buf[MSG_SIZE]; data.valid = 1; data.msg = index; strcpy(data.msgTxt, clientMove.msgTxt); createClientMsgBuff(clientMove, buf); if(clientMove.recp == -1){ // send to all except the sender for (i=0; i< conPlayers + conViewers ; i++){ if(i != index){ sendAll(ClientsQueue[i].fd, buf, &msg_SIZE); } } } else{ // send only to a specific client number for (i=0; i< conPlayers + conViewers ; i++){ if(ClientsQueue[i].clientNum == clientMove.recp){ sendAll(ClientsQueue[i].fd, buf, &msg_SIZE); } } } }
int command_nick(Client *client, StringBuffer *command) { StringBuffer *msg = StringBuffer_construct(); // No arguments if (command == NULL) { StringBuffer_concat(msg, "ERROR: Keinen Nicknamen angegeben!"); sendAll(client->socket, msg->buffer, msg->size); StringBuffer_free(msg); return EXIT_FAILURE; } Client temp; temp.name = command->buffer; // Search for double names if (clientVector_contains(clientList, &temp, &equals_Client_Name) == EXIT_SUCCESS) { StringBuffer_concat(msg, "ERROR: Es existiert bereits ein Client namens '"); StringBuffer_concat(msg, command->buffer); StringBuffer_concat(msg, "'!"); sendAll(client->socket, msg->buffer, msg->size); StringBuffer_free(msg); return EXIT_FAILURE; } StringBuffer_concat(msg, "INFO: '"); StringBuffer_concat(msg, client->name); StringBuffer_concat(msg, "' nennt sich nun '"); StringBuffer_concat(msg, command->buffer); StringBuffer_concat(msg, "'."); Client_setName(client, command->buffer); broadcast(msg); StringBuffer_free(msg); return EXIT_SUCCESS; }
/* * This function sends the content in the target file * to the server trunk by trunk. */ void sendFileToServer(int sockfd, char *targetFile) { struct stat stat_buf; uint32_t fileSize = 0; uint8_t buf[BUF_SIZE]; int bufOffset = 0; int fd = -1; uint32_t fileOffset = 0; // get the file size if(stat(targetFile, &stat_buf) == -1) { fprintf(stderr, "ftpc: ERROR: Can't get the status of the target file %s.\n", targetFile); exit(-1); } fileSize = stat_buf.st_size; // open the target file fd = open(targetFile, O_RDONLY); if(fd == -1) { fprintf(stderr, "ftpc: ERRORL Can't open file %s to read.\n", targetFile); exit(-1); } // create the header memcpy((void*)buf, (void*)&fileSize, 4); /* file size */ bufOffset += 4; memcpy((void*)(buf+4), (void*)targetFile, strlen(targetFile)); /* file name */ bufOffset += strlen(targetFile); buf[bufOffset] = '\0'; bufOffset = 24; // fill the buffer printf("ftpc: Sending file: 0%%"); while(1) { // read in the content int sizeRead = pread(fd, buf+bufOffset, BUF_SIZE - bufOffset, fileOffset); // update counters bufOffset += sizeRead; fileOffset += sizeRead; // send the buf if no more content in the file if(fileOffset >= fileSize) { sendAll(sockfd, buf, bufOffset); updateProgress(fileOffset, fileSize); return; } // send the buf if the buf is filled if(bufOffset == BUF_SIZE) { sendAll(sockfd, buf, bufOffset); updateProgress(fileOffset, fileSize); // reset data and update counters bufOffset = 0; } } // close the file close(fd); }
int Game::run() { while ((level->getSpawnList().size() > 0 || monsters.size() > 0) || ((time - endTime) < 5)) { //cout << "time = " << time << " endTime = " << endTime << endl; //cout.precision(3); //cout << "t : " << time << " s\tpos : " << pos / blockSize << " block / " << pos << " pix" << endl; if (loop() == 0) // No more players return (1); if (gameOver()) return (2); // Loop time stabilization to REFRESH ms double targetTime = round(time * 1000 / REFRESH + 1) * REFRESH / 1000; sleep(static_cast<int>((targetTime - time) * 1000)); last = time; time = (now() - begin); pos = time * BLOCKS_PER_SECOND * blockSize; // Detect end of level if (!(level->getSpawnList().size() > 0 || monsters.size() > 0) && endTime < 0) { endTime = time; string t; t += CMD_NLVL; sendAll(t); } } return (0); }
bool Game::nextLevel() { int oldLevel = level->getId(); string t; t += CMD_NEXT; sendAll(t); if (oldLevel == LEVELS) { return false; } while (rockets.size() > 0) { delete rockets.front(); rockets.pop_front(); } while (bullets.size() > 0) { delete bullets.front(); bullets.pop_front(); } while (monsters.size() > 0) { delete monsters.front(); monsters.pop_front(); } cout << "Next level " << oldLevel + 1 << " (still " << players.size() << " players connected)" << endl; begin = -1; delete level; level = new Level(oldLevel + 1, this); start(); return true; }
/** clientMove - struct containing msgTxt and reciver index - ClientsQueue index of sender */ void handleMsg(struct clientMsg clientMove, int index){ struct gameData data; //int i; char buf[MSGTXT_SIZE]; int msg_size = MSGTXT_SIZE; data.valid = 1; data.msg = 1; strcpy(data.msgTxt, clientMove.msgTxt); createClientMsgBuff(clientMove, buf); sendAll(ClientsQueue[(index + 1) % 2].fd, buf, &msg_size); //if (clientMove.recp == -1){ // // send to all except the sender // for (i = 0; i< conPlayers + conViewers; i++){ // if (i != index){ // sendAll(ClientsQueue[i].fd, buf, &MSGTXT_SIZE); // } // } //} //else{ // // send only to a specific client number // for (i = 0; i< conPlayers + conViewers; i++){ // if (ClientsQueue[i].clientNum == clientMove.recp){ // sendAll(ClientsQueue[i].fd, buf, &MSGTXT_SIZE); // } // } //} }
void MonServeur::dataIncoming() { QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender()); if (socket == 0) return; QDataStream in(socket); if (_sizeMessage == 0) { if (socket->bytesAvailable() < (int)sizeof(quint16)) return; in >> _sizeMessage; } if (socket->bytesAvailable() < _sizeMessage) return; QString message; in >> message; sendAll(message); _sizeMessage = 0; }
int command_list(Client *client, StringBuffer *command) { StringBuffer *msg = StringBuffer_construct(); StringBuffer_concat(msg, "Verbundene Clients("); char temp[15]; sprintf(temp, "%d", clientList->size); StringBuffer_concat(msg, temp); StringBuffer_concat(msg, ")\n"); int i = 0; // Build message for (i = 0; i < clientList->size - 1; ++i) { StringBuffer_concat(msg, "["); StringBuffer_concat(msg, clientVector_get(clientList, i)->name); StringBuffer_concat(msg, "]"); StringBuffer_concat(msg, ", "); } // Add last one without , StringBuffer_concat(msg, "["); StringBuffer_concat(msg, clientVector_get(clientList, i)->name); StringBuffer_concat(msg, "]"); // Send message to client sendAll(client->socket, msg->buffer, msg->size); StringBuffer_free(msg); return EXIT_SUCCESS; }
int Drawboard::sendDrawdata(Client *client,std::vector<uint8_t> data, uint8_t chan) { uint8_t tempdata[4]; std::vector<uint8_t> drawdata; //ToDo: add compression //Type byte drawdata.push_back(ACTION_DRAW_DATA); //Msg len, allocate the space drawdata.insert(drawdata.end(),&tempdata[0],&tempdata[0]+2); //UID putUint16(&tempdata[0],client->UID); drawdata.insert(drawdata.end(),&tempdata[0],&tempdata[0]+2); //the data drawdata.insert(drawdata.end(),&data[0],&data[0]+data.size()); //Fill in the length information putUint16(&drawdata[1], drawdata.size()-3); sendAll((uint8_t *)&drawdata[0],drawdata.size()); return 1; }
void *solicitar_solicitar_bytes(int socket_umv, uint32_t base, uint32_t offset, int tamanio, uint32_t id_programa, char origen, t_log *logger) { uint32_t bEnv = 0; char *orden = codificar_solicitar_bytes(base,offset,tamanio,id_programa); void *valorRetorno = NULL; t_paquete_programa paq_saliente; paq_saliente.id = origen; paq_saliente.mensaje = orden; log_info(logger, "[INTERFAZ_UMV] [ORDEN] [%c] - %s", origen, orden); paq_saliente.sizeMensaje = strlen(orden); char *paqueteSaliente = serializar_paquete(&paq_saliente, logger); bEnv = paq_saliente.tamanio_total; if(sendAll(socket_umv, paqueteSaliente, &bEnv)){ log_error(logger, "[INTERFAZ_UMV] Error en la solicitud de solicitar_bytes. Motivo: %s", strerror(errno)); free(paqueteSaliente); free(orden); return 0; } free(paqueteSaliente); free(orden); uint32_t bRec = 0; t_paquete_programa respuesta; log_info(logger, "[INTERFAZ_UMV] Esperando la respuesta de la UMV al comando solicitar_bytes."); bRec = recvAll(&respuesta, socket_umv); log_info(logger, "[INTERFAZ_UMV] La UMV respondió %s", respuesta.mensaje); valorRetorno = (void *) respuesta.mensaje; return valorRetorno; }
uint32_t solicitar_destruir_segmentos(int socket_umv, uint32_t id_programa, char origen, t_log *logger) { uint32_t bEnv = 0; char *orden = codificar_destruir_segmentos(id_programa); uint32_t valorRetorno = 0; t_paquete_programa paq_saliente; paq_saliente.id = origen; paq_saliente.mensaje = orden; log_info(logger, "[INTERFAZ_UMV] [ORDEN] [%c] - %s", origen, orden); paq_saliente.sizeMensaje = strlen(orden); char *paqueteSaliente = serializar_paquete(&paq_saliente, logger); bEnv = paq_saliente.tamanio_total; if(sendAll(socket_umv, paqueteSaliente, &bEnv)){ log_error(logger, "[INTERFAZ_UMV] Error en la solicitud de destrucción de segmentos. Motivo: %s", strerror(errno)); free(paqueteSaliente); free(orden); return 0; } free(paqueteSaliente); free(orden); return valorRetorno; }
int enviarDatos(FILE *script, int unSocket, t_log *logger) { uint32_t bEnv = 0; char *contenidoScript = NULL; char *paqueteSerializado = NULL; uint32_t sizeMensaje = 0; t_paquete_programa paquete; sizeMensaje = getFileSize(script); contenidoScript = calloc(sizeMensaje + 1, sizeof(char)); //sizeMensaje + 1, el contenido del script mas el '\0' cargarScript(script, &contenidoScript); inicializarPaquete(&paquete, sizeMensaje, &contenidoScript); paqueteSerializado = serializar_paquete(&paquete, logger); bEnv = paquete.tamanio_total; if(sendAll(unSocket, paqueteSerializado, &bEnv)){ log_error(logger, "Error en la transmisión del script. Motivo: %s", strerror(errno)); return 1; } log_info(logger, "Enviados %d bytes.", bEnv); free(contenidoScript); free(paqueteSerializado); return 0; }
void enviar_respuesta_buffer(int *socket, void *respuesta, uint32_t *tam_buffer, t_log *logger) { t_paquete_programa respuestaAlComando; respuestaAlComando.id = 'U'; if(respuesta == NULL){ log_error(logger, "[ATENCION_CONN] Algo va a reventar en cualquier momento, porque una llamada a solicitar_bytes está por retornar NULL"); } else { respuestaAlComando.mensaje = (char *) respuesta; respuestaAlComando.sizeMensaje = *tam_buffer; } char *respuesta_serializada = serializar_paquete(&respuestaAlComando, logger); int bEnv = respuestaAlComando.tamanio_total; if(sendAll(*socket, respuesta_serializada, &bEnv)){ log_error(logger, "[ATENCION_CONN] Error en el envío de la respuesta al comando. Motivo: %s", strerror(errno)); } log_info(logger, "[ATENCION_CONN] Ya envié la respuesta al comando solicitar_bytes. (Tamaño: %d bytes.)", bEnv); free(respuesta_serializada); return; }
void Game::start() { GameTime t; t.reset(); _gameTime = t.getElapsedTime(); _map.init(); _map.setDelegate(this); _numberOfPlayerAlive = _playerList.size(); Message msg; while (stillPlaying()) { while (t.getElapsedTime() - _gameTime < TIME_UNIT) { getPlayerActions(msg); } _gameTime = t.getElapsedTime(); addSpawn(); updateMap(); sendMap(msg); } _gameEnd = _gameTime; while (msg.time - _gameTime < 100) { msg.messageType = (_gameState == GAME_WON) ? MSG_WON : MSG_LOST; msg.time = t.getElapsedTime(); sendAll(msg); getPlayerActions(msg); } while (msg.time - _gameTime < 100) { for (std::list<Player *>::iterator it = _playerList.begin(); it != _playerList.end(); ++it) { (*it)->recvMsg(msg); } } release(); }
int broadcast(StringBuffer *msg) { // Send message to all clients int i; for(i = 0 ; i < clientList->size; ++i) { sendAll(clientVector_get(clientList, i)->socket, msg->buffer, msg->size); } return EXIT_SUCCESS; }
/* * appends newline if none at end of string * */ bool Socket::writeLine(const std::string& str) { char end = str[str.size()-1]; if(end != '\n' && end != '\r') { std::string temp = str; temp.append("\n"); if(!sendAll(temp.c_str(), temp.size())) return false; } else { if(!sendAll(str.c_str(), str.size())) return false; } return true; }
void Game::addPoints(int pts) { string t; score += pts; t += CMD_SCOR; t = Formater::pack<int>(t, score * 10); sendAll(t); }
//Search for the cliend and remove bool Drawboard::remClient(int m_fd) { uint32_t UID = -1; std::string nick; for (std::vector<Client*>::iterator it = m_clients.begin(); it!=m_clients.end(); ++it) { if((*it)->getFd() == m_fd) { if((*it)->UID > 0) { UID = (*it)->UID; nick = (*it)->nick; } //Close client socket #ifdef WIN32 closesocket(m_fd); #else close(m_fd); #endif delete *it; m_clients.erase(it); break; } } //ToDo: send info of removed client if(UID != -1) { uint8_t tempdata[2]; std::vector<uint8_t> remdata; //Type byte remdata.push_back(ACTION_USER_REM); //Datalen putUint16(&tempdata[0],4); remdata.insert(remdata.end(),&tempdata[0],&tempdata[0]+2); remdata.push_back(1); //Rem remdata.push_back(1); //Number of users //UID putUint16(&tempdata[0],UID); remdata.insert(remdata.end(),&tempdata[0],&tempdata[0]+2); sendAll((uint8_t *)&remdata[0],remdata.size()); } std::cout << "Client removed" << std::endl; return true; }
void Game::sendEntity(Message &msg, const Entity &e) { msg.messageType = MSG_GAME; msg.entity = e.getType(); msg.id = e.getId(); msg.isAlive = e.isAlive(); msg.posX = e.posX(); msg.posY = e.posY(); msg.time = _gameTime; sendAll(msg); }
void MonServeur::clientDisconnected() { sendAll("Un client vient de se déconnecter"); QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender()); if (socket == 0) return; qDebug() << "Client disconnected"; _clients.removeOne(socket); socket->deleteLater(); }
void sendMessage(char* input,char* handle,int cSocket,size_t hLen){ int inputLen = (int)strlen(input); int messageLen = (int)(hLen+inputLen); char* message = (char*)malloc(messageLen); strcpy(message,handle); strcat(message,input); int finalLen = strlen(message); if (sendAll(cSocket, message, &finalLen) == -1) { perror("sendall"); printf("We only sent %d bytes because of the error!\n", finalLen); } free(message); }
void SendCantConnectToClient(int fd){ int errorIndicator; char buf[MSGTXT_SIZE]; struct gameData newGame; int msgtxt_size = MSGTXT_SIZE; // -1 stands for too many clients connected newGame.valid = 0; createGameDataBuff(newGame, buf); errorIndicator = sendAll(fd, buf, &msgtxt_size); checkForNegativeValue(errorIndicator, "send", fd); close(fd); }
int handle_command(Client *client, StringBuffer *msg) { // Skip the COMMAND_START char *syntax = msg->buffer + 1; // Extract the args of the command char *args = strchr(syntax, ' '); int syn_len = 0; // Store the args in command buffer StringBuffer *command = NULL; // When command has arguments if (args != NULL) { syn_len = args - syntax; command = StringBuffer_construct(); StringBuffer_concat(command, args + 1); } else { syn_len = msg->size; } // List command if (strncmp(syntax, "list", syn_len) == 0) { command_list(client, command); } // Nick command else if (strncmp(syntax, "nick", syn_len) == 0) { command_nick(client, command); } // Message command else if (strncmp(syntax, "msg", syn_len) == 0) { command_msg(client, command); } // Unknown command! else { StringBuffer *errorMsg = StringBuffer_construct(); StringBuffer_concat(errorMsg, "ERROR: Unbekannter Befehl '"); StringBuffer_concat(errorMsg, syntax); StringBuffer_concat(errorMsg, "'!"); sendAll(client->socket, errorMsg->buffer, errorMsg->size); StringBuffer_free(errorMsg); } // Free temp memory if (command != NULL) StringBuffer_free(command); return EXIT_SUCCESS; }
void Server::manageClientMessages() { sf::TcpSocket* toRemove = 0; ClientManager* managerToRemove = 0; for (std::list<ClientManager*>::iterator it = cms.begin(); it!=cms.end(); ++it) { ClientManager* cm = *it; sf::TcpSocket* client = cm->getSocket(); if (selector.isReady(*client)) { MessageObject msg; sf::Packet packet; sf::TcpSocket::Status status = client->receive(packet); packet >> msg; if (status == sf::Socket::Done) { if (msg.type == MessageObject::START && msg.message == "start") { std::cout << "no more player\n"; canConnect = false; } if (msg.type == MessageObject::PLAYER && msg.message == "player") { sf::Mutex mutex; mutex.lock(); sf::Packet packet; client->receive(packet); std::stringstream ss; ss.write((char*)packet.getData(), packet.getDataSize()); //Player* player = getFromPacket<Player>(packet); //Player player; ss >> *player; map->updatePlayer(player); updatePlayers(); mutex.unlock(); } else { sf::Mutex mutex; mutex.lock(); cm->appendMessage(msg); //sendAllExceptSender(msg, *client); sendAll(msg); mutex.unlock(); } }
void sendClientConnected(int fd, struct gameData *data){ struct clientData thisClientData; char buf[MSG_SIZE]; // last one added thisClientData = ClientsQueue[conViewers+conPlayers]; data->valid = 1; data->msg = 0; data->myPlayerId = thisClientData.clientNum; data->playing = thisClientData.isPlayer; parseGameData(buf, data); int errorIndicator = sendAll(fd, buf, &msg_SIZE); checkForNegativeValue(errorIndicator, "send", fd); }
/** void Port::sendPortData (uint8_t portAddress) Sends port data to SCIO app via miniSDI_12 protocol. @param uint8_t portAddress portAddress must be a valid port address between 0 and PORT_MAX.Since port addresses start at 1 there is an offset of 1 between array position and port address. @return void **/ void Port::sendPortData (uint8_t portAddress){ if (portAddress == 0){ sendAll(); } else if (portAddress > PORT_MAX || portAddress < 0 || !(*ports[portAddress-1]).isActive()){ respond(0); } else if ((*ports[portAddress-1]).isActive()){ if ((*ports[portAddress-1]).getType() == SENSOR_TYPE_A){ dataReport(portAddress, RTC.now().unixtime(), (*ports[portAddress-1]).measureTemp()); } else if ((*ports[portAddress-1]).getType() == SENSOR_TYPE_B){ dataReport(portAddress, RTC.now().unixtime(), (*ports[portAddress-1]).measureLight()); } else{ respond(0); } } }
void sendFileContent(char* fileName, char* content, struct in_addr ip, int puerto) { t_header header; void* message; int contentLength = strlen(content) + 1; int messageLength = sizeof(t_header) + contentLength + sizeof(int) * 2 + strlen(fileName) + 1; header.tipoMensaje = EnvioArchivo; header.tamanioMensaje = messageLength - sizeof(t_header); message = malloc(messageLength); packHeader(header, message); packFile(fileName, content, contentLength, message); int sock; if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } struct sockaddr_in addr; addr.sin_addr = ip; addr.sin_family = AF_INET; addr.sin_port = puerto; memset(&(addr.sin_zero), '\0', 8); //Conecto al socket al FileSystem para notificar conexion del nodo if(connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) { perror("connect"); exit(1); } sendAll(sock, message, messageLength); return; }
void sendFileToReduce(char* fileName, char* content, struct in_addr ipJob, t_connection connection, int puertoNodo) { t_header header; void* message; int contentLength = strlen(content) + 1; int messageLength = sizeof(t_header) + contentLength + sizeof(int) * 2 + strlen(fileName) + 1 + sizeof(struct in_addr); header.tipoMensaje = EnvioArchivoAReducir; header.tamanioMensaje = messageLength - sizeof(t_header); message = malloc(messageLength); packHeader(header, message); packFile(fileName, content, contentLength, message); int offset = messageLength - sizeof(struct in_addr); memcpy(message + offset, (struct in_addr*) &ipJob, sizeof(struct in_addr)); int sock; if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } struct sockaddr_in addr; addr = connection.connectionAddr; addr.sin_port = puertoNodo; if(connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) { perror("connect"); exit(1); } sendAll(sock, message, messageLength); return; }
void Game::start() { if (started()) return; begin = now(); cout << "Starting game " << getId() << endl; time = 0; last = 0; pos = 0; endTime = -1; if (!thread) thread = new AbstractThread(threadFunc, (void*) this); string t(1, CMD_RUN); sendAll(t); PlayerList::iterator pl, plEnd = players.end(); for (pl = players.begin(); pl != plEnd; ++pl) { (*pl)->init(); } }
void sendBlock(t_bloque_datos block, struct in_addr ip, int puerto) { int messageLength = tamanio_bloque + sizeof(int) + sizeof(t_header); void* message = malloc(messageLength); t_header header; header.tamanioMensaje = messageLength - sizeof(t_header); header.tipoMensaje = EnvioBloque; packHeader(header, message); packBlock(block, message); int sock; if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket"); exit(1); } struct sockaddr_in addr; addr.sin_addr = ip; addr.sin_family = AF_INET; addr.sin_port = puerto; memset(&(addr.sin_zero), '\0', 8); //Conecto al socket al FileSystem para notificar conexion del nodo if(connect(sock, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) == -1) { perror("connect"); exit(1); } sendAll(sock, message, messageLength); return; }