void IO::OutputScheduler::Run() {
try {
_stopRequested = false;
while (!_stopRequested) {
int events_number = GetEvents();
for (auto index = 0; index < events_number; ++index) {
volatile std::lock_guard<std::mutex> schedule_lock(_scheduling_mutex);
Log::i("got " + std::to_string(events_number) + " events (writing)");
if (is_error(_events[index].events)) {
log_error(_efd);
remove_socket(_events[index].data.fd);
} else {
std::size_t err_pos = static_cast<std::size_t>(-1);
std::size_t scheduled_item_pos = err_pos;
for (decltype(scheduled_item_pos) index2 = 0;
index2 < _schedule.size(); ++index2) {
if (_schedule[index2].sock->get_fd() == _events[index].data.fd) {
scheduled_item_pos = index2;
}
}
if (scheduled_item_pos != err_pos) {
if (_schedule[scheduled_item_pos].data.size() == 0)
remove_socket(_schedule[scheduled_item_pos].sock->get_fd());
auto written = static_cast<std::size_t>(
_schedule[scheduled_item_pos].sock->Write(
_schedule[scheduled_item_pos].data));
if (written < _schedule[scheduled_item_pos].data.size()) {
auto oldSize = _schedule[scheduled_item_pos].data.size();
Log::i("on fd = " + std::to_string(_events[index].data.fd) +
", wrote " + std::to_string(written) + " remaining = " +
std::to_string(_schedule[scheduled_item_pos].data.size() -
written));
std::vector<decltype(
_schedule[scheduled_item_pos].data)::value_type>(
_schedule[scheduled_item_pos].data.begin() + written,
_schedule[scheduled_item_pos].data.end())
.swap(_schedule[scheduled_item_pos].data);
auto newSize = _schedule[scheduled_item_pos].data.size();
assert(oldSize - written == newSize);
} else {
_schedule[scheduled_item_pos].data = {};
}
}
}
}
}
} catch (std::exception& ex) {
throw;
}
}
void delete_gateway(gateway_handle handle)
{
/* release all the resources */
gateway_context* gateway = (gateway_context*)handle;
int index;
if(gateway)
{
for(index=0; index<gateway->client_count; index++)
{
remove_socket(gateway->network_thread, gateway->clients[index]->comm_socket_fd);
if(gateway->clients[index]->client_ip_address)
free(gateway->clients[index]->client_ip_address);
if(gateway->clients[index]->client_port_number)
free(gateway->clients[index]->client_port_number);
if(gateway->clients[index]->area_id)
free(gateway->clients[index]->area_id);
free(gateway->clients[index]);
}
if(gateway->network_thread)
{
delete_network_thread(gateway->network_thread);
}
if(gateway->server_socket_fd)
{
close_socket(gateway->server_socket_fd);
}
free(gateway);
}
}
static void local_socket_close_locked(asocket *s)
{
D("entered. LS(%d) fd=%d\n", s->id, s->fd);
if(s->peer) {
D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
s->id, s->peer->id, s->peer->fd);
s->peer->peer = 0;
// tweak to avoid deadlock
if (s->peer->close == local_socket_close) {
local_socket_close_locked(s->peer);
} else {
s->peer->close(s->peer);
}
s->peer = 0;
}
/* If we are already closing, or if there are no
** pending packets, destroy immediately
*/
if (s->closing || s->pkt_first == NULL) {
int id = s->id;
local_socket_destroy(s);
D("LS(%d): closed\n", id);
return;
}
/* otherwise, put on the closing list
*/
D("LS(%d): closing\n", s->id);
s->closing = 1;
fdevent_del(&s->fde, FDE_READ);
remove_socket(s);
D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
insert_local_socket(s, &local_socket_closing_list);
}
// be sure to hold the socket list lock when calling this
static void local_socket_destroy(asocket* s) {
apacket *p, *n;
int exit_on_close = s->exit_on_close;
D("LS(%d): destroying fde.fd=%d", s->id, s->fde.fd);
/* IMPORTANT: the remove closes the fd
** that belongs to this socket
*/
fdevent_remove(&s->fde);
/* dispose of any unwritten data */
for (p = s->pkt_first; p; p = n) {
D("LS(%d): discarding %zu bytes", s->id, p->len);
n = p->next;
put_apacket(p);
}
remove_socket(s);
free(s);
if (exit_on_close) {
D("local_socket_destroy: exiting");
exit(1);
}
}
void IO::OutputScheduler::remove_socket(int sockfd) {
IO::Socket* socket = nullptr;
int socket_position = -1;
unsigned int index = 0;
for (index = 0; index < _schedule.size(); ++index) {
if ((*_schedule[index].sock).get_fd() == sockfd) {
socket = &((*_schedule[index].sock));
socket_position = index;
break;
}
}
assert(socket != nullptr);
if (socket != nullptr) {
struct epoll_event* ev = nullptr;
for (auto& event : _events) {
if ((event.data.fd) == socket->get_fd()) ev = &(event);
}
remove_socket(*socket, socket_position, ev);
} else {
Log::e("could not find socket with sockfd = " + std::to_string(sockfd) +
" in order to remove it");
}
}
void pbntf_lost_socket(pubnub_t *pb, pb_socket_t socket)
{
EnterCriticalSection(&m_watcher.mutw);
remove_socket(&m_watcher, pb);
remove_timer_safe(pb);
remove_from_processing_queue(pb);
LeaveCriticalSection(&m_watcher.mutw);
}
void close_server() {
while (socket_list)
remove_socket(socket_list);
online = 0;
server = 0;
init_door();
if (screen == GAME_SCREEN_WORLD)
init_telegraph();
init_game(0);
}
static bool remove_client(Client *c)
{
int sock = c->sock;
Assert(sock >= 0);
c->sock = -1;
if (c->msg) pfree(c->msg);
server.clientnum--;
close(sock);
return remove_socket(sock);
}
void pbntf_lost_socket(pubnub_t *pb, pb_socket_t socket)
{
PUBNUB_UNUSED(socket);
if (pdFALSE == xSemaphoreTakeRecursive(m_watcher.mutw, TICKS_TO_WAIT)) {
return ;
}
remove_socket(&m_watcher, pb);
remove_timer_safe(pb);
xSemaphoreGiveRecursive(m_watcher.mutw);
xTaskNotifyGive(m_watcher.task);
}
static void
jdwp_socket_close( asocket* s )
{
asocket* peer = s->peer;
remove_socket(s);
if (peer) {
peer->peer = NULL;
peer->close(peer);
}
free(s);
}
static void jdwp_socket_close(asocket* s) {
D("LS(%d): closing jdwp socket", s->id);
if (s->peer) {
D("LS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
s->peer->peer = nullptr;
s->peer->close(s->peer);
s->peer = nullptr;
}
remove_socket(s);
delete s;
}
static PyObject*
PyEvents_DeleteSocket(PyObject* unused, PyObject* argument)
{
SocketObject* socket;
if (!PyObject_TypeCheck(argument, &SocketType)) {
PyErr_SetString(PyExc_TypeError, "argument is not a socket");
return NULL;
}
socket = (SocketObject*)argument;
remove_socket(socket);
Py_INCREF(Py_None);
return Py_None;
}
/* disconnect from the server (if client) */
void server_disconnect() {
struct socket_node *p;
if (online && !server) {
p = socket_list;
while (p->type != SOCKET_SERVER)
p = p->next;
remove_socket(p);
online = 0;
init_door();
if (screen == GAME_SCREEN_WORLD)
init_telegraph();
init_game(0);
}
}
static void jdwp_tracker_close(asocket* s) {
D("LS(%d): destroying jdwp tracker service", s->id);
if (s->peer) {
D("LS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
s->peer->peer = nullptr;
s->peer->close(s->peer);
s->peer = nullptr;
}
remove_socket(s);
auto pred = [s](const auto& tracker) { return tracker.get() == s; };
_jdwp_trackers.erase(std::remove_if(_jdwp_trackers.begin(), _jdwp_trackers.end(), pred),
_jdwp_trackers.end());
}
void Connection::close()
{
char tmpstr[255];
if (sock)
{
sprintf(tmpstr, "close port %d", sock->get_port());
//print_comment(__LINE__, __FILE__, tmpstr);
if (remove_socket)
{
remove_socket(sock->get_id());
remove_socket = NULL;
}
delete sock;
sock = NULL;
}
}
static void
jdwp_tracker_close( asocket* s )
{
JdwpTracker* tracker = (JdwpTracker*) s;
asocket* peer = s->peer;
if (peer) {
peer->peer = NULL;
peer->close(peer);
}
remove_socket(s);
tracker->prev->next = tracker->next;
tracker->next->prev = tracker->prev;
free(s);
}
static void local_socket_close_locked(asocket *s)
{
D("entered local_socket_close_locked. LS(%d) fd=%d\n", s->id, s->fd);
if(s->peer) {
D("LS(%d): closing peer. peer->id=%d peer->fd=%d\n",
s->id, s->peer->id, s->peer->fd);
/* Note: it's important to call shutdown before disconnecting from
* the peer, this ensures that remote sockets can still get the id
* of the local socket they're connected to, to send a CLOSE()
* protocol event. */
if (s->peer->shutdown)
s->peer->shutdown(s->peer);
s->peer->peer = 0;
// tweak to avoid deadlock
if (s->peer->close == local_socket_close) {
local_socket_close_locked(s->peer);
} else {
s->peer->close(s->peer);
}
s->peer = 0;
}
/* If we are already closing, or if there are no
** pending packets, destroy immediately
*/
if (s->closing || s->pkt_first == NULL) {
int id = s->id;
local_socket_destroy(s);
D("LS(%d): closed\n", id);
return;
}
/* otherwise, put on the closing list
*/
D("LS(%d): closing\n", s->id);
s->closing = 1;
fdevent_del(&s->fde, FDE_READ);
remove_socket(s);
D("LS(%d): put on socket_closing_list fd=%d\n", s->id, s->fd);
insert_local_socket(s, &local_socket_closing_list);
}
static void local_socket_close(asocket* s) {
D("entered local_socket_close. LS(%d) fd=%d", s->id, s->fd);
std::lock_guard<std::recursive_mutex> lock(local_socket_list_lock);
if (s->peer) {
D("LS(%d): closing peer. peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd);
/* Note: it's important to call shutdown before disconnecting from
* the peer, this ensures that remote sockets can still get the id
* of the local socket they're connected to, to send a CLOSE()
* protocol event. */
if (s->peer->shutdown) {
s->peer->shutdown(s->peer);
}
s->peer->peer = nullptr;
s->peer->close(s->peer);
s->peer = nullptr;
}
/* If we are already closing, or if there are no
** pending packets, destroy immediately
*/
if (s->closing || s->has_write_error || s->pkt_first == NULL) {
int id = s->id;
local_socket_destroy(s);
D("LS(%d): closed", id);
return;
}
/* otherwise, put on the closing list
*/
D("LS(%d): closing", s->id);
s->closing = 1;
fdevent_del(&s->fde, FDE_READ);
remove_socket(s);
D("LS(%d): put on socket_closing_list fd=%d", s->id, s->fd);
insert_local_socket(s, &local_socket_closing_list);
CHECK_EQ(FDE_WRITE, s->fde.state & FDE_WRITE);
}
void check_sockets() {
int num;
struct socket_node *p, *next;
struct packet_disconnect packet;
if (online) {
num = SDLNet_CheckSockets(sockset, 0);
if (num < 0)
do_error("Failed checking socket set for activity");
else if (num) {
for (p = socket_list; p != NULL; p = next) {
next = p->next;
if (SDLNet_SocketReady(p->sock)) {
if (p->type == SOCKET_SERVER && server)
new_connection(p->sock);
else {
if (read_socket(p->sock, p->recv_buf, &p->recv_buf_size) <= 0) {
if (p->type == SOCKET_SERVER) {
server_disconnect();
telegram("\nThe server disconnected.\n");
}
else {
telegram("\n%s has\ndisconnected from the\nserver.\n", GET_NAME(p->player));
init_player(p->player, INIT_PLAYER_INACTIVE);
/* tell other clients */
packet.player =swap_int(p->player);
packet.error =swap_int(ERROR_CONNECTION);
send_all_sockets(PACKET_DISCONNECT, &packet, sizeof(struct packet_disconnect));
remove_socket(p);
}
}
}
}
}
}
}
}
void pbntf_lost_socket(pubnub_t *pb, pb_socket_t socket)
{
PUBNUB_UNUSED(socket);
remove_socket(&m_watcher, pb);
remove_timer_safe(pb);
}
void* read_callback(void *context)
{
gateway_client *client = (gateway_client*)context;
gateway_context *gateway = client->gateway;
int return_value = 0;
message msg;
message snd_msg;
int index;
int flag_found = 0;
return_value = read_message(client->comm_socket_fd, &msg);
if(return_value != E_SUCCESS)
{
if(return_value == E_SOCKET_CONNECTION_CLOSED)
{
LOG_ERROR(("ERROR: Connection closed for client: %s-%s-%s...\n",
client->client_ip_address,
client->client_port_number,
client->area_id));
remove_socket(client->gateway->network_thread, client->comm_socket_fd);
client->connection_state = 0;
LOG_ERROR(("ERROR: Connection closed for client\n"));
index = 0;
flag_found = 0;
for(index=0; index<gateway->client_count; index++)
{
if(gateway->clients[index]->comm_socket_fd == client->comm_socket_fd)
{
flag_found = 1;
break;
}
}
if(flag_found == 1)
{
for(;index<gateway->client_count-1; index++)
{
gateway->clients[index] = gateway->clients[index+1];
}
gateway->client_count--;
}
if(client->client_ip_address)
free(client->client_ip_address);
if(client->client_port_number)
free(client->client_port_number);
if(client->area_id)
free(client->area_id);
free(client);
return NULL;
}
LOG_ERROR(("ERROR: Error in read message\n"));
return NULL;
}
switch(msg.type)
{
case SET_INTERVAL:
LOG_DEBUG(("DEBUG: SetInterval message received, Value: %d\n", msg.u.value));
break;
case REGISTER:
LOG_DEBUG(("DEBUG: Register message received\n"));
client->type = msg.u.s.type;
client->client_ip_address = msg.u.s.ip_address;
client->client_port_number = msg.u.s.port_no;
client->area_id = msg.u.s.area_id;
LOG_DEBUG(("DEBUG: DeviceType:%d\n", client->type));
LOG_DEBUG(("DEBUG: IP Address: %s\n", client->client_ip_address));
LOG_DEBUG(("DEBUG: Port Number: %s\n", client->client_port_number));
LOG_DEBUG(("DEBUG: Area Id: %s\n", client->area_id));
if(client->type == SENSOR)
{
client->state = 1;
}
if(client->type == SMART_DEVICE)
{
client->state = 0;
}
break;
case CURRENT_VALUE:
LOG_DEBUG(("Current value message received\n"));
LOG_DEBUG(("Value: %d\n", msg.u.value));
client->value = msg.u.value;
if(msg.u.value < 32)
{
/* switch all smart devices in area id on */
int index;
for(index=0; index<gateway->client_count; index++)
{
if(gateway->clients[index]->type == SMART_DEVICE &&
strcmp(gateway->clients[index]->area_id, client->area_id)==0 &&
gateway->clients[index]->state == 0)
{
snd_msg.type = SWITCH;
snd_msg.u.value = 1;
return_value = write_message(gateway->clients[index]->comm_socket_fd, &snd_msg);
if(E_SUCCESS != return_value)
{
LOG_ERROR(("Error in sending switch on message to device %s-%s-%s",
gateway->clients[index]->client_ip_address,
gateway->clients[index]->client_port_number,
gateway->clients[index]->area_id));
}
gateway->clients[index]->state = 1;
}
}
}
if(msg.u.value > 34)
{
/* switch all smart devices in area id off */
int index;
int flag = 1;
for(index=0; index<gateway->client_count; index++)
{
if(gateway->clients[index]->type == SENSOR &&
strcmp(gateway->clients[index]->area_id, client->area_id)==0 &&
gateway->clients[index]->value < 34)
{
flag = 0;
break;
}
}
if(flag == 1)
{
for(index=0; index<gateway->client_count; index++)
{
if(gateway->clients[index]->type == SMART_DEVICE &&
strcmp(gateway->clients[index]->area_id, client->area_id)==0 &&
gateway->clients[index]->state == 1)
{
snd_msg.type = SWITCH;
snd_msg.u.value = 0;
return_value = write_message(gateway->clients[index]->comm_socket_fd, &snd_msg);
if(E_SUCCESS != return_value)
{
LOG_ERROR(("Error in sending switch on message to device %s-%s-%s",
gateway->clients[index]->client_ip_address,
gateway->clients[index]->client_port_number,
gateway->clients[index]->area_id));
}
gateway->clients[index]->state = 0;
}
}
}
}
print_state(client->gateway);
break;
case CURRENT_STATE:
LOG_DEBUG(("DEBUG: Current state message is received\n"));
//client->state = msg.u.value;
//print_state(client->gateway);
break;
default:
LOG_DEBUG(("Unknown/Unhandled message is received\n"));
break;
}
return (NULL);
}
