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