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); }