int NetworkHandler::meetClient(int pSocket)
{
_runClient = 0; /* Verificador del ciclo. */
_exitCode = 0; /* Código de salida por defecto */
while (!_runClient)
{
/* Setear el buffer a cero. */
memset(_inBuffer, 0, BUFFERSIZE);
/* Recivimos la información y al mismo tiempo evaluamos si llego correctamente. */
if ((_byteCount = recv(pSocket, _inBuffer, BUFFERSIZE, 0))== -1)
{
Error(5, "No se pudo recibir la información.");
}
if(_byteCount == 0)
{
std::cout << "!ATENCIÓN! El cliente " << inet_ntoa(_clientIP.sin_addr) << " se ha desconectado inesperadamente, conexión perdida." << std::endl;
_runClient = 1;
}
/* Se convierte el _inBuffer de char a string para un manejo más fácil. */
std::string inMessageBuffer = _inBuffer;
/* Se envia el mensaje a otro método para su posterior evaluación. */
inMessage(inMessageBuffer, pSocket);
}
close(pSocket); /* Se cierra la conexión del cliente. */
return _exitCode; /* Retorna el codigo de salida */
}
int WebSocketQueue::callback(libwebsocket_context *context, libwebsocket *wsi,
LibWebsocketsCallbackReasonBoxed const& reasonBoxed,
void *user, void *in, size_t len)
{
WebSocketQueue *self = (WebSocketQueue*)libwebsocket_context_user(context);
PerSession *perSession = (PerSession*)user;
libwebsocket_callback_reasons reason = reasonBoxed.value;
// reason for callback
switch (reason) {
case LWS_CALLBACK_FILTER_NETWORK_CONNECTION: {
if (self->sessions_.size() >= self->maxSessionCount_) {
GATEY_LOG("not accepting connection because already connected");
return -1;
}
break;
}
case LWS_CALLBACK_ESTABLISHED:
*perSession = PerSession(self->nextUniqueSessionId_);
self->nextUniqueSessionId_++;
self->sessions_.insert(perSession->sessionId);
if (self->sessions_.size() > self->maxSessionCount_) {
GATEY_LOG("connection established but will be canceled" + std::to_string(perSession->sessionId));
return -1;
}
GATEY_LOG("connection established" + std::to_string(perSession->sessionId));
break;
case LWS_CALLBACK_RECEIVE: {
char const* bytes = (char const*)in;
InMessage inMessage(perSession->sessionId, bytes, len);
self->inMessages_.push_back(std::move(inMessage));
GATEY_LOG("received message");
break;
}
case LWS_CALLBACK_SERVER_WRITEABLE: {
//Send messages from the queue
auto found = self->firstMessageWithDestination(perSession->sessionId);
if (found == self->outMessages_.end())
break;
OutMessage& message = *found;
libwebsocket_write(wsi, (unsigned char*)&message.buffer_[LWS_SEND_BUFFER_PRE_PADDING], message.len_, LWS_WRITE_TEXT);
message.removeDestination(perSession->sessionId);
self->messageSent_ = true;
break;
}
case LWS_CALLBACK_CLOSED: {
self->sessions_.erase(perSession->sessionId);
for(OutMessage& outMessage : self->outMessages_) {
outMessage.removeDestination(perSession->sessionId);
}
//TODO: Remove already received messages? no
// std::remove_if(self->inMessages_.begin(), self->inMessages_.end(),
// [sessionId](InMessage const& message)
// {
// return message.sessionId_ == sessionId;
// });
GATEY_LOG("connection closed" + std::to_string(perSession->sessionId));
break;
}
default: break;
}
return 0;
}
int main(int argc, char* argv[])
{
(void) argc; // suppress unused parameter warnings
(void) argv; // suppress unused parameter warnings
struct sockaddr_in myaddr; /* our address */
struct sockaddr_in remaddr; /* remote address */
socklen_t addrlen = sizeof(remaddr); /* length of addresses */
int recvlen; /* # bytes received */
int fd; /* our socket */
unsigned char buf[BUFFER_SIZE]; /* receive buffer */
/* create a UDP socket */
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("cannot create socket\n");
return 0;
}
UdpTransmitSocket transmitSocket( IpEndpointName( SEND_ADDRESS, SEND_PORT ) );
// The buffer out
char buffer[BUFFER_SIZE];
osc::OutboundPacketStream p( buffer, BUFFER_SIZE );
/* bind the socket to any valid IP address and a specific port */
memset((char *)&myaddr, 0, sizeof(myaddr));
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
myaddr.sin_port = htons(RECEIVE_PORT);
if (bind(fd, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
perror("bind failed");
return 0;
}
else{
printf("Listening to port %d\n", RECEIVE_PORT);
}
/* now loop, receiving data and printing what we received */
for (;;) {
recvlen = recvfrom(fd, buf, BUFFER_SIZE, 0, (struct sockaddr *)&remaddr, &addrlen);
if (recvlen > 0) {
buf[recvlen] = 0;
// retrieving the data from the udp message
std::string inMessage( buf, buf + sizeof buf / sizeof buf[0] ); // converting the input buffer to a string
// counting the number of semicolons to detect the number of messages in the packet
int nParams = std::count(inMessage.begin(), inMessage.end(), ';')-2;
for(int i=0; i<nParams; i++){
std::string oscAddress = OSC_BASE_ADDRESS;
oscAddress.append(inMessage.substr(0,inMessage.find(":")));
std::string oscValueString = inMessage.substr(inMessage.find(":")+1,inMessage.find(";")-inMessage.find(":")-1);
// making sure that the received message is valid
if(!std::all_of(oscValueString.begin(), oscValueString.end(), ::isdigit)){
float oscValue = stof(oscValueString);
//printf("Rec: %s: ",oscAddress.c_str());
//printf("%f\n", oscValue);
inMessage = inMessage.substr(inMessage.find("\n")+1,inMessage.find(";;")-inMessage.find("\n"));
// formating and sending the OSC message
p.Clear();
p << osc::BeginMessage(oscAddress.c_str())
<< oscValue << osc::EndMessage;
transmitSocket.Send( p.Data(), p.Size() );
}
else printf("Dropped message\n");
}
}
}
/* never exits */
}
void ThousandClientDataParser::incomingData()
{
QueryStruct query;
quint16 blockSize = 0;
QTcpSocket *socket = workClient->connection;
QDataStream stream(socket);
quint16 requestSize = sizeof(QueryStruct) - 2 * sizeof(quint16);
QByteArray incomingRequest;
while (requestSize) {
blockSize = socket->bytesAvailable();
if (blockSize > requestSize) blockSize = requestSize;
if (!blockSize) {
emit(workClient->erorText("Invalid size of query"));
break;
}
char *buffer = new char[blockSize];
stream.readRawData(buffer, blockSize);
incomingRequest += QByteArray::fromRawData(buffer, blockSize);
requestSize -= blockSize;
blockSize = 0;
delete []buffer;
}
QDataStream reader(incomingRequest);
reader>>query; //Извлекаем структуру с запросом из входящего потока
QByteArray data;
requestSize = query.size;
while (requestSize) {
blockSize = socket->bytesAvailable();
if (blockSize > requestSize) blockSize = requestSize;
if (!blockSize) {
emit(workClient->erorText("Invalid size of query"));
break;
}
char *buffer = new char[blockSize];
stream.readRawData(buffer, blockSize);
data += QByteArray::fromRawData(buffer, blockSize);
requestSize -= blockSize;
blockSize = 0;
delete []buffer;
}
switch(query.type)
{
case REGISTER:
inRegistration(data);
break;
case AUTHORIZATION:
inAuthorization(data);
break;
case MESSAGE:
inMessage(data);
break;
case NEWGAME:
inNewGame(data);
break;
case CONNECTGAME:
inConnectToGame(data);
break;
case DISCONNECTGAME:
inDisconnectGame(data);
break;
case STARTGAME:
inStartGame(data);
break;
case CANCELGAME:
inCancelGame(data);
break;
case FINISHGAME:
inFinishGame(data);
break;
case LISTALLCURRENTGAME:
inListAllGame(data);
break;
case LISTALLNEWGAME:
inListAllNewGame(data);
break;
case TOTALSTATISTICS:
inTotalStatistics(data);
break;
case PLAYERSTATISTICS:
inPlayerStatistics(data);
break;
case MOVE:
inMove(data);
break;
}
}
