Quic.NET

0x5c2aad80

Quicnet

Table des matières

• Qu'est-ce que Quicnet
• Commencer
  • Prévisualisation
  • Serveur
  • Client
• Qu'est-ce que Quic
  • Relations
  • Ruisseaux
  • Paquet
  • Cadre
• Contributif
• Plus

Qu'est-ce que Quicnet?

QuicNet est une implémentation .NET du protocole de quic mentionné ci-dessous. La mise en œuvre reste conforme à la 32e version du projet de quic-transport et n'offre pas encore la mise en œuvre des versions connexes suivantes:

• quic-tls
• recouvrement de la quic

Commencer

Exemples de travail minimaux

Prévisualisation

Serveur

 using System ;
using System . Text ;
using QuicNet ;
using QuicNet . Streams ;
using QuicNet . Connections ;

namespace QuickNet . Tests . ConsoleServer
{
    class Program
    {
        // Fired when a client is connected
        static void ClientConnected ( QuicConnection connection )
        {
            connection . OnStreamOpened += StreamOpened ;
        }
        
        // Fired when a new stream has been opened (It does not carry data with it)
        static void StreamOpened ( QuicStream stream )
        {
            stream . OnStreamDataReceived += StreamDataReceived ;
        }
        
        // Fired when a stream received full batch of data
        static void StreamDataReceived ( QuicStream stream , byte [ ] data )
        {
            string decoded = Encoding . UTF8 . GetString ( data ) ;
            
            // Send back data to the client on the same stream
            stream . Send ( Encoding . UTF8 . GetBytes ( "Ping back from server." ) ) ;
        }
        
        static void Main ( string [ ] args )
        {
            QuicListener listener = new QuicListener ( 11000 ) ;
            listener . OnClientConnected += ClientConnected ;

            listener . Start ( ) ;

            Console . ReadKey ( ) ;
        }
    }
} 

Client

 using System ;
using System . Text ;
using QuicNet . Connections ;
using QuicNet . Streams ;

namespace QuicNet . Tests . ConsoleClient
{
    class Program
    {
        static void Main ( string [ ] args )
        {
            QuicClient client = new QuicClient ( ) ;

            // Connect to peer (Server)
            QuicConnection connection = client . Connect ( "127.0.0.1" , 11000 ) ;
            // Create a data stream
            QuicStream stream = connection . CreateStream ( QuickNet . Utilities . StreamType . ClientBidirectional ) ;
            // Send Data
            stream . Send ( Encoding . UTF8 . GetBytes ( "Hello from Client!" ) ) ;   
            // Wait reponse back from the server (Blocks)
            byte [ ] data = stream . Receive ( ) ;

            Console . WriteLine ( Encoding . UTF8 . GetString ( data ) ) ;

            // Create a new data stream
            stream = connection . CreateStream ( QuickNet . Utilities . StreamType . ClientBidirectional ) ;
            // Send Data
            stream . Send ( Encoding . UTF8 . GetBytes ( "Hello from Client2!" ) ) ;
            // Wait reponse back from the server (Blocks)
            data = stream . Receive ( ) ;

            Console . WriteLine ( Encoding . UTF8 . GetString ( data ) ) ;

            Console . ReadKey ( ) ;
        }
    }
}

Qu'est-ce que Quic?

Quic est un protocole de couche de transport standardisé conforme à RFC 9000 conçu par Google, visant à accélérer le transfert de données des applications Web axées sur la connexion. Ce protocole au niveau de l'application vise à passer de TCP à UDP en utilisant plusieurs techniques pour ressembler au transfert TCP tout en réduisant les poignées de main de connexion, ainsi que pour fournir des techniques de multiplexage judicieuses d'une manière que différentes entités de données peuvent être entrelacées pendant le transfert.

Relations

Les connexions sont les canaux logiques de premier niveau représentant une communication entre deux points de terminaison. Lorsqu'une connexion est établie, un ID de connexion est négocié entre les deux points de terminaison. L'ID de connexion est utilisé pour identifier la connexion, même si des modifications se produisent sur les couches de protocole inférieures, telles qu'un téléphone modifiant le Wi-Fi ou le passage du Wi-Fi aux données mobiles. Ce mécanisme est appelé migration de connexion, ce qui empêche le redémarrage du flux de négociation et des données de retenue.

Ruisseaux

Les flux sont des canaux logiques de deuxième niveau représentant des flux de données. Une seule connexion peut avoir un nombre négocié de flux (8 maximum par exemple) qui servent d'entités de multiplexage. Chaque flux a le sien, ID de flux généré, utilisé pour identifier les différents objets de données transférés. Les flux sont fermés lorsque toutes les données sont lues ou que le transfert de données maximal négocié est atteint.

Paquet

Les paquets sont les unités de transfert de données. L'en-tête de paquet contient des informations sur la connexion à laquelle ce paquet est envoyé et des informations cryptographiques. Après avoir supprimé les informations de transfert supplémentaires, ce qui reste, ce sont les cadres de données (un paquet peut avoir plusieurs images).

Cadre

Les cadres sont la plus petite unité qui contiennent l'une ou l'autre des données qui doivent être transférées au point de terminaison ou aux paquets de protocole nécessaires pour des actions telles que la négociation de poignée de main, la gestion des erreurs et autres.

Contributif

Suivant le flux de travail GitHub Fork and Pull:

1. Fourk le repo sur github;
2. Cloner le projet localement;
3. Commettre des changements;
4. Repoussez votre travail jusqu'à votre fourchette;
5. Soumettez une demande de traction afin que les modifications passent par un examen.

Pour plus d'informations, lisez la contribution

Plus

Le projet de quic-transport peut être trouvé, comme mentionné précédemment chez Quic-Transport.

Pour tester Quic et trouver des informations supplémentaires, vous pouvez visiter jouer avec Quic.

Le code source officiel de C ++ se trouve à Proto-Quic.