void Client::seekParty() { _seek = true; std::stringstream str; if (_lvl < 4) _partySize = 1; else if (_lvl < 6) _partySize = 3; else if (_lvl < 8) _partySize = 5; else _partySize = 0; str << "broadcast " << _id << " seek " << _lvl << "\n"; while (_party != true || (_teammate.size() < _partySize && _leader == true)) { checkTime(); _lastCommand = BASIC; writeToSocket(str.str()); if (_party != true || (_teammate.size() < _partySize && _leader == true)) { forkUntil(_time - 100); searchFood(_time + 100); } _accept = false; _invite = false; } }
void Client::defineTime() { _lastCommand = INVENTORY; writeToSocket("inventaire\n"); parseInventory(); _time = (_inventory[0] - 1) * 126; refreshTime(); }
enum Client::e_step Client::sendTeamName(std::string const &buffer) { if (buffer == "BIENVENUE") { return Client::WELCOME_STEP; } writeToSocket(_teamName + "\n"); return Client::DATA_STEP; }
void GameState::send(Protocol::RequestType type, const QByteArray& bytes) throw (Protocol::SendingForbidden, Protocol::RequestTypeForbidden) { if ((type != Protocol::FLEET_INSTALLED) && (type != Protocol::TURN_MADE) && (type != Protocol::CHAT_MESSAGE) && (type != Protocol::PLAYER_QUIT)) { throw Protocol::RequestTypeForbidden(); } writeToSocket(type, bytes); }
void tcpConnectionListenerRunThread(TcpConnection tcpConnection){ TcpConnectionInternal* internal=(TcpConnectionInternal*)tcpConnection; //Declaring proc ess variables. int size ; void* buffer; void *commandBuffer; int commandSize; int currentSize; int tempSize=0; int result; while(internal->active==TRUE){ size=0; while(size<SIZE_OF_INT){ tempSize=read(internal->sockfd,&commandSize+size, SIZE_OF_INT-size); if(tempSize<=0){ internal->active=FALSE; distributionManagerHandleTcpConnectionListenerFailure(internal->distributionManager,internal,internal->coreManagerId); return; } size +=tempSize; } commandSize=htonl(commandSize); buffer=memoryAlloc(commandSize-SIZE_OF_INT); currentSize=0; while(currentSize<commandSize-SIZE_OF_INT){ currentSize+=read(internal->sockfd,buffer+currentSize, MIN(MAX_TCP_MESSAGE_SIZE,commandSize-currentSize-SIZE_OF_INT)); if(currentSize<=0){ internal->active=FALSE; distributionManagerHandleTcpConnectionListenerFailure(internal->distributionManager,internal,internal->coreManagerId); memoryFree(buffer); return; } } Command command=commandDeSerialize(buffer,commandSize-SIZE_OF_INT); commandPush(command,IP,STRING,internal->remoteIp,internal->remoteIpLenght); commandPush(command,PORT,INTEGER,&internal->remotePort); memoryFree(buffer); // handle message distributionManagerConsumeTcp(internal->distributionManager,command); // Create the result message and send it to client commandSize=commandSerialize(command,&commandBuffer); result=writeToSocket(internal->sockfd,commandBuffer,commandSize); memoryFree(commandBuffer); if(result<0){ internal->active=FALSE; distributionManagerHandleTcpConnectionListenerFailure(internal->distributionManager,internal,internal->coreManagerId); return; } // Delete all none model or none atomic commands if(commandIsDeleteOnExit(command)==TRUE){ commandFree(command); } } internal->readyForCleanup+=LISTENER_READY_FOR_CLEANUP; }
void pipeline::sendResponse() { this->preSendResponse(); std::map<std::string, std::string>::const_iterator ite; ite = this->_response->getHeaders().begin(); std::ostringstream oss; oss << "HTTP/1.1 " << this->_response->getStatusCode() << " " << this->_response->getReasonPhrase() << "\n"; writeToSocket(oss.str(), this->_client->getSocket()); while (ite != this->_response->getHeaders().end()) { writeHeaderToSocket(ite->first, ite->second, this->_client->getSocket()); ++ite; } writeToSocket("\n", this->_client->getSocket()); writeToSocket(this->_response->getBody(), this->_client->getSocket()); writeToSocket("\n", this->_client->getSocket()); //end }
int tcpConnectionSend(TcpConnection tcpConnection,Command command){ TcpConnectionInternal* internal=(TcpConnectionInternal*)tcpConnection; if(internal->active==FALSE){ return; } void *commandBuffer; int commandSize=commandSerialize(command,&commandBuffer); int result = writeToSocket(internal->sockfd,commandBuffer,commandSize); memoryFree(commandBuffer); return result; }
int ServerSocket::listenOnSocket() { int listenErr = listen(this->sockfd, BACKLOG); if (listenErr != 0) { printf("\nSocket Listen FAILED! %d\n", errno); return cleanup(); } printf("\nListening on %d...", PORT); acceptConnection(); printf("\nConnection Accepted!"); char *buf = new char[128]; char *start = buf; int len = readSocket(buf); printf("\nReceived %d bytes", len); printf("\nReceived %s", start); writeToSocket("RESPONSE"); return 0; }
//Tx thread function void *AgentTxThread(void *arg) { int errorReply = 0; int checksum; uint8_t msgSequence[MAX_AGENT_CONNECTIONS]; for (int i=0; i<MAX_AGENT_CONNECTIONS; i++) msgSequence[i] = 0; //loop while (1) { //wait for next message psMessage_t *txMessage = GetNextMessage(&agentQueue); for (int i=0; i<MAX_AGENT_CONNECTIONS; i++) { if (connected[i]) { pthread_mutex_lock(&agentMtx); int socket = txSocket[i]; //send STX writeToSocket( socket, STX_CHAR, &checksum, &errorReply); checksum = 0; //checksum starts from here //send header writeToSocket( socket, txMessage->header.length, &checksum, &errorReply); writeToSocket( socket, ~txMessage->header.length, &checksum, &errorReply); writeToSocket( socket, msgSequence[i]++, &checksum, &errorReply); writeToSocket( socket, txMessage->header.source, &checksum, &errorReply); writeToSocket( socket, txMessage->header.messageType, &checksum, &errorReply); //send payload uint8_t *buffer = (uint8_t *) &txMessage->packet; uint8_t size = txMessage->header.length; if (size > sizeof(psMessage_t) - SIZEOF_HEADER) { size = txMessage->header.length = sizeof(psMessage_t) - SIZEOF_HEADER; } while (size) { writeToSocket( socket, *buffer, &checksum, &errorReply); buffer++; size--; } //write checksum writeToSocket( socket, (checksum & 0xff), &checksum, &errorReply); if (errorReply != 0) { ERRORPRINT("agent: Tx send error: %s\n", strerror(errno)); AGENTsendErrors; close(socket); txSocket[i] = -1; connected[i] = false; } else { DEBUGPRINT("agent: %s message sent\n", psLongMsgNames[txMessage->header.messageType]); AGENTmessagesSent++; if (psDefaultTopics[txMessage->header.messageType] == LOG_TOPIC) { switch (txMessage->logPayload.severity) { case SYSLOG_INFO: agentInfo--; break; case SYSLOG_WARNING: agentWarning--; break; case SYSLOG_ERROR: agentError--; default: break; } } } pthread_mutex_unlock(&agentMtx); } } DoneWithMessage(txMessage); } return 0; }
int main(int argc, char *argv[]) { int serverSockId, clientSockId; struct sockaddr_in serverSockAddr,clientSocAddr; int status,serverStorageSize,i; char messageBuffer[4096]; int bytesRead; struct sockaddr_storage serverStorage; /* We will generate a socket for our usage. A descriptor */ serverSockId = socket( AF_INET, SOCK_STREAM, 0 ); if(serverSockId == -1) { printf("Something went wrong with socket generation.\nPlease try again :P \n"); return 0; } serverSockAddr.sin_family = AF_INET; serverSockAddr.sin_port = htons(atoi(argv[1])); serverSockAddr.sin_addr.s_addr = INADDR_ANY; /* We'll bind the descriptor with the socket. From now on we can refer to descriptor for the coket */ status = bind( serverSockId, (struct sockaddr *)&serverSockAddr, sizeof(serverSockAddr) ); if(status == -1) { fprintf(stderr,"This socket port seems occupied!\n"); return 0; } /* We'll start listenig through this socket, whether anyone wants to connect. */ int listenStatus = listen(serverSockId , 3); if(listenStatus < 0) { fprintf(stderr,"I can't listen to this port right now. Please try again!\n"); return 0; } serverStorageSize = sizeof(serverStorage); /* This is a persistence loop to facilitate for multiple connections - one by one. */ while(1) { /* We accept the connection request sent by client and receive a descriptor for the clients socket. */ clientSockId = accept( serverSockId, (struct sockaddr *)&serverStorage, &serverStorageSize ); if(clientSockId < 0) { printf("I can't accept this socket\n"); return 0; } /* Here's a pretty dumb and awesome thing we'll do. We'll treat the socket as a 'File'. Yes as a 'File'. We'll use two files. One for writng and the other for reading. We can generate the file pointers using fdopen. Read Man pages */ FILE *writeSocket = fdopen(clientSockId, "w"); FILE *readSocket = fdopen(dup(clientSockId),"r"); /* Empty the buffer and send a welcome message. */ memset(messageBuffer,0,4096); strcpy(messageBuffer, "Server: Welcome - We just connected\n"); writeToSocket(messageBuffer,writeSocket); while(1) { /* This loop is ensure the connection with the same client, unless the client itself closes connection. */ /* We read message from client( A File name) */ memset(messageBuffer,0,4096); bytesRead = fread( messageBuffer, 1, 4096, readSocket ); if(bytesRead == 0) { break; } printf("The client needs this file: %s\n", messageBuffer); /* Open the file required by the client */ FILE *file; file = fopen(messageBuffer,"r"); if(file == NULL) { /* If the clients request is erroneous, we need to tell the client its erroneous. */ memset(messageBuffer,0,4096); strcpy(messageBuffer,"Server: Such file doesn't exist\n"); intTostr(333); snprintf(messageBuffer+4091, 5, "%s",intstr); writeToSocket(messageBuffer,writeSocket); continue; } memset(messageBuffer,0,4096); strcpy(messageBuffer,"Server: I received your request\n\tHere are the File contents:"); intTostr(24); snprintf(messageBuffer+4091, 5, "%s",intstr); writeToSocket(messageBuffer,writeSocket); while(1) { /* This is a control loop for file reading. We read from a large file block by block into buffer and then transmit it. */ memset(messageBuffer,0,4096); bytesRead = fread(messageBuffer,1,4091,file); if(!bytesRead) { /* If EOF of file is reached, fread stops reading. So we send our custom EOF in the message buffer and then start listening for new message by breaking of this loop. */ memset(messageBuffer,0,4096); strcpy(messageBuffer,"<---EOF--->"); intTostr(11); snprintf(messageBuffer+4091, 5, "%s",intstr); writeToSocket(messageBuffer,writeSocket); break; } intTostr(bytesRead); /* We did something really cool here. We send the client how many bytes we read from file as a integer string in the last 5 bytes. So the client needs to just read those many bytes, although we send 4096 bytes through fwrite. */ snprintf(messageBuffer+4091, 5, "%s",intstr); writeToSocket(messageBuffer,writeSocket); } } fclose(readSocket); fclose(writeSocket); } return 0; }
void mdtTcpSocketThread::run() { Q_ASSERT(pvPort != 0); mdtTcpSocket *socket; pvPort->lockMutex(); // Init write frame pvWriteCurrentFrame = 0; // Get a RX frame pvReadCurrentFrame = getNewFrameRead(); if(pvReadCurrentFrame == 0){ mdtError e(MDT_TCP_IO_ERROR, "No frame available in read frames pool, stopping thread", mdtError::Error); MDT_ERROR_SET_SRC(e, "mdtTcpSocketThread"); e.commit(); pvRunning = false; pvPort->unlockMutex(); return; } // Alloc the local buffer pvReadBufferSize = pvReadCurrentFrame->capacity(); pvReadBuffer = new char[pvReadBufferSize]; if(pvReadBuffer == 0){ mdtError e(MDT_TCP_IO_ERROR, "Cannot allocate memory for local read buffer" , mdtError::Error); MDT_ERROR_SET_SRC(e, "mdtTcpSocketThread"); e.commit(); pvRunning = false; pvReadBufferSize = 0; pvPort->unlockMutex(); return; } //bufferCursor = buffer; // Create a Tcp socket pvSocket = new QTcpSocket; Q_ASSERT(pvSocket != 0); // We must pass this socket object to pvPort // pvPort must be a instance of mdtTcpSocket socket = dynamic_cast<mdtTcpSocket*>(pvPort); Q_ASSERT(socket != 0); socket->setThreadObjects(pvSocket, this); // Set the running flag pvRunning = true; // Run... while(1){ // Read thread state if(!pvRunning){ break; } // Check if a connection was requested if(pvPeerPort == 0){ socket->waitForNewTransaction(); } if(pvSocket->state() == QAbstractSocket::ConnectedState){ // Wait on write ready event if(!pvPort->waitEventWriteReady()){ emit(errorOccured(MDT_TCP_IO_ERROR)); /// NOTE: sleep ? } // Read thread state if(!pvRunning){ break; } // ********************** // Event occured, send the data to port - Check timeout state first if(!pvPort->writeTimeoutOccured()){ // Write data to send writeToSocket(); } // Wait until data is available for read if(!pvPort->waitForReadyRead()){ emit(errorOccured(MDT_TCP_IO_ERROR)); /// NOTE: sleep ? } // Read thread state if(!pvRunning){ break; } // ********************** // Event occured, get the data from port - Check timeout state first if(!pvPort->readTimeoutOccured()){ // We received data , read it readFromSocket(); } }else{ // Try to (Re-)connect if(!reconnectToHost()){ qDebug() << "TCP THD: SIGNAL: Cannot reconnect - Retry at next transaction ..."; socket->waitForNewTransaction(); } } } // Put current frame into pool if(pvReadCurrentFrame != 0){ pvPort->readFramesPool().enqueue(pvReadCurrentFrame); } // End connection if(pvSocket->state() == QAbstractSocket::ConnectedState){ pvSocket->disconnectFromHost(); if(pvSocket->state() != QAbstractSocket::UnconnectedState){ // Wait on disconnected if(!pvSocket->waitForDisconnected(500)){ mdtError e(MDT_TCP_IO_ERROR, "Cannot wait for disconnected" , mdtError::Error); e.setSystemError(pvSocket->error(), pvSocket->errorString()); MDT_ERROR_SET_SRC(e, "mdtTcpSocketThread"); e.commit(); } } } // Free memory Q_ASSERT(pvReadBuffer != 0); delete pvReadBuffer; pvPort->unlockMutex(); }
void ChatRoomBroadCastSocket::sendPrivateChat(QString identifier) { writeToSocket(PRIVATECHAT, identifier); }
void ChatRoomBroadCastSocket::sendParticipantLeft() { writeToSocket(PARTICIPANTLEFT); }
void ChatRoomBroadCastSocket::sendNewParticipant() { writeToSocket(NEWPARTICIPANT); }
void ChatRoomBroadCastSocket::sendMessage(QString message) { writeToSocket(MESSAGE, message); }
void ChatRoomBroadCastSocket::run() { writeToSocket(NEWPARTICIPANT); }