gistfile1.cpp

#include "GameServerConnection.h"
#include "GameClient.h"

GameServerConnection::GameServerConnection(const char *ip, int port){
	uv_tcp_init(GameClient::GetLoop(), &m_Socket);

	struct sockaddr_in dest = uv_ip4_addr(ip, port);

	m_Socket.data = this;
	m_Connect.data = this;

	m_Magic = 0x12345678;

	uv_tcp_connect(&m_Connect, &m_Socket, dest, OnConnect);
}

struct write_req_t {
    uv_write_t req;
    uv_buf_t buf;
};

void OnFinishWritingMessage(uv_write_t* req_, int status){
	write_req_t *req = (write_req_t*) req_;
	free(req->buf.base);
	delete req;
}

void GameServerConnection::WriteRaw(const uint8_t *data, size_t length){
	uv_buf_t buf;
	buf.base = (char*) malloc(length);
	memcpy(buf.base, data, length);
	buf.len = length;

	write_req_t *req = new write_req_t;
	req->buf = buf;

	uv_write((uv_write_t*) req, (uv_stream_t*) &m_Socket, &req->buf, 1, OnFinishWritingMessage);
}


void GameServerConnection::OnConnect(uv_connect_t* req, int status){
	GameServerConnection *self = (GameServerConnection *) req->data;
	if(status == -1){
		printf("Failed to connect: %s\n", uv_err_name(uv_last_error(GameClient::GetLoop())));
		return;
	}

	printf("Connected!\n");
	uv_read_start((uv_stream_t*) req, AllocBufferCallback, OnConnectionData);

	self->WriteRaw((const uint8_t *) "lololol", 5);
}

uv_buf_t GameServerConnection::AllocBufferCallback(uv_handle_t* handle, size_t suggested_size){
	uv_buf_t buf;
	buf.base = (char*)malloc(sizeof(char) * suggested_size);
	buf.len = suggested_size;
	return buf;
}

void GameServerConnection::OnConnectionData(uv_stream_t* stream, ssize_t nread, uv_buf_t buf){
	uv_tcp_t *tcp = (uv_tcp_t*) stream;
	GameServerConnection *self = (GameServerConnection *) tcp->data;
	
	// Error
	if(nread == -1){
		uv_err_t error = uv_last_error(GameClient::GetLoop());
		if(error.code != UV_EOF){
			fprintf(stderr, "Connection data error %s\n", uv_err_name(error));
		}
		self->Destroy();
		return;
	}

	if(nread != 0){
		printf("Received data\n");
	}

	free(buf.base);
}


/*
void GameServerConnection::WriteMessage(uint16_t type, google::protobuf::Message *message){
	if(m_bDestroyed) return;

	ScopedMutex mutex = m_StreamMutex.GetScopeLock();

	int msgLength = message->ByteSize();

	uv_buf_t buf;
	buf.base = (char*)malloc(4 + 2 + 4 + msgLength + 4);
	buf.len = 4 + 2 + 4 + msgLength + 4;

	uint8_t *buffer = (uint8_t *) buf.base;
	if(!message->SerializeToArray(&buffer[10], msgLength)){
		Assert(!"Failed to serialize message to client");
		free(buf.base);
		return;
	}

	buffer[0] = 0x28;
	buffer[1] = 0x48;
	buffer[2] = 0x68;
	buffer[3] = 0x88;

	buffer[4] = (type >> 8) & 0xFF;
	buffer[5] = (type >> 0) & 0xFF;

	buffer[6] = (msgLength >> 24) & 0xFF;
	buffer[7] = (msgLength >> 16) & 0xFF;
	buffer[8] = (msgLength >>  8) & 0xFF;
	buffer[9] = (msgLength >>  0) & 0xFF;

	buffer[10 + msgLength + 0] = 0xA8;
	buffer[10 + msgLength + 1] = 0xC8;
	buffer[10 + msgLength + 2] = 0xE8;
	buffer[10 + msgLength + 3] = 0xFF;

	write_req_t *req = new write_req_t;
	req->buf = buf;

	uv_write((uv_write_t*)req, (uv_stream_t*) m_pStream, &req->buf, 1, OnFinishWritingMessage);
}*/