DTLSServer

Classe di supporto per implementare un server DTLS.

Descrizione

Questa classe serve per memorizzare lo stato di un server DTLS. Dopo aver chiamato setup(), converte i PacketPeerUDP connessi in PacketPeerDTLS accettandoli tramite take_connection() come client DTLS. Internamente, questa classe serve per memorizzare lo stato DTLS e i cookie del server. Il motivo per cui lo stato e i cookie sono necessari è al di fuori dell'ambito di questa documentazione.

Di seguito un piccolo esempio di come utilizzarla:

# server_node.gd
extends Node

var dtls = DTLSServer.new()
var server = UDPServer.new()
var peers = []

func _ready():
    server.listen(4242)
    var key = load("key.key") # La tua chiave privata.
    var cert = load("cert.crt") # Il tuo certificato X509.
    dtls.setup(TlsOptions.server(key, cert))

func _process(delta):
    while server.is_connection_available():
        var peer = server.take_connection()
        var dtls_peer = dtls.take_connection(peer)
        if dtls_peer.get_status() != PacketPeerDTLS.STATUS_HANDSHAKING:
            continue # È normale che il 50% delle connessioni falliscano a causa dello scambio di cookie.
        print("Peer connesso!")
        peers.append(dtls_peer)

    for p in peers:
        p.poll() # È necessario effettuare un polling per aggiornare lo stato.
        if p.get_status() == PacketPeerDTLS.STATUS_CONNECTED:
            while p.get_available_packet_count() > 0:
                print("Ricevuto messaggio da un cliente: %s" % p.get_packet().get_string_from_utf8())
                p.put_packet("Ciao cliente DTLS".to_utf8_buffer())

// ServerNode.cs
using Godot;

public partial class ServerNode : Node
{
    private DtlsServer _dtls = new DtlsServer();
    private UdpServer _server = new UdpServer();
    private Godot.Collections.Array<PacketPeerDtls> _peers = [];

    public override void _Ready()
    {
        _server.Listen(4242);
        var key = GD.Load<CryptoKey>("key.key"); // La tua chiave privata.
        var cert = GD.Load<X509Certificate>("cert.crt"); // Il tuo certificato X509.
        _dtls.Setup(TlsOptions.Server(key, cert));
    }

    public override void _Process(double delta)
    {
        while (_server.IsConnectionAvailable())
        {
            PacketPeerUdp peer = _server.TakeConnection();
            PacketPeerDtls dtlsPeer = _dtls.TakeConnection(peer);
            if (dtlsPeer.GetStatus() != PacketPeerDtls.Status.Handshaking)
            {
                continue; // È normale che il 50% delle connessioni falliscano a causa dello scambio di cookie.
            }
            GD.Print("Peer connesso!");
            _peers.Add(dtlsPeer);
        }

        foreach (var p in _peers)
        {
            p.Poll(); // È necessario effettuare un polling per aggiornare lo stato.
            if (p.GetStatus() == PacketPeerDtls.Status.Connected)
            {
                while (p.GetAvailablePacketCount() > 0)
                {
                    GD.Print($"Ricevuto messaggio da un cliente: {p.GetPacket().GetStringFromUtf8()}");
                    p.PutPacket("Ciao cliente DTLS".ToUtf8Buffer());
                }
            }
        }
    }
}

# client_node.gd
extends Node

var dtls = PacketPeerDTLS.new()
var udp = PacketPeerUDP.new()
var connected = false

func _ready():
    udp.connect_to_host("127.0.0.1", 4242)
    dtls.connect_to_peer(udp, false) # Utilizza true in produzione per convalidare il certificato!

func _process(delta):
    dtls.poll()
    if dtls.get_status() == PacketPeerDTLS.STATUS_CONNECTED:
        if !connected:
            # Prova di contattare il server
            dtls.put_packet("La risposta è... 42!".to_utf8_buffer())
        while dtls.get_available_packet_count() > 0:
            print("Connected: %s" % dtls.get_packet().get_string_from_utf8())
            connected = true

// ClientNode.cs
using Godot;
using System.Text;

public partial class ClientNode : Node
{
    private PacketPeerDtls _dtls = new PacketPeerDtls();
    private PacketPeerUdp _udp = new PacketPeerUdp();
    private bool _connected = false;

    public override void _Ready()
    {
        _udp.ConnectToHost("127.0.0.1", 4242);
        _dtls.ConnectToPeer(_udp, validateCerts: false); // Utilizza true in produzione per convalidare il certificato!
    }

    public override void _Process(double delta)
    {
        _dtls.Poll();
        if (_dtls.GetStatus() == PacketPeerDtls.Status.Connected)
        {
            if (!_connected)
            {
                // Prova a contattare il server
                _dtls.PutPacket("La risposta è... 42!".ToUtf8Buffer());
            }
            while (_dtls.GetAvailablePacketCount() > 0)
            {
                GD.Print($"Connected: {_dtls.GetPacket().GetStringFromUtf8()}");
                _connected = true;
            }
        }
    }
}

Metodi

Error	setup(server_options: TLSOptions)
PacketPeerDTLS	take_connection(udp_peer: PacketPeerUDP)

Descrizioni dei metodi

Error setup(server_options: TLSOptions) 🔗

Imposta il server DTLS per utilizzare le opzioni del server specificate da server_options. Vedi TLSOptions.server().

PacketPeerDTLS take_connection(udp_peer: PacketPeerUDP) 🔗

Prova ad avviare l'handshake DTLS con il peer udp_peer, il quale deve essere già connesso (vedi PacketPeerUDP.connect_to_host()).

Nota: Devi verificare che lo stato del PacketPeerUDP di ritorno sia PacketPeerDTLS.STATUS_HANDSHAKING, poiché è normale che il 50% delle nuove connessioni non siano valide a causa dello scambio di cookie.