Esempio n. 1
0
unsigned char
ngl_net_read_client(char num)
{
	if (num==0) {
		if (SDLNet_TCP_Recv(csd0, buffer0, 512) > 0) {
			return 1;
		}

		return 0;
	}

	if (num==1) {
		if (SDLNet_TCP_Recv(csd1, buffer1, 512) > 0) {
			return 1;
		}

		return 0;
	}

	if (num==2) {
		if (SDLNet_TCP_Recv(csd2, buffer2, 512) > 0) {
			return 1;
		}

		return 0;
	}

	return 0;
}
Esempio n. 2
0
PMRECV PacketManager::Recv(TCPsocket socket, Uint16 *packetID, Uint16 *packetLength){
  if(bufferSize<4)if(!Allocate(4))return PMRECV_ALLOCFAIL;
  Uint8 *buff = buffer; Uint16 len = 4; int ret = 0;
  while(len > 0){
    ret = SDLNet_TCP_Recv(socket, buff, len);
    if((ret<=0)||(ret>len))return ((ret == 0)?PMRECV_DISCONNECT:PMRECV_ERROR);
    len -= ret;
    buff += ret;
  }
  lastPackID = SDLNet_Read16(buffer);
  lastPackLen = SDLNet_Read16(buffer + sizeof(Uint16));
  Uint32 size = (Uint32)lastPackLen + 4;
  if((maxAllocSize != 0)&&(size > maxAllocSize))return PMRECV_OVERFLOW;
  if(size > bufferSize)if(!Allocate(size))return PMRECV_ALLOCFAIL;
  buff = buffer + 4; len = lastPackLen; ret = 0;
  while(len > 0){
    ret = SDLNet_TCP_Recv(socket,buff,len);
    if((ret<=0)||(ret>len))return ((ret == 0)?PMRECV_DISCONNECT:PMRECV_ERROR);
    len -= ret;
    buff += ret;
  }
  dataLength = size;
  dataPos = 4;
  return PMRECV_SUCCESS;
}
Esempio n. 3
0
static int Treception(void *ptr)
{
    Data data;                /* buffer de réception */
    DataList dataList;        /* buffer de réception pour les listes de salles*/
    DataGame dataGame;        /* buffer de réception pour les données de jeu*/

    int cnt;
    bool stopNetwork=false;

    while(!stopNetwork)
    {
        cnt = SDLNet_TCP_Recv(sd, &data, sizeof(Data));
        if(cnt <= 0)
            return cnt;
        (*mCData)(&data);
        if(data.dataType == CONN)
        {
            if(data.car == SWITCH) // on nous prévient que une dataList va être transmise
            {
                do
                {
                    cnt = SDLNet_TCP_Recv(sd, &dataList, sizeof(DataList));
                    (*mCList)(&dataList);

                }
                while(cnt>0 && !dataList.end);
            }
            else if(data.car == CONN_QUIT)
                stopNetwork = true;
            else if(data.car == CONN_ERROR)
                stopNetwork=true;
            else if(data.car == CONN_STOP)
                stopNetwork=true;

        }
        else if(data.dataType == GAME)
        {
            if(data.car == SWITCH) // on nous prévient que une dataGame va être transmise
            {
                if(waiting)
                {
                    printf("reception thread is waiting main thread to switch to game\n");
                    while(waiting){}
                }
                cnt = SDLNet_TCP_Recv(sd, &dataGame, sizeof(DataGame));
                (*mCGame)(&dataGame);
            }
            else if(data.car == GAME_ERROR)
            {
                stopNetwork=true;
            }
        }
        if(cnt <= 0)
            stopNetwork=true;
    }
    printf("Treception terminé\n");
    return cnt;
}
Esempio n. 4
0
std::string TCPConnectionServer::ReadMessages( int connectionNr )
{
	if ( !CheckForActivity( connectionNr ) )
		return "";

	char buffer[1024];
	memset( buffer, 0, bufferSize );

	int byteCount  = 0;
	std::string received("");

	if ( isSocketConnected.size() <  ( connectionNr + 1 ) )
		return received;

	if ( isServer )
		byteCount = SDLNet_TCP_Recv( serverSocket[connectionNr], buffer, bufferSize );
	else
		byteCount = SDLNet_TCP_Recv( tcpSocket, buffer, bufferSize );

	if ( byteCount > 0 )
	{
		//memset( &buffer[byteCount], 0, static_cast< size_t > (512 - byteCount ) );
		buffer[byteCount] = '\0';
		received = buffer;

		if ( byteCount >= bufferSize )
		{
			std::cout << "TCPConnection.cpp@" << __LINE__
				<< " Too much data received : " << byteCount
				<< " / " << bufferSize
				<< std::endl;
		}

	}
	// A bytecount of 0 means the connection has been terminated
	else if ( byteCount == 0 )
	{
		std::cout << "TCPConnection.cpp@" << __LINE__ << " Connection terminated" << std::endl;
		isSocketConnected[ connectionNr ] = false;

	// A bytecount of < 0 means an error occured
	} else if ( byteCount < 0 )
	{
		std::cout << "TCPConnection.cpp@" << __LINE__ << " Read failed!" <<
			"\nSocket : " << ( isServer ? serverSocket[connectionNr] : tcpSocket )  <<
			"\nByte count : " << byteCount <<
			"\nError : " << SDLNet_GetError() <<
			std::endl;
	}

	return received;
}
Esempio n. 5
0
char *network_read_string_1(TCPsocket sock) {
	uint8_t len;
	SDLNet_TCP_Recv(sock,&len,1);
	int read = 0;
	char *text = malloc(len+1);
	while (read != len) {
		int more = SDLNet_TCP_Recv(sock,text,len-read);
		if (more < 1)
			return 0;
		read += more;
	}
	text[len] = 0;
	return text;
}
Esempio n. 6
0
void NetworkManager::NetworkCommunicator()    //make it receive paddlemanagers and ballmanagers to change positions into messages (break up server messages since it'll send ball and paddle to network... easy to write, not to read)
{                           //call this from game loop
	int len;				//	commented out code should be correct (I can't check it yet though) once networking works right
	char buffer[512];	
	//
	char str[512];
	if(!server)
	{
		//strcpy(buffer,NetworkManager::Vector3ToString(clientPaddle->getPosition()));
		len = strlen(buffer) + 1;
		if (SDLNet_TCP_Send(targetSocket, (void *)buffer, len) < len)
		{
			fprintf(stderr, "SDLNet_TCP_Send: %s\n", SDLNet_GetError());
			exit(EXIT_FAILURE);
		}
		if (SDLNet_TCP_Recv(targetSocket, buffer, 512) > 0)
		{
			std::string decode = std::string(buffer);
			unsigned found = decode.find_first_of("&");
			Ogre::Vector3 v = NetworkManager::StringToVector3(buffer,0);
			//hostPaddle->setPosition(v);
			v = NetworkManager::StringToVector3(buffer,found+1);
			//ball->setPosition(v);
			printf("Host say: %s\n", buffer);
		
		}
	}
	else
	{

		if (SDLNet_TCP_Recv(targetSocket, buffer, 512) > 0)
		{
			Ogre::Vector3 v = NetworkManager::StringToVector3(buffer,0);
			//clientPaddle->setPosition(v);
			printf("Client say: %s\n", buffer);
		}
		//strcpy(str, NetworkManager::Vector3ToString(hostPaddle->getPosition()));
		strcat(str, " ");
		//strcat(str, NetworkManager::Vector3ToString(ball->getPosition()));
		strcpy(buffer,str);
		//strcpy(buffer,"test reply");
		int len = strlen(buffer) + 1;
		if (SDLNet_TCP_Send(targetSocket, (void *)buffer, len) < len)
		{
			fprintf(stderr, "SDLNet_TCP_Send: %s\n", SDLNet_GetError());
			exit(EXIT_FAILURE);
		}
	}
}
Esempio n. 7
0
// receive a buffer from a TCP socket with error checking
// this function handles the memory, so it can't use any [] arrays
// returns 0 on any errors, or a valid char* on success
char *getMsg(TCPsocket sock, char **buf)
{
	Uint32 len,result;
	static char *_buf;

	// allow for a NULL buf, use a static internal one...
	if(!buf)
		buf=&_buf;
	
	// free the old buffer
	if(*buf)
		free(*buf);
	*buf=NULL;

	// receive the length of the string message
	result=SDLNet_TCP_Recv(sock,&len,sizeof(len));
	if(result<sizeof(len))
	{
		if(SDLNet_GetError() && strlen(SDLNet_GetError())) // sometimes blank!
			printf("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
		return(NULL);
	}
	
	// swap byte order to our local order
	len=SDL_SwapBE32(len);
	
	// check if anything is strange, like a zero length buffer
	if(!len)
		return(NULL);

	// allocate the buffer memory
	*buf=(char*)malloc(len);
	if(!(*buf)){
		return(NULL);
	}
	// get the string buffer over the socket
	result=SDLNet_TCP_Recv(sock,*buf,len);
	if(result<len)
	{
		if(SDLNet_GetError() && strlen(SDLNet_GetError())) // sometimes blank!
			printf("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
		free(*buf);
		buf=NULL;
	}

	// return the new buffer
	return(*buf);
}
Esempio n. 8
0
File: io.c Progetto: neosam/s3d
int listenToCode(TCPsocket tcpclient, char *answer)
{
	int brakets = 0;
	int i;
	char *data = MALLOCN(char, 4096);
	int size = 0;

	for (;;) {
		answer += size;
		size = SDLNet_TCP_Recv(tcpclient, data, 4095);
		data[size] = '\0';
		memcpy(answer, data, size);
		for (i = 0; i < size; i++) {
			switch (answer[i]) {
			case '(':
				brakets++;
				break;
			case ')':
				brakets--;
				if (brakets == 0) {
					answer[i+1] = '\0';
					return 0;
				}
				if (brakets < 0)
					return -1;
				break;
			}
		}
	}
}
Esempio n. 9
0
void NetClient::handleserver()
{
	Uint8 data[512];
	int pos, len;
//	int used;

	/* Has the connection been lost with the server? */
	len = SDLNet_TCP_Recv(tcpsock, (char *)data, 512);

    if ( len <= 0 ) {
		SDLNet_TCP_DelSocket(socketset, tcpsock);
		SDLNet_TCP_Close(tcpsock);
		tcpsock = NULL;

    } else {
		pos = 0;
        while ( len > 0 ) {
			int used = handleserverdata(&data[pos]);
			pos += used;
			len -= used;
			
            if ( used == 0 ) {
				/* We might lose data here.. oh well,
				   we got a corrupt packet from server
				 */
				len = 0;
			}
		}
	}
}
Esempio n. 10
0
int SDLNet_TCP_RecvLine(TCPsocket sock, char* data, int maxlen) {
  
  char c;
  int status = 0;
  int i = 0;
  while(1) {
    
    status = SDLNet_TCP_Recv(sock, &c, 1);
    
    if (status == -1) return -1;
    if (i == maxlen-1) return -1;
    if (status == 0) break;
    
    data[i] = c;
    i++;
    
    if (c == '\n') {
      data[i] = '\0';
      return i;
    }
  }
  
  if(i > 0) {
    data[i] = '\0';
    return i;
  } else {
    return 0;
  }
  
}
Esempio n. 11
0
/* Setup TCP Client, and attempt to connect
 * to the server */
int setup_client(unsigned port) {

#if !defined(PSP) && !defined(EMSCRIPTEN) && !defined(DREAMCAST) && !defined(THREE_DS)
    is_client = 1;

    log_message(LOG_INFO, "Attempting to connect to server on port %u\n",port);
    //SDL_INIT(SDL_INIT_EVERYTHING); 
    SDLNet_Init();   

    IPaddress ip;
    //TODO, for now always connect to localhost, fix for any specified ip in
    //the future
    SDLNet_ResolveHost(&ip, "localhost", port);

    client =  SDLNet_TCP_Open(&ip);
    socketset = SDLNet_AllocSocketSet(1); 
    char buf[100];
    int i = SDLNet_TCP_Recv(client, buf, 100);
    for (int j = 0; j < i; j++) {
        printf("%c",buf[j]);
    }
    printf("\n");
    SDLNet_TCP_AddSocket(socketset, client);
    connection_up = 1;
    return 1;
#endif
    return 0;

}
Esempio n. 12
0
void mythVirtualServer::HandleClient(int which)
{
	int closesocket;
	char data[4096] = {0};
	//char tmpdata[512] = {0};
	int datalength;
	int length;
	datalength = 0;
	for(;;){
		length = SDLNet_TCP_Recv(people[which]->sock, data + datalength, 512);
		datalength += length;
		if(length < 512)
			break;
	}
    /* Has the connection been closed? */
    if ( datalength <= 0 ) {
#ifdef DEBUG
    fprintf(stderr, "Closing socket %d (was%s active)\n",
            which, people[which].active ? "" : " not");
#endif
        /* Notify all active clients */
		closePeople(people[which]);
    } else {
		this->ServerDecodeCallBack(people[which],data,datalength);
    }
}
Esempio n. 13
0
File: net.c Progetto: esohns/jnb
/** read a packet from the given TCPsocket
Returns -1 if some error occured, 0 if there was no data available and 1 if a
packet was successfully read.
Note: the socket has to be in the supplied socketset.
TODO: this function will bomb if a packet arrives in pieces, there is no
inherent guarantee that the next call will be made on the same socket. */
int
grabPacket(TCPsocket s, SDLNet_SocketSet ss, struct NetPacket* pkt)
{
	static char buf[NETPKTBUFSIZE];
	static int buf_count = 0;
	int rc;

	if (SDLNet_CheckSockets(ss, 0) <= 0)
		return 0;

	if(!SDLNet_SocketReady(s))
		return 0;

	rc = SDLNet_TCP_Recv(s, &buf[buf_count], NETPKTBUFSIZE - buf_count);
	if (rc <= 0) {
		/* closed connection? */
		return -1;
	} else if (rc != NETPKTBUFSIZE) {
		/* we got a partial packet. Store what we got in the static buffer and
		return so that the next call can read the rest. Hopefully. */
		buf_count = rc;
		return 0;
	} else {
		buf_count = 0;
		bufToPacket(buf, pkt);
		return 1;
	}
}
Esempio n. 14
0
int Server::script_client(void* data) throw(const char*){
	Data_scriptClient* _data_cast=static_cast<Data_scriptClient*>(data);
	if(_data_cast==NULL){
		throw "Impossibile eseguire il casting dei dati nello script client!";
	}
	int bytes_rcv;
	char buffer[MAX_BYTES_BUFFER];
	std::string data_store_rcv;
	std::string data_store_snd;
	int result;
	AppProtServer client_prot;
	while(_data_cast->exit==false){
		bytes_rcv=SDLNet_TCP_Recv(_data_cast->connessione, buffer, MAX_BYTES_BUFFER);
		if(bytes_rcv<=0){
			_data_cast->exit=true;
		}else{
			data_store_rcv.append(buffer,bytes_rcv);
			result=client_prot.ElaboraRichiesta(data_store_rcv,data_store_snd);
			if(result){
				int bytes_snd=SDLNet_TCP_Send(_data_cast->connessione, data_store_snd.data(), data_store_snd.size());
				if(bytes_snd!=data_store_snd.size()){
					_data_cast->exit=true;
				}
			}
			if(result==-1){
				_data_cast->exit=true;
			}
		}
	}
	return 0;
}
Esempio n. 15
0
int network_tcp_recv(TCPsocket tcp, void* data, int maxlen) {
        int r = SDLNet_TCP_Recv(tcp, data, maxlen);
        if (r <= 0) {
                std::cerr << "Failed to recieve data over TCP: " << SDLNet_GetError() << "\n";
        }
        return r;
}
Esempio n. 16
0
bool
receiveTCP(TCPsocket socket, char *buffer, int size)
{
    if (SDLNet_TCP_Recv(socket, buffer, size) > 0)
        return (true);
    return (false);
}
Esempio n. 17
0
/*一行読み込み*/
char* NetUtl_readLine(TCPsocket* sock){
	//マルチスレッディングだとバグが出そうなんですが
	static char* buff = NULL;
	char ch;
	int buff_len = 0,length;
	//バッファクリア
	free(buff);
	buff = NULL;
	//ループ
	while((length = SDLNet_TCP_Recv(*sock, &ch, 1)) == 1){
		if(ch == '\r')continue;
		buff = realloc(buff,buff_len+1);
		if(ch == '\n'){
			buff[buff_len] = '\0';
			break;
		}
		buff[buff_len] = ch;
		buff_len++;
	}
	//エラー
	if(length <= 0){
		if(buff_len <= 0){
			free(buff);
			buff = NULL;
		}else{
			buff = realloc(buff,buff_len+1);
			buff[buff_len]='\0';
		}
	}
	return buff;
}
int clientConnection(TCPsocket *socketPekare)
{
    client_send_information clientSendData;
    client_recieve_information clientRecieveData;

    int len1,len2;
    len1 = sizeof(clientSendData);
    len2 = sizeof(clientRecieveData);
    char serialiseradStruct1[len1];
    char serialiseradStruct2[len2];

    while(1)
    {
        SDL_Delay(10);

        convertSend(&clientSendData);
        memcpy(&serialiseradStruct1, &clientSendData, len1);
        SDLNet_TCP_Send(*socketPekare, &serialiseradStruct1, len1);

        SDL_Delay(10);

        SDLNet_TCP_Recv(*socketPekare,&serialiseradStruct2,len2);
        memcpy(&clientRecieveData,&serialiseradStruct2,len2);
        convertRecieve(&clientRecieveData);
    }

    return 0;
}
Esempio n. 19
0
	  int TCP_RECEIVEOBJ::read_tcp(char * readbuf, int size)
	  {
		int len;
		bool reading=true;	
		char tempbuf[readbuflength];

		reading=true;
		readbuf[0]=0;
		while (reading)
		{
			if (SDLNet_CheckSockets(set, sockettimeout) == -1)  return(TCP_BAD_REQUEST);
				
			if (SDLNet_SocketReady(sock))
			{
				if ((len = SDLNet_TCP_Recv(sock, tempbuf, size)) <= 0) return(TCP_ERROR);
				
				tempbuf[len] = '\0';
				if (strlen(readbuf) + strlen(tempbuf) <= (unsigned int)size) strcat (readbuf, tempbuf);
				if (strlen(readbuf)>=(unsigned int)size) reading=false;
			}
			else reading=false;
		
		}
		cout << readbuf;
	    return (TCP_OK);
	  }
Esempio n. 20
0
//-----------------------------------------------------------------------------
uint8_t* RecvData(int index, uint16_t* length, uint16_t* flag) {
	uint8_t temp_data[MAX_PACKET];
	int num_recv = SDLNet_TCP_Recv(sockets[index], temp_data, MAX_PACKET);

	if(num_recv <= 0) {
		CloseSocket(index);
		const char* err = SDLNet_GetError();
		if(strlen(err) == 0) {
			printf("DB: client disconnected\n");
		} else {
			fprintf(stderr, "ER: SDLNet_TCP_Recv: %s\n", err);
		}

		return NULL;
	} else {
		int offset = 0;
		*flag = *(uint16_t*) &temp_data[offset];
		offset += sizeof(uint16_t);

		*length = (num_recv-offset);

		uint8_t* data = (uint8_t*) malloc((num_recv-offset)*sizeof(uint8_t));
		memcpy(data, &temp_data[offset], (num_recv-offset));

		return data;
	}
}
Esempio n. 21
0
void NetServer::handleclient(int which)
{
	char data[512];
	int i;

	/* Has the connection been closed? */
    if (SDLNet_TCP_Recv(clients[which].sock, data, 512) <= 0) {

#ifdef _DEBUG
		printf("Closing socket %d (was%s active)\n", which, clients[which].active ? "" : " not");
#endif
		/* Notify all active clients */
        if (clients[which].active) {
			clients[which].active = 0;
			data[0] = NET_MSG_DEL;
			data[NET_MSG_DEL_SLOT] = which;
			
            for (i = 0; i < MAXCLIENTS; ++i) {
                if (clients[i].active) {
					SDLNet_TCP_Send(clients[i].sock, data, 2);
				}
			}
		}
		
		SDLNet_TCP_DelSocket(socketset, clients[which].sock);
		SDLNet_TCP_Close(clients[which].sock);
		clients[which].sock = NULL;
    } else {
        switch (data[0]) {
        case NET_MSG_JOIN: {
				/* An active connection */
				memcpy(clients[which].name, &data[NET_MSG_JOIN_NAME], 256);
				clients[which].name[256] = 0;
#ifdef _DEBUG
				printf("Activating socket %d (%s)\n", which, clients[which].name);
#endif
				/* Notify all active clients */
            for (i = 0; i < MAXCLIENTS; ++i) {
                if (clients[i].active) {
						sendnewclientmessage(which, i);
					}
				}

				/* Notify about all active clients */
				clients[which].active = 1;
            for (i = 0; i < MAXCLIENTS; ++i) {
                if (clients[i].active) {
						sendnewclientmessage(i, which);
					}
				}
			}
			break;
        default: {
				/* Unknown packet type?? */;
			}
			break;
		}
	}
}
Esempio n. 22
0
unsigned char MySocketConnection::read() {
	unsigned char c;
	int result = SDLNet_TCP_Recv(this->socket, &c, 1);
	if (result <= 0) {
		throw WAException(std::string(SDLNet_GetError()), WAException::SOCKET_EX, WAException::SOCKET_EX_RECV);
	}
	return c;
}
Esempio n. 23
0
void Connection_recv_data(Connection* self, Uint8* buffer, int size)
{
    if(SDLNet_TCP_Recv(self->socket, buffer, size) < size)
    {
        printf("Lost connection to server\n");
        Connection_destroy(&self);
    }
}
Esempio n. 24
0
/**
 * Receive a Minecraft RCON packet through a connected TCP socket.
 * @param[in] rcon McRcon struct
 * @param[out] packetPtr Pointer to McRconPacket pointer. Will be set to a
 			   heap-allocated struct.
 * @return True if everything went ok, false if errors occured.
 */
static bool McRcon_ReceivePacket(McRcon* rcon, McRconPacket** packetPtr)
{
	// Get packet size
	int32_t len;
	if (SDLNet_TCP_Recv(rcon->sock, &len, sizeof(int32_t)) <= 0)
	{
		McRcon_SetError(rcon, MC_RCON_ERR_NETWORK, SDLNet_GetError());
		return false;
	}
	
	// Get packet data
	void* buffer = malloc(len);
	if (NULL == buffer) {
		McRcon_SetError(rcon, MC_RCON_ERR_MALLOC, NULL);
		return false;
	}
	if (SDLNet_TCP_Recv(rcon->sock, buffer, len) <= 0)
	{
		McRcon_SetError(rcon, MC_RCON_ERR_NETWORK, SDLNet_GetError());
		return false;
	}
	
	// Cast received data to data struct
	McRconData* data = (McRconData*)buffer;
	
	// Pass the address of the payload field in McRconData as char pointer
	size_t payload_size = strlen((char*)(&(data->payload)));
	// Allocate sizeof(struct) + size of payload, which is terminated by two
	// null bytes
	McRconPacket* packet = malloc(sizeof(McRconPacket) + payload_size + 2);
	if (NULL == packet) {
		McRcon_SetError(rcon, MC_RCON_ERR_MALLOC, NULL);
		return false;
	}
	
	packet->len = len;
	packet->requestid = data->requestid;
	packet->type = data->type;
	strcpy(packet->payload, data->payload);
	
	free(data);
	
	*packetPtr = packet;
	
	return true;
}
string game_host::recieveMessagep2()
{
	char buff[512];
	while(!SDLNet_TCP_Recv(this->player2sd, buff, 512));
	//cout << buff << "\n";
	string ret = buff;
	return ret;
}
Esempio n. 26
0
bool Client_recv_data(Client* self, Uint8* buffer, int size)
{
    if(SDLNet_TCP_Recv(self->socket, buffer, size) < size)
    {
        return false;
    }
    return true;
}
Esempio n. 27
0
std::string TCPConnection::ReadMessages()
{
	if ( !CheckForActivity() )
		return "";

	char buffer[bufferSize ];
	memset( buffer, 0, bufferSize );

	int byteCount  = 0;
	std::string received("");

	if ( !isConnected )
		return received;

	if ( isServer )
		byteCount = SDLNet_TCP_Recv( serverSocket, buffer, bufferSize );
	else
		byteCount = SDLNet_TCP_Recv( tcpSocket, buffer, bufferSize );

	if ( byteCount > 0 )
	{
		//memset( &buffer[byteCount], 0, static_cast< size_t > (512 - byteCount ) );
		buffer[byteCount] = '\0';
		received = buffer;

		if ( byteCount >= bufferSize )
		{
			logger->Log( __FILE__, __LINE__, " Too much data reciebed : ", byteCount );
			logger->Log( __FILE__, __LINE__, " ...Buffer size is : ", bufferSize );
		}
	}
	// A bytecount of 0 means the connection has been terminated
	else if ( byteCount == 0 )
	{
		logger->Log( __FILE__, __LINE__, "Connection terminated : " );
		Close();
	// A bytecount of < 0 means an error occured
	}
	else if ( byteCount < 0 )
	{
		logger->Log( __FILE__, __LINE__, "Read Failed : ", SDLNet_GetError() );
	}

	return received;
}
Esempio n. 28
0
Uint8 Client_recv_flag(Client* self)
{
    Uint8 flag;
    if(SDLNet_TCP_Recv(self->socket, &flag, 1) < 1)
    {
        return TCP_ERROR;
    }
    return flag;
}
Esempio n. 29
0
/*
* network_tcp_recv() - Receive data via TCP from the given socket
* @tcp: the socket to receive data from
* @data: the pointer to store the data at
* @maxlen: the maximum length of data to receive
*/
int network_tcp_recv(TCPsocket* tcp, void* data, int maxlen) {
	int r = SDLNet_TCP_Recv(*tcp, data, maxlen); // Attempt to receive the data

	if (r <= 0) { // If no data was received or another error occured
		std::cerr << "Failed to receive data over TCP: " << SDLNet_GetError() << "\n"; // Output the error message
	}

	return r; // Return the amount of data received on success, or the error code on failure
}
Esempio n. 30
0
static __inline__ int snTCPRead(TCPsocket s, Uint8 *buf, int max)
{
  int val = -1;

  lockSDLNet();
  val = SDLNet_TCP_Recv(s, buf, max); // read what we can
  unlockSDLNet();

  return val;
}