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
136
137
|
#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");
}
std::pair<bool, std::string> 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);
if (res != 0)
{
log_warning(std::string("getaddrinfo failed: ") + gai_strerror(res));
this->close();
return std::make_pair(false, gai_strerror(res));
}
// Make sure the alloced structure is always freed at the end of the
// function
utils::ScopeGuard sg([&addr_res](){ freeaddrinfo(addr_res); });
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 std::make_pair(true, "");
}
log_info("Connection failed:" << strerror(errno));
}
log_error("All connection attempts failed.");
this->close();
return std::make_pair(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)
{
log_error("send failed: " << strerror(errno));
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;
}
|
