src/net/client.cpp

Go to the documentation of this file.

#include <cstdio>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <netdb.h>
#include <string.h>
#include "net/client.h"
#include "engine/mutex.h"
#include "tools/log.h"

Mutex getaddrinfo_mutex;

Client::Client(bool _reconnect)
{
        client_host = "";
        client_port = -1;
        connecting = false;
        connected = false;
        reconnect = _reconnect;
}

Client::~Client()
{
        if(IsConnected())
                log(LogInfo, "Disconnecting from %s", GetAddress().c_str());
}

void Client::Connect(std::string _host, int _port)
{
        if(IsConnected())
                return;

        info_mutex.Lock();
        connecting = true;
        client_host = _host;
        client_port = _port;
        info_mutex.Unlock();

        Lock();

        log(LogInfo, "Connecting to %s:%i", _host.c_str(), _port);

        if((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
                log(LogPanic, "Could not create socket : %s", strerror(errno));

        struct addrinfo hints;
        struct addrinfo *addr;
        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_socktype = SOCK_STREAM;
        hints.ai_family = AF_INET;

        int ret;
        std::string port_str = int2str(_port);
        getaddrinfo_mutex.Lock();
        if((ret = getaddrinfo(_host.c_str(), port_str.c_str(), &hints, &addr)) != 0)
        {
                log(LogError, "getaddrinfo failed: %s", strerror(ret));
                getaddrinfo_mutex.Unlock();
                Unlock();
                return;
        }
        getaddrinfo_mutex.Unlock();

        if(connect(fd, (struct sockaddr*)addr->ai_addr, sizeof(struct sockaddr_in)) != 0)
        {
                log(LogError, "Could not connect to %s:%i : %s", _host.c_str(), _port, strerror(errno));
                Disconnect();
                Unlock();
        }
        else
        {
                Unlock();
                info_mutex.Lock();
                connected = true;
                info_mutex.Unlock();
        }
        info_mutex.Lock();
        connecting = false;
        info_mutex.Unlock();
        return;
}

void Client::Connect()
{
        Connect(client_host, client_port);
}

bool Client::IsConnecting()
{
        info_mutex.Lock();
        bool r = connecting;
        info_mutex.Unlock();
        return r;
}

bool Client::IsConnected()
{
        info_mutex.Lock();
        bool r = connected;
        info_mutex.Unlock();
        return r;
}

const std::string Client::GetAddress()
{
        std::string str;
        info_mutex.Lock();
        str = client_host + std::string(":") + int2str(client_port);
        info_mutex.Unlock();
        return str;
}

void Client::OnDisconnect()
{
        info_mutex.Lock();
        connected = false;
        info_mutex.Unlock();
}

---