Delphi-HTTP/3-Client | QUIC- & WebTransport-Komponenten | eSeGeCe

Delphi-HTTP/3-Client — QUIC und WebTransport für Pascal

Ein funktionierender HTTP/3-Stack für Delphi und C++Builder: TsgcHTTP3Client sendet RFC 9114-Requests über QUIC, mit QPACK-Header-Kompression, Alt-Svc-Discovery, Server Push und Extended-CONNECT-Tunneln. Rohe QUIC-Transport-Komponenten und WebTransport-Sessions gehören zum selben Paket, und ein HTTP/3-Server macht das Bild komplett.

Kostenlose Testversion Code-Beispiel ansehen

HTTP/3 in Delphi

Gleiche HTTP-Semantik, neuer Transport

HTTP/3 (RFC 9114) behält die Methoden, Statuscodes und Header, die du schon kennst, und ersetzt TCP durch QUIC, einen UDP-basierten Transport mit eingebautem TLS 1.3.

Ein Delphi-HTTP/3-Client gibt deiner Anwendung den Transport, auf den sich das moderne Web zubewegt. QUIC (RFC 9000) fasst Transport- und TLS-Handshake in einem einzigen Flight zusammen, beseitigt Head-of-Line-Blocking auf Transportebene (ein verlorenes Paket stoppt nur die Streams, deren Daten es trug) und übersteht Netzwerkwechsel dank Connection-IDs, sodass eine Verbindung einem Gerät von WLAN zu Mobilfunk folgen kann. Header werden mit QPACK (RFC 9204) komprimiert, dem HTTP/3-Ersatz für HPACK.

sgcWebSockets treibt QUIC über die native QUIC-Unterstützung in OpenSSL 3.5. Die Engine wird beim Laden der OpenSSL-Bibliothek automatisch erkannt: Mit den mitgelieferten OpenSSL-3.5-Binaries bekommst du die qmBuiltin-Engine, die mehrere Streams pro Verbindung unterstützt und um die die Komponenten herum gebaut sind. Für quictls-artige OpenSSL-Builds existiert ein qmCustom-Pfad, beschränkt auf einen Stream pro Verbindung.

HTTP/3-Client

TsgcHTTP3Client: blockierende und asynchrone Requests, Alt-Svc, Push, Tunnel

HTTP/3-Server

TsgcHTTP3Server: bedient Requests über QUIC, erbt von TsgcQUICServer

Raw QUIC

TsgcQUICClient / TsgcQUICServer: QUIC-Streams ohne HTTP-Semantik

Standards

RFC 9000 (QUIC), RFC 9114 (HTTP/3), RFC 9204 (QPACK), RFC 9220 (Extended CONNECT)

Funktionen

Was der HTTP/3-Client kann

Zehn HTTP-Methoden, dazu die HTTP/3-spezifische Maschinerie als Events und Methoden.

Alle Verben

GET, HEAD, POST, PUT, DELETE, PATCH, OPTIONS, TRACE, CONNECT und die neue IETF-QUERY-Methode, jede als blockierender Aufruf, die meisten zusätzlich mit asynchroner Variante.

Alt-Svc-Discovery

Server kündigen HTTP/3-Verfügbarkeit über den Alt-Svc-Header an (RFC 7838). Der Client parst ihn und reicht ihn über OnAltSvc weiter, deine Anwendung entscheidet, wann sie umschaltet.

Server Push

Der Client behält die Kontrolle über gepushte Responses: Kündige ein Limit mit SetMaxPushId an, werde über OnPushPromise benachrichtigt und lehne mit CancelPush ab.

Extended CONNECT

RFC 9220 tunnelt ein weiteres Protokoll durch einen Request-Stream. ExtendedConnect öffnet den Tunnel, wenn der Server Unterstützung ankündigt; danach bewegen TunnelSend und OnTunnelData die Bytes.

WebTransport

Über Extended CONNECT ausgehandelte Sessions, die der Anwendung QUIC-Streams direkt in die Hand geben, gebaut für bidirektionalen Verkehr mit niedriger Latenz. Stream-basiert; Datagramme trägt die ausgelieferte QUIC-Engine nicht.

QPACK-Kompression

RFC-9204-Header-Kompression, entworfen für die Out-of-Order-Zustellung von QUIC, mit Dynamic-Table-Updates auf dedizierten Encoder- und Decoder-Streams.

0-RTT-fähiger Handshake

QUIC fasst Transport und TLS 1.3 in einem Flight zusammen; eine frische Verbindung steht nach einem einzigen Round-Trip, und eine wiederaufgenommene Session kann 0-RTT-Daten schon im ersten Flight tragen.

Connection Migration

QUIC-Verbindungen werden über die Connection-ID identifiziert statt über das Adress-Vierertupel, sie überleben also einen Netzwerkwechsel des Clients.

Mehrere Streams

Auf der Builtin-Engine legen EnableMultiStream und OpenStream mehrere unabhängige QUIC-Streams auf eine Verbindung, das Fundament, auf dem WebTransport aufbaut.

Schnellstart

Ein GET-Request über HTTP/3

Verbinde dich mit einem Host und Port, dann stelle Requests. Der Standard-Port ist 443.

var
  oClient: TsgcHTTP3Client;
  vBody: string;
begin
  oClient := TsgcHTTP3Client.Create(nil);
  oClient.OnResponse := OnResponseHandler;
  oClient.OnAltSvc   := OnAltSvcHandler;

  oClient.Connect('www.example.com', 443);
  vBody := oClient.Get('https://www.example.com/');
  oClient.Disconnect;
end;

TsgcHTTP3Client* oClient = new TsgcHTTP3Client(NULL);
oClient->OnResponse = OnResponseHandler;
oClient->OnAltSvc   = OnAltSvcHandler;

oClient->Connect("www.example.com", 443);
String vBody = oClient->Get("https://www.example.com/");
oClient->Disconnect();

var oClient = new TsgcHTTP3Client();
oClient.OnResponse += OnResponseHandler;
oClient.OnAltSvc   += OnAltSvcHandler;

oClient.Connect("www.example.com", 443);
var vBody = oClient.Get("https://www.example.com/");
oClient.Disconnect();

Schnellstart — Server

Ein HTTP/3-Server in Delphi

Der Server bindet einen UDP-Port, lädt Zertifikat und Key und löst für jeden Request ein Event aus. HTTP/3-Unterstützung gibt es auch auf der HTTP-Server-Seite der Bibliothek.

var
  oServer: TsgcHTTP3Server;
begin
  oServer := TsgcHTTP3Server.Create(nil);
  oServer.Port := 443;
  oServer.QUICOptions.SSLOptions.CertFile := 'cert.pem';
  oServer.QUICOptions.SSLOptions.KeyFile  := 'key.pem';
  oServer.OnH3Request := OnH3RequestHandler;
end;

Voraussetzungen

Edition und Laufzeit-Voraussetzungen

HTTP/3, QUIC und WebTransport sind exklusiv in der All-Access-Edition enthalten. Die Komponenten benötigen den Indy-basierten Bibliothekskern und OpenSSL 3.5 oder neuer, das die native QUIC-Unterstützung liefert, auf der sie aufbauen.

WebTransport benötigt zusätzlich die eingebaute OpenSSL-QUIC-Engine (qmBuiltin), weil eine Session mehrere Streams auf einer QUIC-Verbindung braucht. Auch die Server-Komponenten laufen nur auf der Builtin-Engine. Da ein Client nicht voraussetzen kann, dass ein Server HTTP/3 spricht, halte den HTTP/2-Client für Origins bereit, die nur h2 ankündigen. Das Alt-Svc-Event sagt dir, wann HTTP/3 verfügbar ist.

Verwandt

See All-Access pricing