int main() {

    try {

        WSADATA wsaData;
        WSAStartup(MAKEWORD(2, 2), &wsaData);

        sockaddr_in enderecoServidor;
        inet_pton(AF_INET, "0.0.0.0", &enderecoServidor.sin_addr);
        enderecoServidor.sin_family = AF_INET;
        enderecoServidor.sin_port = htons(PORTA_SERVIDOR);

        SOCKET principalSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

        bind(principalSocket, (sockaddr*)&enderecoServidor, sizeof(enderecoServidor));

        listen(principalSocket, SOMAXCONN);

        sockaddr_in clienteEndereco;
        int clienteEnderecoTam = sizeof(clienteEndereco);

        SOCKET clienteSocket;

        for(;;) {

            clienteSocket = accept(principalSocket, (sockaddr*)&clienteEndereco, &clienteEnderecoTam);

            for(;;) {
                try {
                    int comando;
                    int size;
                    char* login;
                    char* senha;
                    receberTcp(clienteSocket, &comando, sizeof(int));

                    switch(comando) {
                        case CMD_AUTH_REQUEST:
                            receberTcp(clienteSocket, &size, sizeof(int));
                            login = new char[size+1];
                            receberTcp(clienteSocket, login, size);
                            login[size] = '\0';
                            receberTcp(clienteSocket, &size, sizeof(int));
                            senha = new char[size+1];
                            receberTcp(clienteSocket, senha, size);
                            senha[size] = '\0';
                            std::cout << "Login: "******"\tSenha: " << senha << std::endl;
                            comando = CMD_AUTH_SUCESS;
                            send(clienteSocket, (char*)&comando, sizeof(int), NULL);

                            delete login;
                            delete senha;
                            break;
                        default:
                            break;
                    }
                } catch(std::exception& ex) {
                    std::cout << ex.what();
                    break;
                }
            }
        }

        closesocket(principalSocket);

        WSACleanup();
    } catch(std::exception& ex) {
        std::cout << ex.what();
        system("pause");
        return 1;
    }

    return 0;
}
Beispiel #2
0
int main()
{
	WSAData wsaData;
	WSAStartup(MAKEWORD(2, 2), &wsaData);

	sockaddr_in enderecoServidor;

	inet_pton(AF_INET, "127.0.0.1", &enderecoServidor.sin_addr);
	enderecoServidor.sin_family = AF_INET;
	enderecoServidor.sin_port = htons(PORTA_SERVIDOR);

	SOCKET meuSocket;
	meuSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	std::cout << "LAUNCHER: " << std::endl;

	int r;
	r = connect(meuSocket,
		(SOCKADDR*)&enderecoServidor,
		sizeof(sockaddr_in));

	if (r != 0)
	{
		std::cout << "Nao foi possivel estabelecer uma conexao com o servidor" << std::endl;
		system("pause");
		return 1;
	}

	try
	{

		VersaoCliente versaoCliente;
		int minhaVersaoCliente = versaoCliente.Versao();

		std::cout << "Conectado ao servidor"
			<< std::endl
			<< "Versao do cliente: "
			<< minhaVersaoCliente << std::endl;


		unsigned int ultimaVersaoCliente;
		int comando = Comandos::NUMERO_ULTIMA_VERSAO_CLIENTE_REQ;

		send(meuSocket,
			(char*)&comando,
			sizeof(int),
			NULL);

		std::cout << "Procurando por atualizacoes..." << std::endl;

		receberTcp(meuSocket,
			&ultimaVersaoCliente,
			sizeof(int));

		if (ultimaVersaoCliente != minhaVersaoCliente)
		{

			std::cout << "Atualizacao encontrada: Versao "
				<< ultimaVersaoCliente
				<< std::endl;


			comando = Comandos::EXECUTAVEL_ULTIMA_VERSAO_CLIENTE_REQ;

			send(meuSocket,
				(char*)&comando,
				sizeof(int),
				NULL);

			long tamanhoArquivo;
			receberTcp(meuSocket,
				&tamanhoArquivo,
				sizeof(long));

			std::cout << "Iniciando a transferencia: "
				<< tamanhoArquivo << " bytes"
				<< std::endl;

			receberArquivo(meuSocket,
				ultimaVersaoCliente,
				tamanhoArquivo);

			std::ostringstream executavel;
			executavel << "wowv" << ultimaVersaoCliente << ".exe";

			STARTUPINFO si;
			PROCESS_INFORMATION pi;

			ZeroMemory(&si, sizeof(si));
			si.cb = sizeof(si);
			ZeroMemory(&pi, sizeof(pi));

			std::cout << "Atualizacao recebida com sucesso." << std::endl;

			versaoCliente.Atualizar(ultimaVersaoCliente);

			std::cout << "Inicializando o jogo." << std::endl;

			CreateProcess(NULL,
				(TCHAR*)executavel.str().c_str(),
				NULL,
				NULL,
				FALSE,
				CREATE_NEW_CONSOLE,
				NULL,
				NULL,
				&si,
				&pi);

		}
		else
		{
			std::cout << "Cliente esta atualizado." << std::endl;
		}
	}
	catch (std::exception& ex)
	{
		std::cout << "Nao foi possivel realizar o download da ultima versao do cliente: "
			<< std::endl
			<< ex.what();
	}

	closesocket(meuSocket);

	system("pause");
	return 0;
}
Beispiel #3
0
int main(){

	try{
		ClienteJogo* ultimoCliente = new ClienteJogo();

		WSADATA wsaData;
		int result;
		result = WSAStartup(MAKEWORD(2, 2), &wsaData);

		if (result != 0){
			return MsgErro("WSAStartup");
		}

		sockaddr_in enderecoServidor;
		inet_pton(AF_INET, "0.0.0.0", &enderecoServidor.sin_addr);
		enderecoServidor.sin_family = AF_INET;
		enderecoServidor.sin_port = htons(PORTA_SERVIDOR);

		SOCKET principalSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

		if (principalSocket == INVALID_SOCKET){
			return MsgErro("socket");
		}

		result = bind(principalSocket, (sockaddr*)&enderecoServidor, sizeof(enderecoServidor));

		if (result == SOCKET_ERROR){
			return MsgErro("bind");
		}

		result = listen(principalSocket, SOMAXCONN);

		if (result == SOCKET_ERROR){
			return MsgErro("listen");
		}

		sockaddr_in clienteEndereco;
		int clienteEnderecoTam = sizeof(clienteEndereco);

		SOCKET clienteSocket;

		for (;;){
	
			clienteSocket = accept(principalSocket, (sockaddr*)&clienteEndereco, &clienteEnderecoTam);

			for (;;){
				try{
					int comando;
					int ultimaVersaoCliente;
					receberTcp(clienteSocket, &comando, sizeof(int));

					switch (comando)
					{
					default:
						break;
					}
				}
				catch (std::exception& ex){
					std::cout << ex.what();
					break;
				}
			}
		}

		int 

		closesocket(principalSocket);

		WSACleanup();
	}
	catch (std::exception& ex){
		std::cout << ex.what();
		system("pause");
		return 1;
	}
	return 0;
}