Fonction getsockopt (winsock.h)

Article
08/08/2024

La fonction getsockopt récupère une option de socket.

Syntaxe

int getsockopt(
  [in]      SOCKET s,
  [in]      int    level,
  [in]      int    optname,
  [out]     char   *optval,
  [in, out] int    *optlen
);

Paramètres

[in] s

Descripteur identifiant un socket.

[in] level

Niveau auquel l’option est définie. Exemple : SOL_SOCKET.

[in] optname

Option de socket pour laquelle la valeur doit être récupérée. Exemple : SO_ACCEPTCONN. La valeur optname doit être une option de socket définie dans le niveau spécifié, sinon le comportement n’est pas défini.

[out] optval

Pointeur vers la mémoire tampon dans laquelle la valeur de l’option demandée doit être retournée.

[in, out] optlen

Pointeur vers la taille, en octets, de la mémoire tampon optval .

Valeur retournée

Si aucune erreur ne se produit, getsockopt retourne zéro. Sinon, une valeur de SOCKET_ERROR est retournée et un code d’erreur spécifique peut être récupéré en appelant WSAGetLastError.

Code d'erreur	Signification
WSANOTINITIALISED	Un appel WSAStartup réussi doit se produire avant d’utiliser cette fonction.
WSAENETDOWN	Note Le sous-système réseau a échoué.
WSAEFAULT	L’un des paramètres optval ou optlen n’est pas une partie valide de l’espace d’adressage utilisateur, ou le paramètre optlen est trop petit.
WSAEINPROGRESS	Un appel Windows Sockets 1.1 bloquant est en cours ou le fournisseur de services traite toujours une fonction de rappel.
WSAEINVAL	Le paramètre level est inconnu ou non valide.
WSAENOPROTOOPT	L’option est inconnue ou non prise en charge par la famille de protocoles indiquée.
WSAENOTSOCK	Le descripteur n’est pas un socket.

Remarques

La fonction getsockopt récupère la valeur actuelle d’une option de socket associée à un socket de n’importe quel type, dans n’importe quel état, et stocke le résultat dans optval. Les options peuvent exister à plusieurs niveaux de protocole, mais elles sont toujours présentes au niveau de socket le plus élevé. Les options affectent les opérations de socket, telles que le routage des paquets et le transfert de données OOB.

La valeur associée à l’option sélectionnée est retournée dans l’optval de la mémoire tampon. L’entier pointé par optlen doit initialement contenir la taille de cette mémoire tampon ; lors du retour, elle sera définie sur la taille de la valeur retournée. Pour SO_LINGER, il s’agit de la taille d’une structure LINGER . Pour la plupart des autres options, il s’agit de la taille d’un entier.

L’application est responsable de l’allocation de tout espace mémoire pointé directement ou indirectement par l’un des paramètres qu’elle a spécifiés.

Si l’option n’a jamais été définie avec setsockopt, getsockopt retourne la valeur par défaut de l’option.

Les options suivantes sont prises en charge pour getsockopt. La colonne Type identifie le type de données traitées par optval.

Pour plus d’informations sur les options de socket, consultez Options de socket.

Le tableau de valeur suivant pour le paramètre optname est valide lorsque le paramètre level est défini sur SOL_SOCKET.

Valeur	Type	Signification
SO_ACCEPTCONN	BOOL	Le socket est à l'écoute.
SO_BROADCAST	BOOL	Le socket est configuré pour la transmission et la réception des messages de diffusion.
SO_BSP_STATE	CSADDR_INFO	Retourne l’adresse locale, le port local, l’adresse distante, le port distant, le type de socket et le protocole utilisés par un socket.
SO_CONDITIONAL_ACCEPT	BOOL	Retourne l’état actuel du socket, soit à partir d’un appel précédent à setsockopt , soit à la valeur par défaut du système.
SO_CONNECT_TIME	DWORD	Retourne le nombre de secondes pendant lesquelles un socket a été connecté. Cette option de socket est valide uniquement pour les protocoles orientés connexion.
SO_DEBUG	BOOL	Le débogage est activé.
SO_DONTLINGER	BOOL	Si la valeur est TRUE, l’option SO_LINGER est désactivée.
SO_DONTROUTE	BOOL	Le routage est désactivé. Cette définition réussit, mais est ignorée sur les sockets AF_INET ; échoue sur les sockets AF_INET6 avec WSAENOPROTOOPT. Cette option n’est pas prise en charge sur les sockets ATM.
SO_ERROR	int	Récupère l’erreur status et clear.
SO_EXCLUSIVEADDRUSE	BOOL	Empêche tout autre socket de se lier à la même adresse et au même port. Cette option doit être définie avant d’appeler la fonction bind .
SO_GROUP_ID	GROUP	Réservé.
SO_GROUP_PRIORITY	int	Réservé.
SO_KEEPALIVE	BOOL	Des keep-alives sont envoyés. Non pris en charge sur les sockets ATM.
SO_LINGER	Structure LINGER	Retourne les options persistantes actuelles.
SO_MAX_MSG_SIZE	nombre entier non signé	Taille maximale d’un message pour les types de sockets orientés message (par exemple, SOCK_DGRAM). N’a aucune signification pour les sockets orientés flux.
SO_OOBINLINE	BOOL	Les données OOB sont reçues dans le flux de données normal. (Consultez la section Windows Sockets 1.1 Blocage des routines et EINPROGRESS pour une discussion sur cette rubrique.)
SO_PORT_SCALABILITY	BOOL	Permet la scalabilité des ports locaux pour un socket en permettant d’optimiser l’allocation de ports en allouant plusieurs fois des ports génériques pour différentes paires de ports d’adresse locale sur un ordinateur local.
SO_PROTOCOL_INFO	WSAPROTOCOL_INFO	Description des informations de protocole pour le protocole lié à ce socket.
SO_RCVBUF	int	Espace tampon total par socket réservé aux réceptions. Cela n’est pas lié à SO_MAX_MSG_SIZE et ne correspond pas nécessairement à la taille de la fenêtre de réception TCP.
SO_REUSEADDR	BOOL	Le socket peut être lié à une adresse déjà utilisée. Non applicable aux sockets ATM.
SO_SNDBUF	int	Espace tampon total par socket réservé aux envois. Cela n’est pas lié à SO_MAX_MSG_SIZE et ne correspond pas nécessairement à la taille d’une fenêtre d’envoi TCP.
SO_TYPE	int	Type du socket (par exemple, SOCK_STREAM).
PVD_CONFIG	Dépendant du fournisseur de services	Objet de structure de données opaque du fournisseur de services associé aux sockets. Cet objet stocke les informations de configuration actuelles du fournisseur de services. Le format exact de cette structure de données est spécifique au fournisseur de services.

Niveau = IPPROTO_TCP

Consultez TCP_NODELAY dans options de socket IPPROTO_TCP. Consultez également cette rubrique pour obtenir des informations plus complètes et détaillées sur les options de socket pourles IPPROTO_TCP de niveau = .

Le tableau de valeur suivant pour le paramètre optname est valide lorsque le paramètre de niveau est défini sur NSPROTO_IPX.

Note Windows NT prend en charge toutes les options IPX. Windows Me, Windows 98 et Windows 95 prennent uniquement en charge les options suivantes :

IPX_PTYPE

IPX_FILTERPTYPE

IPX_DSTYPE

IPX_RECVHDR

IPX_MAXSIZE

IPX_ADDRESS

Valeur	Type	Signification
IPX_PTYPE	int	Récupère le type de paquet IPX.
IPX_FILTERPTYPE	int	Récupère le type de paquet de filtre de réception
IPX_DSTYPE	int	Obtient la valeur du champ de flux de données dans l’en-tête SPX sur chaque paquet envoyé.
IPX_EXTENDED_ADDRESS	BOOL	Détermine si l’adressage étendu est activé.
IPX_RECVHDR	BOOL	Détermine si l’en-tête de protocole est envoyé sur tous les en-têtes de réception.
IPX_MAXSIZE	int	Obtient la taille maximale des données pouvant être envoyées.
IPX_ADDRESS	structure IPX_ADDRESS_DATA	Obtient des informations sur une carte spécifique à laquelle IPX est lié. La numérotation de l’adaptateur est de base zéro. Le membre adapternum est renseigné au retour.
IPX_GETNETINFO	structure IPX_NETNUM_DATA	Obtient des informations sur un numéro de réseau IPX spécifique. S’il n’est pas disponible dans le cache, utilise RIP pour obtenir des informations.
IPX_GETNETINFO_NORIP	structure IPX_NETNUM_DATA	Obtient des informations sur un numéro de réseau IPX spécifique. S’il n’est pas disponible dans le cache, n’utilise pas RIP pour obtenir des informations et retourne l’erreur.
IPX_SPXGETCONNECTIONSTATUS	structure IPX_SPXCONNSTATUS_DATA	Récupère des informations sur un socket SPX connecté.
IPX_ADDRESS_NOTIFY	structure IPX_ADDRESS_DATA	Récupère status notification lorsque des modifications se produisent sur une carte à laquelle IPX est lié.
IPX_MAX_ADAPTER_NUM	int	Récupère le nombre maximal d’adaptateurs présents, numérotés en base zéro.
IPX_RERIPNETNUMBER	structure IPX_NETNUM_DATA	Comme pour IPX_GETNETINFO, mais force IPX à utiliser LAR pour la résolution, même si les informations réseau se situent dans le cache local.
IPX_IMMEDIATESPXACK	BOOL	Indique aux connexions SPX de ne pas retarder l’envoi d’un ACK. Les applications sans trafic aller-retour doivent définir cette valeur sur TRUE pour augmenter les performances.
TCP_MAXSEG	int	Reçoit la taille maximale du segment TCP. Pris en charge dans les versions Windows 10 et plus récentes.

Le tableau suivant répertorie la valeur de l’optname qui représente les options de socket BSD qui ne sont pas prises en charge par la fonction getsockopt .

Valeur	Type	Signification
SO_RCVLOWAT	int	Reçoit un filigrane faible.
SO_RCVTIMEO	int	Reçoit un délai d’expiration.
SO_SNDLOWAT	int	Envoie un filigrane faible.
SO_SNDTIMEO	int	Envoie un délai d’attente.
TCP_MAXSEG	int	Reçoit la taille maximale du segment TCP. Non pris en charge dans les versions antérieures à Windows 10.

Note Lors de l’utilisation de la fonction recv , si aucune donnée n’arrive pendant la période spécifiée dans SO_RCVTIMEO, la fonction recv se termine. Dans les versions de Windows antérieures à Windows 2000, toutes les données reçues par la suite échouent avec WSAETIMEDOUT. Dans Windows 2000 et versions ultérieures, si aucune donnée n’arrive dans la période spécifiée dans SO_RCVTIMEO, la fonction recv retourne WSAETIMEDOUT et, si des données sont reçues, recv retourne SUCCESS.

L’appel de getockopt avec une option non prise en charge entraîne le retour d’un code d’erreur WSAENOPROTOOPT à partir de WSAGetLastError.

Vous trouverez ci-dessous des informations plus détaillées sur certaines des options de socket pour le paramètre optname pris en charge par la fonction getsockopt .

SO_CONNECT_TIME: Cette option retourne le nombre de secondes qu’un socket a été connecté. Cette option est valide uniquement pour les protocoles orientés connexion.
L’option SO_CONNECT_TIME peut être utilisée avec la fonction getsockopt pour case activée si une connexion a été établie. Cette option peut également être utilisée pendant qu’un appel de fonction ConnectEx est en cours. Si une connexion est établie, l’option SO_CONNECT_TIME peut déterminer la durée pendant laquelle la connexion a été établie. Si le socket n’est pas connecté, le getsockopt retourne SOCKET_ERROR. La vérification d’une connexion comme celle-ci est nécessaire pour voir si des connexions ont été établies depuis un certain temps, sans envoyer de données. Il est recommandé aux applications d’arrêter ces connexions.
SO_DEBUG: Note Les fournisseurs de services Windows Sockets sont encouragés (mais pas obligatoires) à fournir des informations de débogage de sortie si l’option SO_DEBUG est définie par une application. Le mécanisme permettant de générer les informations de débogage et la forme qu’il prend dépassent l’étendue de ce document.
SO_ERROR: L’option SO_ERROR retourne et réinitialise le code d’erreur par socket, qui est différent du code d’erreur basé sur le thread géré à l’aide des appels de fonction WSAGetLastError et WSASetLastError . Un appel réussi à l’aide du socket ne réinitialise pas le code d’erreur basé sur le socket retourné par l’option SO_ERROR.
SO_EXCLUSIVEADDRUSE: Empêche tout autre socket de se lier à la même adresse et au même port. Cette option doit être définie avant d’appeler la fonction de liaison . Pour plus d’informations, consultez la référence SO_EXCLUSIVEADDRUSE .
SO_GROUP_ID: Note Cette option est réservée. Cette option est également exclusive à getsockopt ; la valeur doit être NULL.
SO_GROUP_PRIORITY: Cette option est réservée. La priorité du groupe indique la priorité du socket spécifié par rapport aux autres sockets au sein du groupe de sockets. Les valeurs sont des entiers non négatifs, avec zéro correspondant à la priorité la plus élevée. Les valeurs de priorité représentent un indicateur pour le fournisseur de services sous-jacent sur la façon dont les ressources potentiellement rares doivent être allouées. Par exemple, chaque fois que deux sockets ou plus sont tous deux prêts à transmettre des données, le socket de priorité la plus élevée (valeur la plus faible pour SO_GROUP_PRIORITY) doit être en premier, le reste étant à son tour service en fonction de leurs priorités relatives.
Le code d’erreur WSAENOPROTOOPT est indiqué pour les sockets non-groupe ou pour les fournisseurs de services qui ne prennent pas en charge les sockets de groupe.
SO_KEEPALIVE: Une application peut demander à un fournisseur de services TCP/IP d’activer l’utilisation de paquets keep-alive sur les connexions TCP en activant l’option de socket SO_KEEPALIVE. Cette option interroge la valeur actuelle de l’option keep-alive sur un socket. Un fournisseur de sockets Windows n’a pas besoin de prendre en charge l’utilisation de keep-alive : si c’est le cas, la sémantique précise est spécifique à l’implémentation, mais doit être conforme à la section 4.2.3.6 relative à la configuration requise pour les hôtes Internet — Couches de communication spécifiées dans la RFC 1122 disponible sur le site web de l’IETF. Si une connexion est supprimée à la suite de maintiens en vie, le code d’erreur WSAENETRESET est retourné à tous les appels en cours sur le socket, et tous les appels suivants échouent avec WSAENOTCONN. SO_KEEPALIVE n’est pas pris en charge sur les sockets ATM, et les demandes d’activation de paquets keep-alive sur un socket ATM entraînent le retour d’une erreur par le socket.
SO_LINGER: SO_LINGER contrôle l’action effectuée lorsque les données non en attente sont mises en file d’attente sur un socket et qu’un closesocket est effectué. Consultez closesocket pour obtenir une description de la façon dont les paramètres SO_LINGER affectent la sémantique de closesocket. L’application obtient le comportement actuel en récupérant une structure LINGER (pointée par le paramètre optval ).
SO_MAX_MSG_SIZE: Il s’agit d’une option de socket get-only qui indique la taille sortante (envoi) maximale d’un message pour les types de sockets orientés message (par exemple, SOCK_DGRAM) implémentés par un fournisseur de services particulier. Il n’a aucune signification pour les sockets orientés flux d’octets. Il n’existe aucune disposition permettant de déterminer la taille maximale des messages entrants.
SO_PROTOCOL_INFO: Il s’agit d’une option get-only qui fournit la structure WSAPROTOCOL_INFO associée à ce socket. Pour plus d’informations sur cette structure, consultez WSAEnumProtocols .
SO_SNDBUF: Lorsqu’une implémentation windows Sockets prend en charge les options SO_RCVBUF et SO_SNDBUF, une application peut demander différentes tailles de mémoire tampon (plus ou moins grande). L’appel à setsockopt peut réussir même si l’implémentation n’a pas fourni la totalité du montant demandé. Une application doit appeler cette fonction avec la même option pour case activée la taille de mémoire tampon réellement fournie.
SO_REUSEADDR: Par défaut, un socket ne peut pas être lié (voir liaison) à une adresse locale déjà utilisée. Toutefois, à l’occasion, il peut être nécessaire de réutiliser une adresse de cette façon. Étant donné que chaque connexion est identifiée de manière unique par la combinaison d’adresses locales et distantes, il n’y a aucun problème avec le fait d’avoir deux sockets liés à la même adresse locale tant que les adresses distantes sont différentes. Pour informer le fournisseur Windows Sockets qu’une liaison sur un socket ne doit pas être interdite, car l’adresse souhaitée est déjà utilisée par un autre socket, l’application doit définir l’option de socket SO_REUSEADDR pour le socket avant d’émettre la liaison. Notez que l’option n’est interprétée qu’au moment de la liaison : il est donc inutile (mais inoffensif) de définir l’option sur un socket qui ne doit pas être lié à une adresse existante, et la définition ou la réinitialisation de l’option après la liaison n’a aucun effet sur ce socket ou sur un autre socket. SO_REUSEADDR n’est pas applicable aux sockets ATM, et bien que les demandes de réutilisation et d’adresse ne mettent pas en cause une erreur, elles n’ont aucun effet sur l’utilisation d’un socket ATM.
PVD_CONFIG: Cette option récupère un objet de structure de données opaque à partir du fournisseur de services associé aux sockets. Cet objet stocke les informations de configuration actuelles du fournisseur de services. Le format exact de cette structure de données est spécifique au fournisseur de services.
TCP_NODELAY: L’option TCP_NODELAY est spécifique aux fournisseurs de services TCP/IP. L’algorithme Nagle est désactivé si l’option TCP_NODELAY est activée (et vice versa). L’algorithme Nagle (décrit dans RFC 896) est très efficace pour réduire le nombre de petits paquets envoyés par un hôte. Le processus implique la mise en mémoire tampon des données d’envoi lorsque des données non reconnues sont déjà en cours d’exécution ou la mise en mémoire tampon des données d’envoi jusqu’à ce qu’un paquet de taille réelle puisse être envoyé. Il est vivement recommandé que les implémentations de Sockets Windows activent l’algorithme Nagle par défaut, car, pour la grande majorité des protocoles d’application, l’algorithme Nagle peut apporter des améliorations significatives en matière de performances. Toutefois, pour certaines applications, cet algorithme peut nuire aux performances, et setockopt avec la même option peut être utilisé pour le désactiver. Il s’agit d’applications où de nombreux petits messages sont envoyés et où les délais entre les messages sont conservés.

Note Lors de l’émission d’un appel Winsock bloquant tel que getsockopt, Winsock peut avoir besoin d’attendre qu’un événement réseau se termine. Winsock effectue une attente alertable dans cette situation, qui peut être interrompue par un appel de procédure asynchrone (APC) planifié sur le même thread. L’émission d’un autre appel Winsock bloquant à l’intérieur d’un APC qui a interrompu un appel Winsock bloquant en cours sur le même thread entraîne un comportement non défini et ne doit jamais être tenté par les clients Winsock.

Exemple de code

L’exemple de code suivant illustre l’utilisation de la fonction getsockopt .

#include <stdio.h>
#include "winsock2.h"
#include <windows.h>

void main() {

  //---------------------------------------
  // Declare variables
  WSADATA wsaData;
  SOCKET ListenSocket;
  sockaddr_in service;

  //---------------------------------------
  // Initialize Winsock
  int iResult = WSAStartup( MAKEWORD(2,2), &wsaData );
  if( iResult != NO_ERROR )
    printf("Error at WSAStartup\n");

  //---------------------------------------
  // Create a listening socket
  ListenSocket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
  if (ListenSocket == INVALID_SOCKET) {
    printf("Error at socket()\n");
    WSACleanup();
    return;
  }

  //---------------------------------------
  // Bind the socket to the local IP address
  // and port 27015
  hostent* thisHost;
  char* ip;
  u_short port;
  port = 27015;
  thisHost = gethostbyname("");
  ip = inet_ntoa (*(struct in_addr *)*thisHost->h_addr_list);

  service.sin_family = AF_INET;
  service.sin_addr.s_addr = inet_addr(ip);
  service.sin_port = htons(port);
 
  if ( bind( ListenSocket,(SOCKADDR*) &service, sizeof(service) )  == SOCKET_ERROR ) {
    printf("bind failed\n");
    closesocket(ListenSocket);
    return;
  }

  //---------------------------------------
  // Initialize variables and call getsockopt. 
  // The SO_ACCEPTCONN parameter is a socket option 
  // that tells the function to check whether the 
  // socket has been put in listening mode or not. 
  // The various socket options return different
  // information about the socket. This call should
  // return 0 to the optVal parameter, since the socket
  // is not in listening mode.
  int optVal;
  int optLen = sizeof(int);

  if (getsockopt(ListenSocket, 
    SOL_SOCKET, 
    SO_ACCEPTCONN, 
    (char*)&optVal, 
    &optLen) != SOCKET_ERROR)
    printf("SockOpt Value: %ld\n", optVal);

  //---------------------------------------
  // Put the listening socket in listening mode.
  if (listen( ListenSocket, 100 ) == SOCKET_ERROR) {
    printf("error listening\n");
  } 

  //---------------------------------------
  // Call getsockopt again to verify that 
  // the socket is in listening mode.
  if (getsockopt(ListenSocket, 
    SOL_SOCKET, 
    SO_ACCEPTCONN, 
    (char*)&optVal, 
    &optLen) != SOCKET_ERROR)
    printf("SockOpt Value: %ld\n", optVal);

  WSACleanup();
  return;
}

Remarques pour les sockets IrDA

Le fichier d’en-tête Af_irda.h doit être inclus explicitement.
Windows retourne WSAENETDOWN pour indiquer que le pilote d’émetteur-récepteur sous-jacent n’a pas pu s’initialiser avec la pile de protocoles IrDA.
IrDA prend en charge plusieurs options de socket spéciales :

Valeur Type Signification

IRLMP_ENUMDEVICES *DEVICELIST Décrit les appareils dans la plage.

IRLMP_IAS_QUERY *IAS_QUERY Récupérer les attributs IAS.

Valeur	Type	Signification
IRLMP_ENUMDEVICES	*DEVICELIST	Décrit les appareils dans la plage.
IRLMP_IAS_QUERY	*IAS_QUERY	Récupérer les attributs IAS.

Avant qu’une connexion de socket IrDA puisse être lancée, une adresse d’appareil doit être obtenue en effectuant un appel de fonction getsockopt(,,IRLMP_ENUMDEVICES,,,), qui retourne une liste de tous les appareils IrDA disponibles. Une adresse d’appareil retournée à partir de l’appel de fonction est copiée dans une structure de SOCKADDR_IRDA , qui à son tour est utilisée par un appel suivant à l’appel de fonction de connexion .

La découverte peut être effectuée de deux manières :

Tout d’abord, l’exécution d’un appel de fonction getsockopt avec l’option IRLMP_ENUMDEVICES entraîne l’exécution d’une découverte unique sur chaque adaptateur inactif. La liste des appareils découverts et mis en cache (sur les cartes actives) est retournée immédiatement.

Le code suivant illustre cette approche.

#include <winsock2.h>
#include <ws2tcpip.h>
#include <af_irda.h>
#include <stdio.h>
#include <windows.h>

// link with Ws2_32.lib

int __cdecl main()
{

    //-----------------------------------------
    // Declare and initialize variables
    WSADATA wsaData;

    int iResult;
    int i;
    DWORD dwError;

    SOCKET Sock = INVALID_SOCKET;

#define DEVICE_LIST_LEN    10


    SOCKADDR_IRDA DestSockAddr = { AF_IRDA, 0, 0, 0, 0, "SampleIrDAService" };

    unsigned char DevListBuff[sizeof (DEVICELIST) -
                              sizeof (IRDA_DEVICE_INFO) +
                              (sizeof (IRDA_DEVICE_INFO) * DEVICE_LIST_LEN)];

    int DevListLen = sizeof (DevListBuff);
    PDEVICELIST pDevList;

    pDevList = (PDEVICELIST) & DevListBuff;

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
    }

    Sock = socket(AF_IRDA, SOCK_STREAM, 0);
    if (Sock == INVALID_SOCKET) {
        dwError = WSAGetLastError();
        printf
            ("socket failed trying to create an AF_IRDA socket with error %d\n",
             dwError);

        if (dwError == WSAEAFNOSUPPORT) {
            printf("Check that the local computer has an infrared device\n");
            printf
                ("and a device driver is installed for the infrared device\n");
        }
        WSACleanup();
        return 1;
    }
    // Sock is not in connected state
    iResult = getsockopt(Sock, SOL_IRLMP, IRLMP_ENUMDEVICES,
                         (char *) pDevList, &DevListLen);
    if (iResult == SOCKET_ERROR) {
        printf("getsockopt failed with error %d\n", WSAGetLastError());
        WSACleanup();
        return 1;
    }

    if (pDevList->numDevice == 0) {
        // no devices discovered or cached
        // not a bad idea to run a couple of times
        printf("No IRDA devices were discovered or cached\n");
    } else {
        // one per discovered device
        for (i = 0; i < (int) pDevList->numDevice; i++) {
            // typedef struct _IRDA_DEVICE_INFO
            // {
            //     u_char    irdaDeviceID[4];
            //     char      irdaDeviceName[22];
            //     u_char    irdaDeviceHints1;
            //     u_char    irdaDeviceHints2;
            //     u_char    irdaCharSet;
            // } _IRDA_DEVICE_INFO;

            // pDevList->Device[i]. see _IRDA_DEVICE_INFO for fields
            // display the device names and let the user select one
        }
    }

    // assume the user selected the first device [0]
    memcpy(&DestSockAddr.irdaDeviceID[0], &pDevList->Device[0].irdaDeviceID[0],
           4);

    iResult = connect(Sock, (const struct sockaddr *) &DestSockAddr,
                      sizeof (SOCKADDR_IRDA));
    if (iResult == SOCKET_ERROR) {
        printf("connect failed with error %d\n", WSAGetLastError());
    } else
        printf("connect to first IRDA device was successful\n");

    WSACleanup();
    return 0;
}

La deuxième approche pour effectuer la découverte d’adresses d’appareil IrDA consiste à effectuer une découverte paresseuse ; dans cette approche, l’application n’est pas avertie tant que la liste des appareils découverts n’a pas changé par rapport à la dernière découverte exécutée par la pile.

La structure DEVICELIST indiquée dans la colonne Type du tableau précédent est un tableau extensible de descriptions d’appareils. IrDA remplit autant de descriptions d’appareil que possible dans la mémoire tampon spécifiée. La description de l’appareil se compose d’un identificateur d’appareil nécessaire pour former une structure sockaddr_irda et d’une chaîne pouvant être affichée décrivant l’appareil.

La structure IAS_QUERY indiquée dans la colonne Type de la table précédente est utilisée pour récupérer un attribut unique d’une classe unique à partir de la base de données IAS d’un appareil homologue. L’application spécifie l’appareil et la classe à interroger, ainsi que l’attribut et le type d’attribut. Notez que l’appareil aurait été obtenu précédemment par un appel à getsockopt(IRLMP_ENUMDEVICES). Il est attendu que l’application alloue une mémoire tampon, de la taille nécessaire, pour les paramètres retournés.

De nombreuses options de socket de niveau ne sont pas significatives pour IrDA ; seuls les SO_LINGER et les SO_DONTLINGER sont spécifiquement pris en charge.

Windows Phone 8 : cette fonction est prise en charge pour les applications du Store Windows Phone Windows Phone 8 et versions ultérieures.

Windows 8.1 et Windows Server 2012 R2 : cette fonction est prise en charge pour les applications du Windows Store sur Windows 8.1, Windows Server 2012 R2 et versions ultérieures.

Configuration requise

Condition requise	Valeur
Client minimal pris en charge	Windows 8.1, Windows Vista [applications de bureau \| Applications UWP]
Serveur minimal pris en charge	Windows Server 2003 [applications de bureau \| applications UWP]
Plateforme cible	Windows
En-tête	winsock.h (inclure Winsock2.h)
Bibliothèque	Ws2_32.lib
DLL	Ws2_32.dll