Sur cette page

QCoapClient Class

La classe QCoapClient permet à l'application d'envoyer des requêtes CoAP et de recevoir des réponses. En savoir plus...

En-tête : #include <QCoapClient>
CMake : find_package(Qt6 REQUIRED COMPONENTS Coap)
target_link_libraries(mytarget PRIVATE Qt6::Coap)
qmake : QT += coap
Hérite de : QObject

Remarque : toutes les fonctions de cette classe sont réentrantes.

Propriétés

Fonctions publiques

QCoapClient(QtCoap::SecurityMode securityMode = QtCoap::SecurityMode::NoSecurity, QObject *parent = nullptr)
virtual ~QCoapClient()
QNetworkInterface bindInterface() const
void cancelObserve(QCoapReply *notifiedReply)
void cancelObserve(const QUrl &url)
QCoapReply *deleteResource(const QCoapRequest &request)
QCoapReply *deleteResource(const QUrl &url)
void disconnect()
QCoapResourceDiscoveryReply *discover(const QUrl &url, const QString &discoveryPath = QLatin1String("/.well-known/core"))
QCoapResourceDiscoveryReply *discover(QtCoap::MulticastGroup group = QtCoap::MulticastGroup::AllCoapNodesIPv4, int port = QtCoap::DefaultPort, const QString &discoveryPath = QLatin1String("/.well-known/core"))
QCoapReply *get(const QCoapRequest &request)
QCoapReply *get(const QUrl &url)
QCoapReply *observe(const QCoapRequest &request)
QCoapReply *observe(const QUrl &url)
QCoapReply *post(const QCoapRequest &request, const QByteArray &data = QByteArray())
QCoapReply *post(const QCoapRequest &request, QIODevice *device)
QCoapReply *post(const QUrl &url, const QByteArray &data = QByteArray())
QCoapReply *put(const QCoapRequest &request, const QByteArray &data = QByteArray())
QCoapReply *put(const QCoapRequest &request, QIODevice *device)
QCoapReply *put(const QUrl &url, const QByteArray &data = QByteArray())
void setAckRandomFactor(double ackRandomFactor)
void setAckTimeout(uint ackTimeout)
void setBindInterface(const QNetworkInterface &iface)
void setBlockSize(quint16 blockSize)
void setMaximumRetransmitCount(uint maximumRetransmitCount)
void setMaximumServerResponseDelay(uint responseDelay)
void setMinimumTokenSize(int tokenSize)
void setSecurityConfiguration(const QCoapSecurityConfiguration &configuration)
void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)

Signaux

void bindInterfaceChanged(const QNetworkInterface &iface)
void error(QCoapReply *reply, QtCoap::Error error)
void finished(QCoapReply *reply)
void responseToMulticastReceived(QCoapReply *reply, const QCoapMessage &message, const QHostAddress &sender)

Description détaillée

La classe QCoapClient contient des signaux qui sont déclenchés lorsque la réponse à une requête envoyée est reçue.

L'application peut utiliser un QCoapClient pour envoyer des requêtes sur un réseau CoAP. Elle fournit des fonctions pour les requêtes standard : chacune renvoie un objet ` QCoapReply `, auquel les données de réponse doivent être transmises ; celles-ci peuvent être lues lorsque le signal ` finished()` est déclenché.

Une requête simple peut être envoyée à l'aide de :

QCoapClient *client = new QCoapClient(this);
connect(client, &QCoapClient::finished, this, &TestClass::slotFinished);
client->get(QCoapRequest(Qurl("coap://coap.me/test")));

Remarque : une fois le traitement de la requête terminé, il incombe à l’utilisateur de supprimer l’objet ` QCoapReply ` au moment opportun. Ne le supprimez pas directement dans le slot associé à ` finished()`. Vous pouvez utiliser la fonction ` deleteLater()`.

Vous pouvez également utiliser une requête d’observation. Celle-ci peut être utilisée comme ci-dessus, ou de manière plus pratique avec le signal QCoapReply::notified() :

QCoapRequest request = QCoapRequest(Qurl("coap://coap.me/obs"));
QCoapReply *reply = client->observe(request);
connect(reply, &QCoapReply::notified, this, &TestClass::slotNotified);

Et l’observation peut être annulée avec :

client->cancelObserve(reply);

Lorsqu’une réponse arrive, le QCoapClient émet un signal finished().

Remarque : pour une requête de découverte, l’objet renvoyé est un ` QCoapResourceDiscoveryReply`. Il peut être utilisé de la même manière qu’un ` QCoapReply `, mais contient également une liste de ressources.

Considérations de sécurité

Lors d’un transfert par blocs, la charge utile de la réponse s’accumule en mémoire jusqu’à la fin du transfert, et ` QtCoap ` n’impose aucune limite supérieure à la taille accumulée. Un serveur malveillant ou défectueux qui continue d’envoyer des blocs sans jamais signaler le dernier peut donc pousser le client à épuiser sa mémoire. La taille cumulée n’est pas observable pendant que le transfert est en cours ; une application ne peut donc pas la limiter directement. N’effectuez des échanges par blocs qu’avec des serveurs de confiance, et de préférence sur un réseau de confiance ou isolé.

Multidiffusion

Le protocole DTLS protège une connexion entre deux points d’extrémité et ne peut donc pas s’appliquer à la multidiffusion, où il peut y avoir plus de deux points d’extrémité. De ce fait, une requête de multidiffusion et ses réponses ne sont ni chiffrées ni authentifiées.

Chaque hôte du groupe peut répondre à une requête de multidiffusion. Dans CoAP, ces hôtes sont tous des propriétaires légitimes de la ressource et sont censés fournir des réponses équivalentes. Lorsqu’une réponse est envoyée bloc par bloc, les blocs restants sont récupérés par monodiffusion à partir de l’hôte qui a répondu.

La multidiffusion CoAP est conçue en partant du principe que le réseau est sécurisé et que chaque nœud du groupe est fiable. N’utilisez la multidiffusion que dans des scénarios répondant à cette hypothèse.

Voir également QCoapRequest, QCoapReply et QCoapResourceDiscoveryReply.

Documentation sur les propriétés

[since 6.11] bindInterface : QNetworkInterface

Cette propriété spécifie l'interface réseau à utiliser par le socket

La valeur par défaut est un objet ` invalid ` de type ` QNetworkInterface `, ce qui signifie que les paquets entrants seront acceptés depuis toutes les interfaces réseau. De même, toutes les interfaces réseau peuvent être utilisées pour envoyer des paquets sortants.

Lorsqu’une interface réseau valide est spécifiée, les paquets entrants ne seront acceptés qu’à partir de cette interface. De même, les paquets sortants ne seront envoyés qu’à l’aide de cette interface.

La modification de cette propriété ne prend effet qu’au prochain établissement de connexion du client au socket ; veillez donc à appeler ` disconnect()` si une communication a déjà eu lieu.

Cette énumération a été introduite dans Qt 6.11.

Fonctions d’accès :

QNetworkInterface bindInterface() const
void setBindInterface(const QNetworkInterface &iface)

Signal de notification :

void bindInterfaceChanged(const QNetworkInterface &iface)

Documentation des fonctions membres

[explicit] QCoapClient::QCoapClient(QtCoap::SecurityMode securityMode = QtCoap::SecurityMode::NoSecurity, QObject *parent = nullptr)

Crée un objet `QCoapClient` pour l'securityMode ` spécifiée et définit ` parent ` comme objet parent.

La valeur par défaut de ` securityMode ` est ` QtCoap::NoSecurity`, ce qui désactive la sécurité.

[virtual noexcept] QCoapClient::~QCoapClient()

Détruit l'objet ` QCoapClient ` et libère toutes les ressources associées. Notez que les objets ` QCoapReply ` renvoyés par cette classe ont pour parent l'objet ` QCoapClient ` ; ils seront donc supprimés en même temps que celui-ci.

void QCoapClient::cancelObserve(QCoapReply *notifiedReply)

Annule la surveillance d'une ressource à l'aide de la réponse « notifiedReply » renvoyée par la méthode observe().

Il s'agit d'une fonction surchargée.

Voir également observe().

void QCoapClient::cancelObserve(const QUrl &url)

Annule l'observation d'une ressource identifiée par l'url.

Il s'agit d'une fonction surchargée.

Voir également observe().

QCoapReply *QCoapClient::deleteResource(const QCoapRequest &request)

Envoie l'request à l'aide de la méthode DELETE et renvoie un nouvel objet QCoapReply.

Voir également get(), put(), post(), observe() et discover().

QCoapReply *QCoapClient::deleteResource(const QUrl &url)

Envoie une requête DELETE à l'url.

Il s'agit d'une fonction surchargée.

Voir également get(), put(), post(), observe() et discover().

void QCoapClient::disconnect()

Ferme les sockets et les connexions ouvertes afin de libérer le transport.

Remarque : en mode sécurisé, cette fonction doit être appelée avant de modifier la configuration de sécurité ou de se connecter à un autre serveur.

Voir également setSecurityConfiguration().

QCoapResourceDiscoveryReply *QCoapClient::discover(const QUrl &url, const QString &discoveryPath = QLatin1String("/.well-known/core"))

Détecte les ressources disponibles à l'adresse url et renvoie un nouvel objet QCoapResourceDiscoveryReply qui émet le signal QCoapResourceDiscoveryReply::discovered() dès que la réponse arrive.

Le chemin de découverte est par défaut « /.well-known/core », mais peut être modifié en passant un chemin différent à discoveryPath. La découverte est décrite dans la RFC 6690.

Voir également get(), post(), put(), deleteResource() et observe().

QCoapResourceDiscoveryReply *QCoapClient::discover(QtCoap::MulticastGroup group = QtCoap::MulticastGroup::AllCoapNodesIPv4, int port = QtCoap::DefaultPort, const QString &discoveryPath = QLatin1String("/.well-known/core"))

Détecte les ressources disponibles au niveau des terminaux ayant rejoint l'group à l'adresse port indiquée. Renvoie un nouvel objet QCoapResourceDiscoveryReply qui émet le signal QCoapResourceDiscoveryReply::discovered() dès qu'une réponse arrive. L'adresse group correspond à l'une des adresses de groupe de multidiffusion CoAP ; sa valeur par défaut est QtCoap::AllCoapNodesIPv4.

Le chemin de découverte est par défaut « /.well-known/core », mais peut être modifié en transmettant un chemin différent à discoveryPath. La découverte est décrite dans la RFC 6690.

Il s’agit d’une fonction surchargée.

Voir également get(), post(), put(), deleteResource() et observe().

[signal] void QCoapClient::error(QCoapReply *reply, QtCoap::Error error)

Ce signal est émis chaque fois qu'une erreur se produit. Le paramètre reply peut prendre la valeur « nullptr » si l'erreur n'est pas liée à une QCoapReply spécifique. Le paramètre error contient le code d'erreur.

Voir également finished(), QCoapReply::error() et QCoapReply::finished().

[signal] void QCoapClient::finished(QCoapReply *reply)

Ce signal est émis en même temps que le signal « QCoapReply::finished() » chaque fois qu’une réponse CoAP est reçue, qu’il s’agisse d’une opération réussie ou d’une erreur. Le paramètre « reply » contiendra un pointeur vers la réponse qui vient d’être reçue.

Voir également error(), QCoapReply::finished() et QCoapReply::error().

QCoapReply *QCoapClient::get(const QCoapRequest &request)

Envoie l'request à l'aide de la méthode GET et renvoie un nouvel objet QCoapReply.

Voir également post(), put(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::get(const QUrl &url)

Envoie une requête GET à url et renvoie un nouvel objet QCoapReply.

Il s'agit d'une fonction surchargée.

Voir également post(), put(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::observe(const QCoapRequest &request)

Envoie une requête pour surveiller l'request cible et renvoie un nouvel objet QCoapReply qui émet le signal QCoapReply::notified() dès qu'une nouvelle notification arrive.

Voir également cancelObserve(), get(), post(), put(), deleteResource() et discover().

QCoapReply *QCoapClient::observe(const QUrl &url)

Envoie une requête pour surveiller l'url cible et renvoie un nouvel objet QCoapReply qui émet le signal QCoapReply::notified() dès qu'une nouvelle notification arrive.

Il s'agit d'une fonction surchargée.

Voir également cancelObserve(), get(), post(), put(), deleteResource() et discover().

QCoapReply *QCoapClient::post(const QCoapRequest &request, const QByteArray &data = QByteArray())

Envoie l'request à l'aide de la méthode POST et renvoie un nouvel objet QCoapReply. Utilise data comme charge utile pour cette requête. Si data est vide, la charge utile de request sera utilisée.

Voir également get(), put(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::post(const QCoapRequest &request, QIODevice *device)

Envoie l'request e à l'aide de la méthode POST et renvoie un nouvel objet QCoapReply. Utilise le contenu de device comme charge utile pour cette requête. Un périphérique null est considéré comme un contenu vide ; dans ce cas, la charge utile de request sera utilisée.

Remarque : le périphérique doit être ouvert et accessible en lecture avant d’appeler cette fonction.

Il s’agit d’une fonction surchargée.

Voir également get(), put(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::post(const QUrl &url, const QByteArray &data = QByteArray())

Envoie une requête POST à url et renvoie un nouvel objet QCoapReply. Utilise data comme charge utile pour cette requête.

Il s'agit d'une fonction surchargée.

Voir également get(), put(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::put(const QCoapRequest &request, const QByteArray &data = QByteArray())

Envoie l'request à l'aide de la méthode PUT et renvoie un nouvel objet QCoapReply. Utilise data comme charge utile pour cette requête. Si data est vide, la charge utile de request sera utilisée.

Voir également get(), post(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::put(const QCoapRequest &request, QIODevice *device)

Envoie l'request e à l'aide de la méthode PUT et renvoie un nouvel objet QCoapReply. Utilise le contenu de device comme charge utile pour cette requête. Un périphérique null est considéré comme un contenu vide ; dans ce cas, la charge utile de request sera utilisée.

Remarque : le périphérique doit être ouvert et accessible en lecture avant d’appeler cette fonction.

Il s'agit d'une fonction surchargée.

Voir également get(), post(), deleteResource(), observe() et discover().

QCoapReply *QCoapClient::put(const QUrl &url, const QByteArray &data = QByteArray())

Envoie une requête PUT à url et renvoie un nouvel objet QCoapReply. Utilise data comme charge utile pour cette requête.

Il s'agit d'une fonction surchargée.

Voir également get(), post(), deleteResource(), observe() et discover().

[signal] void QCoapClient::responseToMulticastReceived(QCoapReply *reply, const QCoapMessage &message, const QHostAddress &sender)

Ce signal est émis lorsqu'une réponse en unicast à une requête en multicast arrive. Le paramètre reply contient un pointeur vers la réponse qui vient d'être reçue, message contient la charge utile et les détails du message, et sender contient l'adresse de l'expéditeur.

Remarque : les requêtesde multidiffusion ne font pas l'objet d'une authentification ; voir multicast security considerations pour connaître le modèle de confiance sur lequel cela repose.

Voir également error(), QCoapReply::finished() et QCoapReply::error().

void QCoapClient::setAckRandomFactor(double ackRandomFactor)

Définit la valeur « ACK_RANDOM_FACTOR » (taux de mise à jour des données) définie dans la norme RFC 7252 - section 4.2, sur « ackRandomFactor ». Cette valeur doit être supérieure ou égale à 1. La valeur par défaut est 1,5.

Voir également setAckTimeout().

void QCoapClient::setAckTimeout(uint ackTimeout)

Définit la valeur « ACK_TIMEOUT » spécifiée dans la RFC 7252 – section 4.2 sur « ackTimeout » en millisecondes. La valeur par défaut est de 2 000 ms.

Ce délai d'expiration s'applique uniquement aux messages confirmables. Le délai d'expiration réel pour les transmissions fiables est une valeur aléatoire comprise entre ACK_TIMEOUT et ACK_TIMEOUT * ACK_RANDOM_FACTOR.

Voir également setAckRandomFactor().

void QCoapClient::setBlockSize(quint16 blockSize)

Définit la taille maximale des blocs utilisés par le protocole à blockSize lors de l'envoi de requêtes et de la réception de réponses. La taille des blocs doit être une puissance de deux.

void QCoapClient::setMaximumRetransmitCount(uint maximumRetransmitCount)

Définit la valeur « MAX_RETRANSMIT » (fréquence de mise à jour) définie dans la norme RFC 7252 - section 4.2 sur « maximumRetransmitCount ». Cette valeur doit être inférieure ou égale à 25. La valeur par défaut est 4.

void QCoapClient::setMaximumServerResponseDelay(uint responseDelay)

Définit la valeur « MAX_SERVER_RESPONSE_DELAY » sur « responseDelay » en millisecondes. La valeur par défaut est de 250 secondes.

Comme défini dans la RFC 7390 - Section 2.5, l'MAX_SERVER_RESPONSE_DELAY correspond au délai de réponse maximal attendu sur l'ensemble des serveurs auxquels le client peut envoyer une requête de multidiffusion.

void QCoapClient::setMinimumTokenSize(int tokenSize)

Définit la taille minimale des jetons à tokenSize s en octets. Pour des raisons de sécurité, il est recommandé d'utiliser des jetons d'une longueur d'au moins 4 octets. La valeur par défaut de ce paramètre est de 4 octets.

void QCoapClient::setSecurityConfiguration(const QCoapSecurityConfiguration &configuration)

Définit les paramètres de configuration de sécurité à partir de configuration. La configuration sera ignorée si le mode « QtCoap::NoSecurity » est utilisé.

Remarque : cette méthode doit être appelée avant le début de la négociation de connexion. Si vous devez modifier la configuration de sécurité après avoir établi une connexion sécurisée avec le serveur, le client doit d'abord être déconnecté.

Voir également disconnect().

void QCoapClient::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)

QUdpSocket Définit l'option de la socket sur value.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.