Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

DTLSServer

Eredita: RefCounted < Object

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.