QAbstractSocket Class

Documentation sur les fonctions membres

QAbstractSocket::QAbstractSocket(QAbstractSocket::SocketType socketType, QObject *parent)

Crée un nouveau socket abstrait de type socketType. L'argument ` parent ` est transmis au constructeur de QObject.

Voir aussi ` socketType()`, ` QTcpSocket` et ` QUdpSocket`.

[virtual noexcept] QAbstractSocket::~QAbstractSocket()

Supprime le socket.

void QAbstractSocket::abort()

Interrompt la connexion en cours et réinitialise le socket. Contrairement à la fonction ` disconnectFromHost()`, cette fonction ferme immédiatement le socket, en supprimant toutes les données en attente dans le tampon d'écriture.

Voir également disconnectFromHost() et close().

[virtual] bool QAbstractSocket::bind(const QHostAddress &address, quint16 port = 0, QAbstractSocket::BindMode mode = DefaultForPlatform)

Effectue une liaison avec l'adresse address sur le port port, en utilisant le nom de domaine BindMode mode .

Pour les sockets UDP, une fois la liaison établie, le signal QUdpSocket::readyRead() est émis dès qu’un datagramme UDP arrive à l’adresse et au port spécifiés. Cette fonction est donc utile pour écrire des serveurs UDP.

Pour les sockets TCP, cette fonction peut être utilisée pour spécifier l’interface à utiliser pour une connexion sortante, ce qui est utile en cas de présence de plusieurs interfaces réseau.

Par défaut, le socket est lié à l’adresse DefaultForPlatform BindMode . Si aucun port n’est spécifié, un port aléatoire est choisi.

En cas de succès, la fonction renvoie « true » et le socket passe à l’état « BoundState » ; dans le cas contraire, elle renvoie « false ».

bool QAbstractSocket::bind(quint16 port = 0, QAbstractSocket::BindMode mode = DefaultForPlatform)

Se lie à l'adresse QHostAddress:Any sur le port port, en utilisant le BindMode mode .

Par défaut, la socket est liée à l'adresse DefaultForPlatform BindMode . Si aucun port n'est spécifié, un port aléatoire est choisi.

[since 6.2] bool QAbstractSocket::bind(QHostAddress::SpecialAddress addr, quint16 port = 0, QAbstractSocket::BindMode mode = DefaultForPlatform)

Se lie à l'adresse spéciale addr sur le port port, en utilisant le BindMode mode .

Par défaut, la socket est liée à l'adresse DefaultForPlatform sur le port BindMode. Si aucun port n'est spécifié, un port aléatoire est choisi.

Cette fonction a été introduite dans Qt 6.2.

[override virtual] qint64 QAbstractSocket::bytesAvailable() const

Réimplémente : ` QIODevice::bytesAvailable()` const.

Renvoie le nombre d’octets entrants en attente de lecture.

Voir également bytesToWrite() et read().

[override virtual] qint64 QAbstractSocket::bytesToWrite() const

Réimplémente : ` QIODevice::bytesToWrite()` const.

Renvoie le nombre d’octets en attente d’écriture. Ces octets sont écrits lorsque le contrôle revient à la boucle d’événements ou lorsque la fonction flush() est appelée.

Voir également bytesAvailable() et flush().

[override virtual] void QAbstractSocket::close()

Réimplémente : QIODevice::close().

Ferme le périphérique d'E/S associé au socket et appelle disconnectFromHost() pour fermer la connexion du socket.

Voir QIODevice::close() pour une description des actions qui se produisent lorsqu'un périphérique d'E/S est fermé.

Voir également abort().

[virtual] void QAbstractSocket::connectToHost(const QString &hostName, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite, QAbstractSocket::NetworkLayerProtocol protocol = AnyIPProtocol)

Tente d'établir une connexion à hostName via l'adresse IP indiquée port. Le paramètre protocol permet de spécifier le protocole réseau à utiliser (par exemple, IPv4 ou IPv6).

Le socket est ouvert sur l’ openMode indiquée et accède d’abord à HostLookupState, puis effectue une recherche du nom d’hôte de hostName. Si la recherche aboutit, hostFound() est émis et QAbstractSocket accède à ConnectingState. Il tente ensuite de se connecter à l’adresse ou aux adresses renvoyées par la recherche. Enfin, si une connexion est établie, QAbstractSocket accède à ConnectedState et émet connected().

À tout moment, le socket peut émettre errorOccurred() pour signaler qu’une erreur s’est produite.

hostName peut être une adresse IP sous forme de chaîne de caractères (par exemple, « 43.195.83.32 ») ou un nom d’hôte (par exemple, « example.com »). La fonction QAbstractSocket n’effectuera une recherche que si nécessaire. La fonction port utilise l’ordre natif des octets.

Voir également state(), peerName(), peerAddress(), peerPort() et waitForConnected().

void QAbstractSocket::connectToHost(const QHostAddress &address, quint16 port, QIODeviceBase::OpenMode openMode = ReadWrite)

Tentative de connexion à address sur le port port.

[signal] void QAbstractSocket::connected()

Ce signal est émis après l'appel de la fonction connectToHost() et une fois la connexion établie avec succès.

Voir aussi ` connectToHost()` et ` disconnected()`.

[virtual] void QAbstractSocket::disconnectFromHost()

Tente de fermer le socket. S’il reste des données en attente d’écriture, ` QAbstractSocket ` passe en état « ClosingState » et attend que toutes les données aient été écrites. À terme, il passe en état « UnconnectedState » et émet le signal ` disconnected()`.

Voir également connectToHost().

[signal] void QAbstractSocket::disconnected()

Ce signal est émis lorsque la connexion a été interrompue.

Voir également connectToHost(), disconnectFromHost() et abort().

QAbstractSocket::SocketError QAbstractSocket::error() const

Renvoie le type de l'erreur qui s'est produite en dernier.

Voir également state() et errorString().

[signal] void QAbstractSocket::errorOccurred(QAbstractSocket::SocketError socketError)

Ce signal est émis lorsqu’une erreur s’est produite. Le paramètre ` socketError ` décrit le type d’erreur survenue.

Lorsque ce signal est émis, il se peut que le socket ne soit pas prêt pour une tentative de reconnexion. Dans ce cas, les tentatives de reconnexion doivent être effectuées à partir de la boucle d'événements. Par exemple, utilisez QChronoTimer::singleShot() avec un délai d'expiration de 0 ns.

QAbstractSocket::SocketError n'est pas un métatype enregistré ; pour les connexions en file d'attente, vous devrez donc l'enregistrer à l'aide des fonctions Q_DECLARE_METATYPE() et qRegisterMetaType().

Voir également error(), errorString() et Création de types Qt personnalisés.

bool QAbstractSocket::flush()

Cette fonction écrit autant de données que possible depuis le tampon d'écriture interne vers la socket réseau sous-jacente, sans blocage. Si des données ont été écrites, cette fonction renvoie ` true` ; dans le cas contraire, elle renvoie `false`.

Appelez cette fonction si vous avez besoin que ` QAbstractSocket ` commence immédiatement à envoyer les données mises en mémoire tampon. Le nombre d’octets écrits avec succès dépend du système d’exploitation. Dans la plupart des cas, vous n’avez pas besoin d’appeler cette fonction, car ` QAbstractSocket ` commencera automatiquement à envoyer les données dès que le contrôle reviendra à la boucle d’événements. En l’absence de boucle d’événements, appelez plutôt ` waitForBytesWritten()`.

Voir également ` write()` et ` waitForBytesWritten()`.

[signal] void QAbstractSocket::hostFound()

Ce signal est émis après l'appel de la fonction connectToHost() et une fois que la recherche de l'hôte a abouti.

Voir également connected().

[override virtual] bool QAbstractSocket::isSequential() const

Réimplémente : QIODevice::isSequential() const.

bool QAbstractSocket::isValid() const

Renvoie « true » si le socket est valide et prêt à être utilisé ; sinon, renvoie « false ».

Voir également state().

QHostAddress QAbstractSocket::localAddress() const

Renvoie l'adresse hôte du socket local si elle est disponible ; sinon, renvoie QHostAddress::Null.

Il s'agit généralement de l'adresse IP principale de l'hôte, mais elle peut être QHostAddress::LocalHost (127.0.0.1) pour les connexions à l'hôte local.

Voir également localPort(), peerAddress() et setLocalAddress().

quint16 QAbstractSocket::localPort() const

Renvoie le numéro de port de l'hôte (dans l'ordre natif des octets) de la socket locale s'il est disponible ; sinon, renvoie 0.

Voir également localAddress(), peerPort() et setLocalPort().

QAbstractSocket::PauseModes QAbstractSocket::pauseMode() const

Renvoie le mode de pause de cette socket.

Voir également setPauseMode() et resume().

QHostAddress QAbstractSocket::peerAddress() const

Renvoie l'adresse du pair connecté si le socket est en mode « ConnectedState » ; sinon, renvoie « QHostAddress::Null ».

Voir également peerName(), peerPort(), localAddress() et setPeerAddress().

QString QAbstractSocket::peerName() const

Renvoie le nom du pair tel que spécifié par la fonction connectToHost(), ou un objet QString vide si la fonction connectToHost() n'a pas été appelée.

Voir également peerAddress(), peerPort() et setPeerName().

quint16 QAbstractSocket::peerPort() const

Renvoie le port du pair connecté si le socket se trouve dans l'état « ConnectedState » ; sinon, renvoie 0.

Voir également peerAddress(), localPort() et setPeerPort().

QString QAbstractSocket::protocolTag() const

Renvoie l'identifiant de protocole associé à cette socket. Si cet identifiant est défini, il est transmis à ` QNetworkProxyQuery ` lors de la création interne de cette dernière afin d'indiquer l'identifiant de protocole à utiliser.

Voir également setProtocolTag() et QNetworkProxyQuery.

QNetworkProxy QAbstractSocket::proxy() const

Renvoie le proxy réseau associé à cette socket. Par défaut, QNetworkProxy::DefaultProxy est utilisé, ce qui signifie que cette socket interrogera les paramètres de proxy par défaut de l'application.

Voir également setProxy(), QNetworkProxy et QNetworkProxyFactory.

[signal] void QAbstractSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)

Ce signal peut être émis lorsqu'une connexion « proxy » nécessitant une authentification est utilisée. L'objet « authenticator » peut alors être renseigné avec les informations requises pour permettre l'authentification et poursuivre la connexion.

Voir également QAuthenticator et QNetworkProxy.

qint64 QAbstractSocket::readBufferSize() const

Renvoie la taille du tampon de lecture interne. Cela limite la quantité de données que le client peut recevoir avant que vous n'appeliez read() ou readAll().

Une taille de tampon de lecture égale à 0 (valeur par défaut) signifie que le tampon n'a pas de limite de taille, ce qui garantit qu'aucune donnée n'est perdue.

Voir également setReadBufferSize() et read().

[override virtual protected] qint64 QAbstractSocket::readData(char *data, qint64 maxSize)

Réimplémentation de : QIODevice::readData(char *data, qint64 maxSize).

[override virtual protected] qint64 QAbstractSocket::readLineData(char *data, qint64 maxlen)

Réimplémentation de : QIODevice::readLineData(char *data, qint64 maxSize).

[virtual] void QAbstractSocket::resume()

Poursuit le transfert de données sur le socket. Cette méthode ne doit être utilisée qu’après avoir configuré le socket pour qu’il se mette en pause à la réception d’une notification et qu’une notification ait effectivement été reçue. La seule notification actuellement prise en charge est ` QSslSocket::sslErrors()` (). L’appel de cette méthode alors que le socket n’est pas en pause entraîne un comportement indéfini.

Voir également pauseMode() et setPauseMode().

[protected] void QAbstractSocket::setLocalAddress(const QHostAddress &address)

Définit l'adresse côté local d'une connexion à address.

Vous pouvez appeler cette fonction dans une sous-classe de ` QAbstractSocket ` pour modifier la valeur renvoyée par la fonction ` localAddress()` une fois la connexion établie. Cette fonctionnalité est couramment utilisée par les connexions proxy pour la configuration des connexions virtuelles.

Notez que cette fonction ne lie pas l'adresse locale du socket avant l'établissement d'une connexion (par exemple, ` QAbstractSocket::bind()`).

Voir également localAddress(), setLocalPort() et setPeerAddress().

[protected] void QAbstractSocket::setLocalPort(quint16 port)

Définit le port côté local d'une connexion sur port.

Vous pouvez appeler cette fonction dans une sous-classe de ` QAbstractSocket ` pour modifier la valeur renvoyée par la fonction ` localPort()` une fois la connexion établie. Cette fonctionnalité est couramment utilisée par les connexions proxy pour les paramètres de connexion virtuelle.

Notez que cette fonction ne lie pas le port local du socket avant l'établissement d'une connexion (par exemple, ` QAbstractSocket::bind()`).

Voir également localPort(), localAddress(), setLocalAddress() et setPeerPort().

void QAbstractSocket::setPauseMode(QAbstractSocket::PauseModes pauseMode)

Détermine s'il faut mettre en pause à la réception d'une notification. Le paramètre ` pauseMode ` spécifie les conditions dans lesquelles le socket doit être mis en pause. La seule notification actuellement prise en charge est QSslSocket::sslErrors(). Si cette option est définie sur PauseOnSslErrors, le transfert de données sur le socket sera mis en pause et devra être réactivé explicitement en appelant resume(). Par défaut, cette option est définie sur PauseNever. Cette option doit être appelée avant de se connecter au serveur, sinon cela entraînera un comportement indéfini.

Voir également pauseMode() et resume().

[protected] void QAbstractSocket::setPeerAddress(const QHostAddress &address)

Définit l'adresse du côté distant de la connexion sur address.

Vous pouvez appeler cette fonction dans une sous-classe de ` QAbstractSocket ` pour modifier la valeur de retour de la fonction ` peerAddress()` une fois la connexion établie. Cette fonctionnalité est couramment utilisée par les connexions proxy pour les paramètres de connexion virtuelle.

Voir également peerAddress(), setPeerPort() et setLocalAddress().

[protected] void QAbstractSocket::setPeerName(const QString &name)

Définit le nom d'hôte du pair distant sur name.

Vous pouvez appeler cette fonction dans une sous-classe de QAbstractSocket pour modifier la valeur de retour de la fonction peerName() une fois la connexion établie. Cette fonctionnalité est couramment utilisée par les connexions proxy pour les paramètres de connexion virtuelle.

Voir également peerName().

[protected] void QAbstractSocket::setPeerPort(quint16 port)

Définit le port côté distant de la connexion sur port.

Vous pouvez appeler cette fonction dans une sous-classe de ` QAbstractSocket ` pour modifier la valeur de retour de la fonction ` peerPort()` une fois la connexion établie. Cette fonctionnalité est couramment utilisée par les connexions proxy pour les paramètres de connexion virtuelle.

Voir également peerPort(), setPeerAddress() et setLocalPort().

void QAbstractSocket::setProtocolTag(const QString &tag)

Définit l'identifiant de protocole de cette socket sur « tag ».

Voir également protocolTag().

void QAbstractSocket::setProxy(const QNetworkProxy &networkProxy)

Définit le proxy réseau explicite de ce socket sur networkProxy.

Pour désactiver l'utilisation d'un proxy pour ce socket, utilisez le type de proxy « QNetworkProxy::NoProxy » :

socket->setProxy(QNetworkProxy::NoProxy);

La valeur par défaut du proxy est « QNetworkProxy::DefaultProxy », ce qui signifie que le socket utilisera les paramètres de l’application : si un proxy est défini avec « QNetworkProxy::setApplicationProxy », il l’utilisera ; sinon, si une fabrique est définie avec « QNetworkProxyFactory::setApplicationProxyFactory », il interrogera cette fabrique avec le type « QNetworkProxyQuery::TcpSocket ».

Voir également proxy(), QNetworkProxy et QNetworkProxyFactory::queryProxy().

[virtual] void QAbstractSocket::setReadBufferSize(qint64 size)

Définit la taille du tampon de lecture interne de la fonction ` QAbstractSocket` à size octets.

Si la taille du tampon est limitée à une certaine valeur, ` QAbstractSocket ` ne mettra pas en tampon plus de données que cette taille. Exceptionnellement, une taille de tampon égale à 0 signifie que le tampon de lecture est illimité et que toutes les données entrantes sont mises en tampon. C'est la valeur par défaut.

Cette option est utile si vous ne lisez les données qu’à certains moments (par exemple, dans une application de streaming en temps réel) ou si vous souhaitez protéger votre socket contre la réception d’un volume trop important de données, ce qui pourrait finir par entraîner un épuisement de la mémoire de votre application.

Seule la fonction ` QTcpSocket ` utilise le tampon interne de ` QAbstractSocket` ; la fonction ` QUdpSocket ` n’utilise aucun tampon, mais s’appuie plutôt sur la mise en tampon implicite fournie par le système d’exploitation. De ce fait, l’appel de cette fonction sur ` QUdpSocket ` n’a aucun effet.

Voir également readBufferSize() et read().

[virtual] bool QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, QAbstractSocket::SocketState socketState = ConnectedState, QIODeviceBase::OpenMode openMode = ReadWrite)

Initialise QAbstractSocket avec le descripteur de socket natif socketDescriptor. Renvoie true si socketDescriptor est reconnu comme un descripteur de socket valide ; sinon, renvoie false. La socket est ouverte dans le mode spécifié par openMode et passe à l'état spécifié par socketState. Les tampons de lecture et d'écriture sont vidés, ce qui entraîne la suppression de toutes les données en attente.

Remarque : il n’est pas possible d’initialiser deux sockets abstraites avec le même descripteur de socket natif.

Voir également socketDescriptor().

[protected] void QAbstractSocket::setSocketError(QAbstractSocket::SocketError socketError)

Définit le type de la dernière erreur survenue dans ` socketError`.

Voir également setSocketState() et setErrorString().

[virtual] void QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)

Définit la fonction ` option ` indiquée sur la valeur décrite par ` value`.

Voir également socketOption().

[protected] void QAbstractSocket::setSocketState(QAbstractSocket::SocketState state)

Définit l'état de la socket sur « state ».

Voir aussi state().

[override virtual protected] qint64 QAbstractSocket::skipData(qint64 maxSize)

Réimplémente : QIODevice::skipData(qint64 maxSize).

[virtual] qintptr QAbstractSocket::socketDescriptor() const

Renvoie le descripteur de socket natif de l'objet ` QAbstractSocket ` s'il est disponible ; sinon, renvoie -1.

Si le socket utilise la fonction ` QNetworkProxy`, le descripteur renvoyé peut ne pas être utilisable avec les fonctions de socket natives.

Le descripteur de socket n'est pas disponible lorsque QAbstractSocket est en mode « UnconnectedState ».

Voir aussi setSocketDescriptor().

[virtual] QVariant QAbstractSocket::socketOption(QAbstractSocket::SocketOption option)

Renvoie la valeur de l'option « option ».

Voir aussi setSocketOption().

QAbstractSocket::SocketType QAbstractSocket::socketType() const

Renvoie le type de socket (TCP, UDP ou autre).

Voir également QTcpSocket et QUdpSocket.

QAbstractSocket::SocketState QAbstractSocket::state() const

Renvoie l'état du socket.

Voir aussi error().

[signal] void QAbstractSocket::stateChanged(QAbstractSocket::SocketState socketState)

Ce signal est émis chaque fois que l'état de ` QAbstractSocket` change. Le paramètre ` socketState ` correspond au nouvel état.

QAbstractSocket::SocketState n'est pas un métatype enregistré ; par conséquent, pour les connexions mises en file d'attente, vous devrez l'enregistrer à l'aide des fonctions Q_DECLARE_METATYPE() et qRegisterMetaType().

Voir également state() et Création de types Qt personnalisés.

[override virtual] bool QAbstractSocket::waitForBytesWritten(int msecs = 30000)

Réimplémentation de : QIODevice::waitForBytesWritten(int msecs).

Cette fonction reste bloquée jusqu’à ce qu’au moins un octet ait été écrit sur le socket et que le signal bytesWritten() ait été émis. La fonction expire après msecs millisecondes ; le délai d’expiration par défaut est de 30 000 millisecondes.

La fonction renvoie « true » si le signal « bytesWritten() » est émis ; sinon, elle renvoie « false » (si une erreur s’est produite ou si le délai d’attente a expiré).

Voir aussi ` waitForReadyRead()`.

[virtual] bool QAbstractSocket::waitForConnected(int msecs = 30000)

Attend que le socket soit connecté, pendant au maximum msecs millisecondes. Si la connexion a été établie, cette fonction renvoie true; sinon, elle renvoie false. Si elle renvoie false, vous pouvez appeler error() pour déterminer la cause de l'erreur.

L'exemple suivant attend jusqu'à une seconde que la connexion soit établie :

socket->connectToHost("imap", 143);
if (socket->waitForConnected(1000))
    qDebug("Connected!");

Si msecs vaut -1, cette fonction n'appliquera pas de délai d'expiration.

Voir également connectToHost() et connected().

[virtual] bool QAbstractSocket::waitForDisconnected(int msecs = 30000)

Attend que la connexion soit déconnectée, pendant un délai maximal de msecs millisecondes. Si la connexion a été déconnectée avec succès, cette fonction renvoie true; dans le cas contraire, elle renvoie false (si l'opération a dépassé le délai d'attente, si une erreur s'est produite ou si ce QAbstractSocket est déjà déconnecté). Si elle renvoie false, vous pouvez appeler error() pour déterminer la cause de l'erreur.

L'exemple suivant attend jusqu'à une seconde que la connexion soit fermée :

socket->disconnectFromHost();
if (socket->state()== QAbstractSocket::UnconnectedState
    || socket->waitForDisconnected(1000)) {
        qDebug("Disconnected!");
}

Si msecs vaut -1, cette fonction n'est soumise à aucun délai d'expiration.

Voir également disconnectFromHost() et close().

[override virtual] bool QAbstractSocket::waitForReadyRead(int msecs = 30000)

Réimplémentation de : QIODevice::waitForReadyRead(int msecs).

Cette fonction reste bloquée jusqu’à ce que de nouvelles données soient disponibles en lecture et que le signal readyRead() ait été émis. La fonction expire après msecs millisecondes ; le délai d’expiration par défaut est de 30000 millisecondes.

La fonction renvoie true si le signal readyRead() est émis et que de nouvelles données sont disponibles pour la lecture ; sinon, elle renvoie false (si une erreur s’est produite ou si l’opération a expiré).

Voir également waitForBytesWritten().

[override virtual protected] qint64 QAbstractSocket::writeData(const char *data, qint64 size)

Réimplémentation de : QIODevice::writeData(const char *data, qint64 maxSize).