Programmation réseau avec Qt Network

Le module Qt Network offre des classes qui vous permettent d'écrire des clients et des serveurs TCP/IP. Il propose des classes de bas niveau telles que QTcpSocket, QTcpServer et QUdpSocket qui représentent des concepts de réseau de bas niveau, et des classes de haut niveau telles que QNetworkRequest, QNetworkReply et QNetworkAccessManager pour effectuer des opérations de réseau à l'aide de protocoles communs.

Qt Network fournit également une API pour la sécurité de la couche transport (TLS) et des fonctions de sécurité utilisant un backend TLS natif, la boîte à outils OpenSSL ou tout plugin TLS approprié. Reportez-vous aux classes Secure Sockets Layer (SSL) pour plus d'informations.

Classes de Qt Network pour la programmation réseau

La page Qt Network C++ Classes contient une liste des classes C++ de Qt Network.

Opérations réseau de haut niveau pour HTTP

L'API d'accès au réseau est une collection de classes permettant d'effectuer des opérations réseau courantes. L'API fournit une couche d'abstraction sur les opérations et les protocoles spécifiques utilisés (par exemple, l'obtention et l'envoi de données par HTTP), et n'expose que des classes, des fonctions et des signaux pour des concepts généraux ou de haut niveau.

Les requêtes réseau sont représentées par la classe QNetworkRequest, qui sert également de conteneur général pour les informations associées à une requête, telles que les informations d'en-tête et le cryptage utilisé. L'URL spécifiée lors de la construction d'un objet de requête détermine le protocole utilisé pour une requête. Actuellement, HTTP et les URL de fichiers locaux sont pris en charge pour le chargement et le téléchargement.

La coordination des opérations de réseau est assurée par la classe QNetworkAccessManager. Une fois qu'une requête a été créée, cette classe est utilisée pour l'envoyer et émettre des signaux pour rendre compte de sa progression. Le gestionnaire coordonne également l'utilisation de cookies pour stocker les données sur le client, les demandes d'authentification et l'utilisation de proxies.

Les réponses aux demandes du réseau sont représentées par la classe QNetworkReply; elles sont créées par QNetworkAccessManager lorsqu'une demande est envoyée. Les signaux fournis par QNetworkReply peuvent être utilisés pour surveiller chaque réponse individuellement, ou les développeurs peuvent choisir d'utiliser les signaux du gestionnaire à cette fin et de supprimer les références aux réponses. Comme QNetworkReply est une sous-classe de QIODevice, les réponses peuvent être traitées de manière synchrone ou asynchrone, c'est-à-dire comme des opérations bloquantes ou non bloquantes.

Chaque application ou bibliothèque peut créer une ou plusieurs instances de QNetworkAccessManager pour gérer la communication réseau.

Utilisation de TCP avec QTcpSocket et QTcpServer

TCP (Transmission Control Protocol) est un protocole réseau de bas niveau utilisé par la plupart des protocoles Internet, y compris HTTP et FTP, pour le transfert de données. Il s'agit d'un protocole de transport fiable, orienté flux et connexion. Il est particulièrement bien adapté à la transmission continue de données.

La classe QTcpSocket fournit une interface pour TCP. Vous pouvez utiliser QTcpSocket pour mettre en œuvre des protocoles réseau standard tels que POP3, SMTP et NNTP, ainsi que des protocoles personnalisés.

Une connexion TCP doit être établie avec un hôte et un port distants avant qu'un transfert de données puisse commencer. Une fois la connexion établie, l'adresse IP et le port de l'homologue sont disponibles via QTcpSocket::peerAddress() et QTcpSocket::peerPort(). À tout moment, l'homologue peut fermer la connexion et le transfert de données s'arrête alors immédiatement.

QTcpSocket fonctionne de manière asynchrone et émet des signaux pour signaler les changements d'état et les erreurs, tout comme QNetworkAccessManager. Il s'appuie sur la boucle d'événements pour détecter les données entrantes et évacuer automatiquement les données sortantes. Vous pouvez écrire des données sur la socket en utilisant QTcpSocket::write(), et lire des données en utilisant QTcpSocket::read(). QTcpSocket représente deux flux de données indépendants : l'un pour la lecture et l'autre pour l'écriture.

Comme QTcpSocket hérite de QIODevice, vous pouvez l'utiliser avec QTextStream et QDataStream. Lorsque vous lisez à partir de QTcpSocket, vous devez vous assurer que suffisamment de données sont disponibles en appelant QTcpSocket::bytesAvailable() au préalable.

Si vous devez gérer des connexions TCP entrantes (par exemple, dans une application serveur), utilisez la classe QTcpServer. Appelez QTcpServer::listen() pour configurer le serveur et connectez-vous au signal QTcpServer::newConnection(), qui est émis une fois pour chaque client qui se connecte. Dans votre slot, appelez QTcpServer::nextPendingConnection() pour accepter la connexion et utilisez le signal QTcpSocket retourné pour communiquer avec le client.

Bien que la plupart de ses fonctions fonctionnent de manière asynchrone, il est possible d'utiliser QTcpSocket de manière synchrone (c'est-à-dire bloquante). Pour obtenir un comportement bloquant, appelez les fonctions waitFor...() de QTcpSocket; celles-ci suspendent le thread appelant jusqu'à ce qu'un signal ait été émis. Par exemple, après avoir appelé la fonction non bloquante QTcpSocket::connectToHost(), appelez QTcpSocket::waitForConnected() pour bloquer le thread jusqu'à ce que le signal connected() soit émis.

Les sockets synchrones conduisent souvent à un code dont le flux de contrôle est plus simple. Le principal inconvénient de l'approche waitFor...() est que les événements ne seront pas traités lorsqu'une fonction waitFor...() est bloquée. Si elle est utilisée dans le fil d'exécution de l'interface graphique, l'interface utilisateur de l'application risque de se figer. C'est pourquoi nous vous recommandons de n'utiliser les sockets synchrones que dans les threads autres que ceux de l'interface graphique. Lorsqu'il est utilisé de manière synchrone, QTcpSocket ne nécessite pas de boucle d'événements.

Les exemples Fortune Client et Fortune Server montrent comment utiliser QTcpSocket et QTcpServer pour écrire des applications client-serveur TCP. Voir aussi Blocking Fortune Client pour un exemple d'utilisation d'un QTcpSocket synchrone dans un thread séparé (sans utiliser de boucle d'événements), et Threaded Fortune Server pour un exemple de serveur TCP multithread avec un thread par client actif.

Utilisation de UDP avec QUdpSocket

UDP (User Datagram Protocol) est un protocole léger, non fiable, orienté vers les datagrammes et sans connexion. Il peut être utilisé lorsque la fiabilité n'est pas importante. Par exemple, un serveur qui indique l'heure de la journée pourrait choisir UDP. Si un datagramme contenant l'heure est perdu, le client peut simplement faire une autre demande.

La classe QUdpSocket vous permet d'envoyer et de recevoir des datagrammes UDP. Elle hérite de QAbstractSocket et partage donc la plupart des interfaces de QTcpSocket. La principale différence réside dans le fait que QUdpSocket transfère les données sous forme de datagrammes plutôt que sous forme de flux continu de données. En bref, un datagramme est un paquet de données de taille limitée (normalement inférieure à 512 octets), contenant l'adresse IP et le port de l'expéditeur et du destinataire du datagramme en plus des données transférées.

QUdpSocket prend en charge la diffusion IPv4. La diffusion est souvent utilisée pour mettre en œuvre des protocoles de découverte de réseau, tels que la recherche de l'hôte du réseau ayant le plus d'espace libre sur le disque dur. Un hôte diffuse un datagramme sur le réseau que tous les autres hôtes reçoivent. Chaque hôte qui reçoit une demande renvoie une réponse à l'expéditeur en indiquant l'espace disque libre dont il dispose actuellement. L'expéditeur attend de recevoir les réponses de tous les hôtes et peut alors choisir le serveur ayant le plus d'espace libre pour stocker les données. Pour diffuser un datagramme, il suffit de l'envoyer à l'adresse spéciale QHostAddress::Broadcast (255.255.255.255) ou à l'adresse de diffusion de votre réseau local.

QUdpSocket::bind() prépare la socket à accepter les datagrammes entrants, tout comme QTcpServer::listen() pour les serveurs TCP. Lorsqu'un ou plusieurs datagrammes arrivent, QUdpSocket émet le signal readyRead(). Appelez QUdpSocket::readDatagram() pour lire le datagramme.

Les exemples Broadcast Sender et Broadcast Receiver montrent comment écrire un émetteur et un récepteur UDP à l'aide de Qt.

QUdpSocket Qt prend également en charge la multidiffusion. Les exemples Multicast Sender et Multicast Receiver montrent comment écrire des clients UDP multicast.

Résolution des noms d'hôtes à l'aide de QHostInfo

Avant d'établir une connexion réseau, QTcpSocket et QUdpSocket effectuent une recherche de nom, traduisant le nom de l'hôte auquel vous vous connectez en une adresse IP. Cette opération est généralement effectuée à l'aide du protocole DNS (Domain Name Service).

QHostInfo fournit une fonction statique qui vous permet d'effectuer vous-même une telle recherche. En appelant QHostInfo::lookupHost() avec un nom d'hôte, un pointeur QObject et une signature de slot, QHostInfo effectuera la recherche de nom et invoquera le slot donné lorsque les résultats seront prêts. La recherche proprement dite est effectuée dans un thread séparé, en utilisant les méthodes propres au système d'exploitation pour effectuer les recherches de noms.

QHostInfo fournit également une fonction statique appelée QHostInfo::fromName() qui prend le nom de l'hôte en argument et renvoie les résultats. Dans ce cas, la recherche de nom est effectuée dans le même thread que l'appelant. Cette surcharge est utile pour les applications non-GUI ou pour effectuer des recherches de noms dans un thread séparé, non-GUI. (L'appel de cette fonction dans un thread GUI peut entraîner le blocage de l'interface utilisateur pendant que la fonction effectue la recherche).

Prise en charge des mandataires réseau

La communication réseau avec Qt Network peut être effectuée par l'intermédiaire de proxys, qui dirigent ou filtrent le trafic réseau entre les connexions locales et distantes.

Les proxys individuels sont représentés par la classe QNetworkProxy, qui est utilisée pour décrire et configurer la connexion à un proxy. Les types de proxy qui opèrent à différents niveaux de la communication réseau sont pris en charge, le support SOCKS 5 permettant le proxy du trafic réseau à un bas niveau, et les proxys HTTP et FTP fonctionnant au niveau du protocole. Voir QNetworkProxy::ProxyType pour plus d'informations.

Le proxy peut être activé pour chaque socket ou pour toutes les communications réseau d'une application. Une socket nouvellement ouverte peut être amenée à utiliser un proxy en appelant sa fonction QAbstractSocket::setProxy() avant qu'elle ne soit connectée. Le proxy à l'échelle de l'application peut être activé pour toutes les connexions de sockets ultérieures en utilisant la fonction QNetworkProxy::setApplicationProxy().

Les usines à mandataires sont utilisées pour créer des politiques d'utilisation des mandataires. QNetworkProxyFactory fournit des mandataires sur la base de requêtes portant sur des types de mandataires spécifiques. Les requêtes elles-mêmes sont encodées dans des objets QNetworkProxyQuery qui permettent de sélectionner les mandataires en fonction de critères clés, tels que le but du mandataire (TCP, UDP, serveur TCP, requête URL), le port local, l'hôte et le port distants, et le protocole utilisé (HTTP, FTP, etc.).

QNetworkProxyFactory::proxyForQuery() est utilisé pour interroger directement l'usine. Une politique de proxys à l'échelle de l'application peut être mise en œuvre en passant une fabrique à QNetworkProxyFactory::setApplicationProxyFactory() et une politique de proxys personnalisée peut être créée en sous-classant QNetworkProxyFactory; voir la documentation de la classe pour plus de détails.