asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/core/io/udp_server.cpp

207 lines
6.7 KiB
C++
Raw Normal View History

UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
/*************************************************************************/
/* udp_server.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "udp_server.h"
void UDPServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("listen", "port", "bind_address"), &UDPServer::listen, DEFVAL("*"));
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
ClassDB::bind_method(D_METHOD("poll"), &UDPServer::poll);
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
ClassDB::bind_method(D_METHOD("is_connection_available"), &UDPServer::is_connection_available);
Allow local port control on net_socket connections
2021-03-21 11:15:30 +01:00
ClassDB::bind_method(D_METHOD("get_local_port"), &UDPServer::get_local_port);
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
ClassDB::bind_method(D_METHOD("is_listening"), &UDPServer::is_listening);
ClassDB::bind_method(D_METHOD("take_connection"), &UDPServer::take_connection);
ClassDB::bind_method(D_METHOD("stop"), &UDPServer::stop);
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
ClassDB::bind_method(D_METHOD("set_max_pending_connections", "max_pending_connections"), &UDPServer::set_max_pending_connections);
ClassDB::bind_method(D_METHOD("get_max_pending_connections"), &UDPServer::get_max_pending_connections);
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_pending_connections", PROPERTY_HINT_RANGE, "0,256,1"), "set_max_pending_connections", "get_max_pending_connections");
}
Error UDPServer::poll() {
ERR_FAIL_COND_V(!_sock.is_valid(), ERR_UNAVAILABLE);
if (!_sock->is_open()) {
return ERR_UNCONFIGURED;
}
Error err;
int read;
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
IPAddress ip;
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
uint16_t port;
while (true) {
err = _sock->recvfrom(recv_buffer, sizeof(recv_buffer), read, ip, port);
if (err != OK) {
if (err == ERR_BUSY) {
break;
}
return FAILED;
}
Peer p;
p.ip = ip;
p.port = port;
List<Peer>::Element *E = peers.find(p);
if (!E) {
E = pending.find(p);
}
if (E) {
E->get().peer->store_packet(ip, port, recv_buffer, read);
} else {
if (pending.size() >= max_pending_connections) {
// Drop connection.
continue;
}
// It's a new peer, add it to the pending list.
Peer peer;
peer.ip = ip;
peer.port = port;
peer.peer = memnew(PacketPeerUDP);
peer.peer->connect_shared_socket(_sock, ip, port, this);
peer.peer->store_packet(ip, port, recv_buffer, read);
pending.push_back(peer);
}
}
return OK;
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
}
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
Error UDPServer::listen(uint16_t p_port, const IPAddress &p_bind_address) {
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
ERR_FAIL_COND_V(!_sock.is_valid(), ERR_UNAVAILABLE);
ERR_FAIL_COND_V(_sock->is_open(), ERR_ALREADY_IN_USE);
ERR_FAIL_COND_V(!p_bind_address.is_valid() && !p_bind_address.is_wildcard(), ERR_INVALID_PARAMETER);
Allow local port control on net_socket connections
2021-03-21 11:15:30 +01:00
ERR_FAIL_COND_V_MSG(p_port < 0 || p_port > 65535, ERR_INVALID_PARAMETER, "The local port number must be between 0 and 65535 (inclusive).");
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
Error err;
IP::Type ip_type = IP::TYPE_ANY;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (p_bind_address.is_valid()) {
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
ip_type = p_bind_address.is_ipv4() ? IP::TYPE_IPV4 : IP::TYPE_IPV6;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
err = _sock->open(NetSocket::TYPE_UDP, ip_type);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (err != OK) {
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
return ERR_CANT_CREATE;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
_sock->set_blocking_enabled(false);
_sock->set_reuse_address_enabled(true);
err = _sock->bind(p_bind_address, p_port);
if (err != OK) {
stop();
return err;
}
return OK;
}
Allow local port control on net_socket connections
2021-03-21 11:15:30 +01:00
int UDPServer::get_local_port() const {
uint16_t local_port;
_sock->get_socket_address(nullptr, &local_port);
return local_port;
}
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
bool UDPServer::is_listening() const {
ERR_FAIL_COND_V(!_sock.is_valid(), false);
return _sock->is_open();
}
bool UDPServer::is_connection_available() const {
ERR_FAIL_COND_V(!_sock.is_valid(), false);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!_sock->is_open()) {
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
return pending.size() > 0;
}
void UDPServer::set_max_pending_connections(int p_max) {
ERR_FAIL_COND_MSG(p_max < 0, "Max pending connections value must be a positive number (0 means refuse new connections).");
max_pending_connections = p_max;
while (p_max > pending.size()) {
List<Peer>::Element *E = pending.back();
if (!E) {
break;
}
memdelete(E->get().peer);
pending.erase(E);
}
}
int UDPServer::get_max_pending_connections() const {
return max_pending_connections;
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
}
Ref<PacketPeerUDP> UDPServer::take_connection() {
Ref<PacketPeerUDP> conn;
if (!is_connection_available()) {
return conn;
}
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
Peer peer = pending[0];
pending.pop_front();
peers.push_back(peer);
return peer.peer;
}
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
void UDPServer::remove_peer(IPAddress p_ip, int p_port) {
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
Peer peer;
peer.ip = p_ip;
peer.port = p_port;
List<Peer>::Element *E = peers.find(peer);
if (E) {
peers.erase(E);
}
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
}
void UDPServer::stop() {
if (_sock.is_valid()) {
_sock->close();
}
UDPServer handles PacketPeerUDP-client association UDPServer now uses a single socket which is shared with the PacketPeerUDP it creates and has a new `poll` function to read incoming packets on that socket and delivers them to the appropriate peer. PacketPeerUDP created this way never reads from the socket, but are allowed to write on it using sendto. This is needed because Windows (unlike Linux/BSD) does not support packet routing when multiple sockets are bound on the same address/port.
2020-06-25 15:32:50 +02:00
List<Peer>::Element *E = peers.front();
while (E) {
E->get().peer->disconnect_shared_socket();
E = E->next();
}
E = pending.front();
while (E) {
E->get().peer->disconnect_shared_socket();
memdelete(E->get().peer);
E = E->next();
}
peers.clear();
pending.clear();
UDPServer and PacketPeerUDP connect_to_host. UDP sockets can be "connected" to filter packets from a specific source. In case of a bound socket (e.g. server), a new socket can be created on the same address/port that will receive all packets that are not filtered by a more specific socket (e.g. the previously connect socket). This way, a UDPServer can listen to new packets, and return a new PacketPeerUDP when receiving one, knowing that is a "new client".
2019-08-22 19:03:35 +02:00
}
UDPServer::UDPServer() :
_sock(Ref<NetSocket>(NetSocket::create())) {
}
UDPServer::~UDPServer() {
stop();
}
Reference in a new issue Copy permalink