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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
#include <sys/ioctl.h>
#include <systemd/sd-daemon.h>
#include <phosphor-logging/log.hpp>
#include "main.hpp"
#include "message_handler.hpp"
#include "sd_event_loop.hpp"
namespace eventloop
{
using namespace phosphor::logging;
static int udp623Handler(sd_event_source* es, int fd, uint32_t revents,
void* userdata)
{
std::shared_ptr<udpsocket::Channel> channelPtr;
struct timeval timeout;
timeout.tv_sec = SELECT_CALL_TIMEOUT;
timeout.tv_usec = 0;
try
{
channelPtr.reset(new udpsocket::Channel(fd, timeout));
// Initialize the Message Handler with the socket channel
message::Handler msgHandler(channelPtr);
std::unique_ptr<message::Message> inMessage;
// Read the incoming IPMI packet
inMessage = msgHandler.receive();
if (inMessage == nullptr)
{
return 0;
}
// Execute the Command
auto outMessage = msgHandler.executeCommand(*(inMessage.get()));
if (outMessage == nullptr)
{
return 0;
}
// Send the response IPMI Message
msgHandler.send(*(outMessage.get()));
}
catch (std::exception& e)
{
log<level::ERR>("Executing the IPMI message failed");
log<level::ERR>(e.what());
}
return 0;
}
static int consoleInputHandler(sd_event_source* es, int fd, uint32_t revents,
void* userdata)
{
try
{
int readSize = 0;
if (ioctl(fd, FIONREAD, &readSize) < 0)
{
log<level::ERR>("ioctl failed for FIONREAD:",
entry("errno = %d", errno));
return 0;
}
std::vector<uint8_t> buffer(readSize);
auto bufferSize = buffer.size();
ssize_t readDataLen = 0;
readDataLen = read(fd, buffer.data(), bufferSize);
// Update the Console buffer with data read from the socket
if (readDataLen > 0)
{
buffer.resize(readDataLen);
std::get<sol::Manager&>(singletonPool).dataBuffer.write(buffer);
}
else if (readDataLen == 0)
{
log<level::ERR>("Connection Closed for host console socket");
}
else if (readDataLen < 0) // Error
{
log<level::ERR>("Reading from host console socket failed:",
entry("ERRNO=%d", errno));
}
}
catch (std::exception& e)
{
log<level::ERR>(e.what());
}
return 0;
}
int EventLoop::startEventLoop()
{
int fd = -1;
int r = 0;
sigset_t ss;
sd_event_source* source = nullptr;
r = sd_event_default(&event);
if (r < 0)
{
goto finish;
}
if (sigemptyset(&ss) < 0 || sigaddset(&ss, SIGTERM) < 0 ||
sigaddset(&ss, SIGINT) < 0)
{
r = -errno;
goto finish;
}
/* Block SIGTERM first, so that the event loop can handle it */
if (sigprocmask(SIG_BLOCK, &ss, nullptr) < 0)
{
r = -errno;
goto finish;
}
/* Let's make use of the default handler and "floating" reference features
* of sd_event_add_signal() */
r = sd_event_add_signal(event, nullptr, SIGTERM, nullptr, nullptr);
if (r < 0)
{
goto finish;
}
r = sd_event_add_signal(event, nullptr, SIGINT, nullptr, nullptr);
if (r < 0)
{
goto finish;
}
if (sd_listen_fds(0) != 1)
{
log<level::ERR>("No or too many file descriptors received");
goto finish;
}
fd = SD_LISTEN_FDS_START;
r = sd_event_add_io(event, &source, fd, EPOLLIN, udp623Handler, nullptr);
if (r < 0)
{
goto finish;
}
udpIPMI.reset(source);
source = nullptr;
r = sd_event_loop(event);
finish:
event = sd_event_unref(event);
if (fd >= 0)
{
(void) close(fd);
}
if (r < 0)
{
log<level::ERR>("Event Loop Failure:",
entry("FAILURE=%s", strerror(-r)));
}
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
void EventLoop::startHostConsole(const sol::CustomFD& fd)
{
int rc = 0;
if((fd() == -1) || hostConsole.get())
{
throw std::runtime_error("Console descriptor already added");
}
sd_event_source* source = nullptr;
// Add the fd to the event loop for EPOLLIN
rc = sd_event_add_io(
event, &source, fd(), EPOLLIN, consoleInputHandler, nullptr);
if (rc < 0)
{
throw std::runtime_error("Failed to add socket descriptor");
}
hostConsole.reset(source);
source=nullptr;
}
} // namespace eventloop
|
