summaryrefslogtreecommitdiff
path: root/src/network/socket_handler.cpp
blob: 67adacd1067e30cd0ff4913a39da4816edaea0f7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include <network/socket_handler.hpp>

#include <utils/scopeguard.hpp>
#include <network/poller.hpp>

#include <logger/logger.hpp>
#include <sys/socket.h>
#include <sys/types.h>
#include <stdexcept>
#include <unistd.h>
#include <errno.h>
#include <cstring>
#include <netdb.h>
#include <stdio.h>

#include <iostream>

SocketHandler::SocketHandler():
  poller(nullptr),
  connected(false)
{
  if ((this->socket = ::socket(AF_INET, SOCK_STREAM, 0)) == -1)
    throw std::runtime_error("Could not create socket");
}

bool SocketHandler::connect(const std::string& address, const std::string& port)
{
  log_info("Trying to connect to " << address << ":" << port);
  struct addrinfo hints;
  memset(&hints, 0, sizeof(struct addrinfo));
  hints.ai_flags = 0;
  hints.ai_family = AF_INET;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;

  struct addrinfo* addr_res;
  const int res = ::getaddrinfo(address.c_str(), port.c_str(), &hints, &addr_res);
  // Make sure the alloced structure is always freed at the end of the
  // function
  utils::ScopeGuard sg([&addr_res](){ freeaddrinfo(addr_res); });

  if (res != 0)
    {
      perror("getaddrinfo");
      throw std::runtime_error("getaddrinfo failed");
    }
  for (struct addrinfo* rp = addr_res; rp; rp = rp->ai_next)
    {
      if (::connect(this->socket, rp->ai_addr, rp->ai_addrlen) == 0)
        {
          log_info("Connection success.");
          this->connected = true;
          this->on_connected();
          return true;
        }
      log_info("Connection failed:");
      perror("connect");
    }
  log_error("All connection attempts failed.");
  this->close();
  return false;
}

void SocketHandler::set_poller(Poller* poller)
{
  this->poller = poller;
}

void SocketHandler::on_recv(const size_t nb)
{
  char buf[4096];

  ssize_t size = ::recv(this->socket, buf, nb, 0);
  if (0 == size)
    {
      this->on_connection_close();
      this->close();
    }
  else if (-1 == static_cast<ssize_t>(size))
    {
      log_warning("Error while reading from socket: " << strerror(errno));
      this->on_connection_close();
      this->close();
    }
  else
    {
      this->in_buf += std::string(buf, size);
      this->parse_in_buffer();
    }
}

void SocketHandler::on_send()
{
  const ssize_t res = ::send(this->socket, this->out_buf.data(), this->out_buf.size(), 0);
  if (res == -1)
    {
      perror("send");
      this->close();
    }
  else
    {
      this->out_buf = this->out_buf.substr(res, std::string::npos);
      if (this->out_buf.empty())
        this->poller->stop_watching_send_events(this);
    }
}

void SocketHandler::close()
{
  this->connected = false;
  this->poller->remove_socket_handler(this->get_socket());
  ::close(this->socket);
  // recreate the socket for a potential future usage
  if ((this->socket = ::socket(AF_INET, SOCK_STREAM, 0)) == -1)
    throw std::runtime_error("Could not create socket");
}

socket_t SocketHandler::get_socket() const
{
  return this->socket;
}

void SocketHandler::send_data(std::string&& data)
{
  this->out_buf += std::move(data);
  if (!this->out_buf.empty())
    {
      this->poller->watch_send_events(this);
    }
}

bool SocketHandler::is_connected() const
{
  return this->connected;
}