Funzione getsockopt (winsock.h)

Articolo
03/15/2023

La funzione getsockopt recupera un'opzione socket.

Sintassi

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

Parametri

[in] s

Descrittore che identifica un socket.

[in] level

Livello a cui viene definita l'opzione. Esempio: SOL_SOCKET.

[in] optname

Opzione socket per cui il valore deve essere recuperato. Esempio: SO_ACCEPTCONN. Il valore optname deve essere un'opzione socket definita all'interno del livello specificato o il comportamento non definito.

[out] optval

Puntatore al buffer in cui verrà restituito il valore dell'opzione richiesta.

[in, out] optlen

Puntatore alle dimensioni, in byte, del buffer optval .

Valore restituito

Se non si verifica alcun errore, getsockopt restituisce zero. In caso contrario, viene restituito un valore di SOCKET_ERROR e un codice di errore specifico può essere recuperato chiamando WSAGetLastError.

Codice di errore	Significato
WSANOTINITIALISED	Prima di usare questa funzione, è necessario eseguire una chiamata WSAStartup riuscita.
WSAENETDOWN	Nota Il sottosistema di rete non è riuscito.
WSAEFAULT	Uno dei parametri optval o optlen non è una parte valida dello spazio degli indirizzi utente o il parametro optlen è troppo piccolo.
WSAEINPROGRESS	Una chiamata windows Sockets 1.1 bloccata è in corso oppure il provider di servizi sta ancora elaborando una funzione di callback.
WSAEINVAL	Il parametro di livello è sconosciuto o non valido.
WSAENOPROTOOPT	L'opzione è sconosciuta o non supportata dalla famiglia di protocolli indicata.
WSAENOTSOCK	Il descrittore non è un socket.

Commenti

La funzione getsockopt recupera il valore corrente per un'opzione socket associata a un socket di qualsiasi tipo, in qualsiasi stato e archivia il risultato di optval. Le opzioni possono esistere a più livelli di protocollo, ma sono sempre presenti a livello di socket superiore. Le opzioni influiscono sulle operazioni socket, ad esempio il routing dei pacchetti e il trasferimento dei dati OOB.

Il valore associato all'opzione selezionata viene restituito nel buffer optval. L'intero a cui punta optlen deve contenere originariamente le dimensioni di questo buffer; in caso di restituzione, verrà impostato sulle dimensioni del valore restituito. Per SO_LINGER, questa sarà la dimensione di una struttura LINGER . Per la maggior parte delle altre opzioni, sarà la dimensione di un intero.

L'applicazione è responsabile dell'allocazione di qualsiasi spazio di memoria puntato direttamente o indirettamente da uno dei parametri specificati.

Se l'opzione non è mai stata impostata con setockopt, viene restituito il valore predefinito per l'opzione.

Le opzioni seguenti sono supportate per getsockopt. La colonna Type identifica il tipo di dati indirizzato da optval.

Per altre informazioni sulle opzioni socket, vedere Opzioni socket.

La tabella seguente del valore per il parametro optname è valida quando il parametro di livello è impostato su SOL_SOCKET.

Valore	Type	Significato
SO_ACCEPTCONN	BOOL	Il socket è in ascolto.
SO_BROADCAST	BOOL	Il socket è configurato per la trasmissione e la ricezione di messaggi di trasmissione.
SO_BSP_STATE	CSADDR_INFO	Restituisce l'indirizzo locale, la porta locale, l'indirizzo remoto, la porta remota, il tipo di socket e il protocollo usati da un socket.
SO_CONDITIONAL_ACCEPT	BOOL	Restituisce lo stato del socket corrente, da una chiamata precedente a setockopt o impostazione predefinita del sistema.
SO_CONNECT_TIME	DWORD	Restituisce il numero di secondi in cui è stato connesso un socket. Questa opzione socket è valida solo per i protocolli orientati alla connessione.
SO_DEBUG	BOOL	Il debug è abilitato.
SO_DONTLINGER	BOOL	Se TRUE, l'opzione SO_LINGER è disabilitata.
SO_DONTROUTE	BOOL	Il routing è disabilitato. L'impostazione di questa operazione ha esito positivo ma viene ignorata nei socket AF_INET; ha esito negativo sui socket AF_INET6 con WSAENOPROTOOPT. Questa opzione non è supportata nei socket ATM.
SO_ERROR	INT	Recupera lo stato degli errori e cancella.
SO_EXCLUSIVEADDRUSE	BOOL	Impedisce a qualsiasi altro socket di associarsi allo stesso indirizzo e alla stessa porta. Questa opzione deve essere impostata prima di chiamare la funzione di associazione .
SO_GROUP_ID	GROUP	Riservato.
SO_GROUP_PRIORITY	INT	Riservato.
SO_KEEPALIVE	BOOL	I keep-alive vengono inviati. Non supportato nei socket ATM.
SO_LINGER	Struttura LINGER	Restituisce le opzioni di ritardo correnti.
SO_MAX_MSG_SIZE	int senza segno	Dimensioni massime di un messaggio per i tipi socket orientati ai messaggi, ad esempio SOCK_DGRAM. Non ha alcun significato per i socket orientati al flusso.
SO_OOBINLINE	BOOL	I dati OOB sono ricevuti nel normale flusso di dati. Per una descrizione di questo argomento, vedere la sezione Routine di blocco di Windows Sockets 1.1 e EINPROGRESS .
SO_PORT_SCALABILITY	BOOL	Abilita la scalabilità delle porte locali per un socket consentendo l'allocazione delle porte ingrandita allocando più volte porte con caratteri jolly per coppie di porte di indirizzi locali diverse in un computer locale.
SO_PROTOCOL_INFO	WSAPROTOCOL_INFO	Descrizione delle informazioni sul protocollo per il protocollo associato a questo socket.
SO_RCVBUF	INT	Spazio totale del buffer per socket riservato per le ricevute. Non è correlato a SO_MAX_MSG_SIZE e non corrisponde necessariamente alle dimensioni della finestra di ricezione TCP.
SO_REUSEADDR	BOOL	Il socket può essere associato a un indirizzo già in uso. Non applicabile per i socket ATM.
SO_SNDBUF	INT	Spazio totale del buffer per socket riservato per gli invii. Non è correlato a SO_MAX_MSG_SIZE e non corrisponde necessariamente alle dimensioni di una finestra di invio TCP.
SO_TYPE	INT	Tipo del socket (ad esempio, SOCK_STREAM).
PVD_CONFIG	Dipendente dal provider di servizi	Oggetto struttura di dati opaca del provider di servizi associato a socket s. Questo oggetto archivia le informazioni di configurazione correnti del provider di servizi. Il formato esatto di questa struttura di dati è specifico del provider di servizi.

Livello = IPPROTO_TCP

Vedere TCP_NODELAY nelle opzioni socket di IPPROTO_TCP. Vedere anche questo argomento per informazioni più complete e dettagliate sulle opzioni socket per il livello = IPPROTO_TCP.

La tabella seguente di valore per il parametro optname è valida quando il parametro level è impostato su NSPROTO_IPX.

Nota Windows NT supporta tutte le opzioni IPX. Windows Me, Windows 98 e Windows 95 supportano solo le opzioni seguenti:

IPX_PTYPE

IPX_FILTERPTYPE

IPX_DSTYPE

IPX_RECVHDR

IPX_MAXSIZE

IPX_ADDRESS

Valore	Type	Significato
IPX_PTYPE	INT	Recupera il tipo di pacchetto IPX.
IPX_FILTERPTYPE	INT	Recupera il tipo di pacchetto di filtro di ricezione
IPX_DSTYPE	INT	Ottiene il valore del campo flusso di dati nell'intestazione SPX in ogni pacchetto inviato.
IPX_EXTENDED_ADDRESS	BOOL	Verifica se l'indirizzamento esteso è abilitato.
IPX_RECVHDR	BOOL	Verifica se l'intestazione del protocollo viene inviata su tutte le intestazioni di ricezione.
IPX_MAXSIZE	INT	Ottiene la dimensione massima dei dati che è possibile inviare.
IPX_ADDRESS	struttura IPX_ADDRESS_DATA	Ottiene informazioni su una scheda specifica a cui è associato IPX. La numerazione dell'adattatore è di base zero. Il membro adapternum viene compilato al momento della restituzione .
IPX_GETNETINFO	struttura IPX_NETNUM_DATA	Ottiene informazioni su un numero di rete IPX specifico. Se non è disponibile nella cache, usa RIP per ottenere informazioni.
IPX_GETNETINFO_NORIP	struttura IPX_NETNUM_DATA	Ottiene informazioni su un numero di rete IPX specifico. Se non è disponibile nella cache, non userà RIP per ottenere informazioni e restituisce l'errore.
IPX_SPXGETCONNECTIONSTATUS	struttura IPX_SPXCONNSTATUS_DATA	Recupera informazioni su un socket SPX connesso.
IPX_ADDRESS_NOTIFY	struttura IPX_ADDRESS_DATA	Recupera la notifica di stato quando si verificano modifiche in una scheda a cui è associato IPX.
IPX_MAX_ADAPTER_NUM	INT	Recupera il numero massimo di adattatori presenti, numerati come base zero.
IPX_RERIPNETNUMBER	struttura IPX_NETNUM_DATA	Analogamente a IPX_GETNETINFO, ma impone a IPX di usare RIP per la risoluzione, anche se le informazioni di rete si trovano nella cache locale.
IPX_IMMEDIATESPXACK	BOOL	Indirizza le connessioni SPX a non ritardare prima di inviare un ACK. Le applicazioni senza traffico back-and-forth devono impostare su TRUE per migliorare le prestazioni.
TCP_MAXSEG	INT	Riceve le dimensioni massime del segmento TCP. Supportato in Windows 10 e versioni più recenti.

La tabella seguente elenca il valore per optname che rappresentano le opzioni del socket BSD non supportate dalla funzione getsockopt .

Valore	Type	Significato
SO_RCVLOWAT	INT	Riceve una filigrana bassa.
SO_RCVTIMEO	INT	Riceve il timeout.
SO_SNDLOWAT	INT	Invia una filigrana bassa.
SO_SNDTIMEO	INT	Invia il timeout.
TCP_MAXSEG	INT	Riceve le dimensioni massime del segmento TCP. Non supportato nelle versioni precedenti alla Windows 10.

Nota Quando si usa la funzione recv , se non arrivano dati durante il periodo specificato in SO_RCVTIMEO, la funzione recv viene completata. Nelle versioni di Windows precedenti a Windows 2000, tutti i dati ricevuti successivamente hanno esito negativo con WSAETIMEDOUT. In Windows 2000 e versioni successive, se non arrivano dati entro il periodo specificato in SO_RCVTIMEO, la funzione recv restituisce WSAETIMEDOUT e, se i dati vengono ricevuti, restituisce SUCCESS.

La chiamata a getsockopt con un'opzione non supportata genera un codice di errore di WSAENOPROTOOPT restituito da WSAGetLastError.

Informazioni più dettagliate su alcune delle opzioni del socket per il parametro optname supportato dalla funzione getsockopt sono elencate di seguito.

SO_CONNECT_TIME: Questa opzione restituisce il numero di secondi in cui è stato connesso un socket. Questa opzione è valida solo per i protocolli orientati alla connessione.
L'opzione SO_CONNECT_TIME può essere usata con la funzione getsockopt per verificare se è stata stabilita una connessione. Questa opzione può essere usata anche mentre è in corso una chiamata di funzione ConnectEx . Se viene stabilita una connessione, l'opzione SO_CONNECT_TIME può determinare la durata della connessione. Se il socket non è connesso, il getsockopt restituisce SOCKET_ERROR. La verifica di una connessione simile a questa è necessaria per verificare se le connessioni stabilite per un po' di tempo, senza inviare dati. È consigliabile che le applicazioni terminano queste connessioni.
SO_DEBUG: Nota I provider di servizi Windows Sockets sono invitati (ma non necessari) a fornire informazioni di debug di output se l'opzione SO_DEBUG è impostata da un'applicazione. Il meccanismo per generare le informazioni di debug e il modulo che accetta sono oltre l'ambito di questo documento.
SO_ERROR: L'opzione SO_ERROR restituisce e reimposta il codice di errore basato su socket, diverso dal codice di errore basato su thread gestito usando le chiamate di funzione WSAGetLastError e WSASetLastError . Una chiamata con esito positivo usando il socket non reimposta il codice di errore basato su socket restituito dall'opzione SO_ERROR.
SO_EXCLUSIVEADDRUSE: Impedisce a qualsiasi altro socket di associarsi allo stesso indirizzo e alla stessa porta. Questa opzione deve essere impostata prima di chiamare la funzione di associazione . Per altre informazioni, vedere il riferimento SO_EXCLUSIVEADDRUSE .
SO_GROUP_ID: Nota Questa opzione è riservata. Questa opzione è esclusiva anche per getsockopt; il valore deve essere NULL.
SO_GROUP_PRIORITY: Questa opzione è riservata. La priorità del gruppo indica la priorità del socket specificato rispetto ad altri socket all'interno del gruppo socket. I valori sono interi nonnegative, con zero corrispondente alla priorità più alta. I valori di priorità rappresentano un hint per il provider di servizi sottostanti su come devono essere allocate risorse potenzialmente scarse. Ad esempio, ogni volta che due o più socket sono entrambi pronti per trasmettere i dati, il socket con priorità più alta (valore più basso per SO_GROUP_PRIORITY) deve essere usato per primo, con il resto servizio a sua volta in base alle loro priorità relative.
Il codice di errore WSAENOPROTOOPT è indicato per i socket nongroup o per i provider di servizi che non supportano i socket di gruppo.
SO_KEEPALIVE: Un'applicazione può richiedere che un provider di servizi TCP/IP consenta l'uso di pacchetti keep-alive sulle connessioni TCP attivando l'opzione SO_KEEPALIVE socket. Questa opzione esegue una query sul valore corrente dell'opzione keep-alive in un socket. Un provider Windows Sockets non deve supportare l'uso di keep-alive: se lo fa, la semantica precisa è specifica dell'implementazione, ma deve essere conforme alla sezione 4.2.3.6 sui requisiti per gli host Internet- Livelli di comunicazione specificati in RFC 1122 disponibile nel sito Web IETF. Se una connessione viene eliminata come risultato di keep-alives il codice di errore WSAENETRESET viene restituito a qualsiasi chiamata in corso nel socket e le chiamate successive avranno esito negativo con WSAENOTCONN. SO_KEEPALIVE non è supportato nei socket ATM e le richieste per abilitare l'uso di pacchetti keep-alive in un socket ATM genera un errore restituito dal socket.
SO_LINGER: SO_LINGER controlla l'azione eseguita quando i dati non inviati vengono accodati su un socket e viene eseguito un closesocket . Vedere closesocket per una descrizione del modo in cui le impostazioni SO_LINGER influiscono sulla semantica di closesocket. L'applicazione ottiene il comportamento corrente recuperando una struttura LINGER (a cui fa riferimento il parametro optval ).
SO_MAX_MSG_SIZE: Si tratta di un'opzione socket get-only che indica la dimensione massima in uscita (invio) di un messaggio per i tipi di socket orientati ai messaggi (ad esempio, SOCK_DGRAM) come implementato da un determinato provider di servizi. Non ha alcun significato per i socket orientati al flusso di byte. Non è disponibile alcun provisioning per individuare le dimensioni massime dei messaggi in ingresso.
SO_PROTOCOL_INFO: Questa è un'opzione get-only che fornisce la struttura di WSAPROTOCOL_INFO associata a questo socket. Per altre informazioni su questa struttura, vedere WSAEnumProtocols .
SO_SNDBUF: Quando un'implementazione di Windows Sockets supporta le opzioni di SO_RCVBUF e SO_SNDBUF, un'applicazione può richiedere dimensioni del buffer diverse (maggiore o minore). La chiamata a setockopt può avere esito positivo anche se l'implementazione non ha fornito l'intero importo richiesto. Un'applicazione deve chiamare questa funzione con la stessa opzione per controllare le dimensioni del buffer effettivamente fornite.
SO_REUSEADDR: Per impostazione predefinita, un socket non può essere associato (vedere binding) a un indirizzo locale già in uso. In occasione, tuttavia, può essere necessario riutilizzare un indirizzo in questo modo. Poiché ogni connessione viene identificata in modo univoco dalla combinazione di indirizzi locali e remoti, non esiste alcun problema con due socket associati allo stesso indirizzo locale purché gli indirizzi remoti siano diversi. Per informare il provider Windows Sockets che un binding su un socket non deve essere consentito perché l'indirizzo desiderato è già in uso da un altro socket, l'applicazione deve impostare l'opzione di socket SO_REUSEADDR per il socket prima di emettere l'associazione. Si noti che l'opzione viene interpretata solo al momento dell'associazione : pertanto non è necessario (ma innocuo) impostare l'opzione su un socket che non deve essere associato a un indirizzo esistente e impostare o reimpostare l'opzione dopo che l'associazione non ha alcun effetto su questo o su qualsiasi altro socket. SO_REUSEADDR non è applicabile per i socket ATM e anche se le richieste di riutilizzo e indirizzo non generano un errore, non hanno alcun effetto su quando un socket ATM è in uso.
PVD_CONFIG: Questa opzione recupera un oggetto struttura dati opaco dal provider di servizi associato a socket s. Questo oggetto archivia le informazioni di configurazione correnti del provider di servizi. Il formato esatto di questa struttura di dati è specifico del provider di servizi.
TCP_NODELAY: L'opzione TCP_NODELAY è specifica per i provider di servizi TCP/IP. L'algoritmo Nagle è disabilitato se l'opzione TCP_NODELAY è abilitata (e viceversa). L'algoritmo Nagle (descritto in RFC 896) è molto efficace per ridurre il numero di piccoli pacchetti inviati da un host. Il processo comporta l'invio di dati di buffering quando non sono presenti dati non riconosciuti già in anteprima o in buffering di inviare dati fino a quando non è possibile inviare un pacchetto di dimensioni complete. È consigliabile che le implementazioni di Windows Sockets consentano per impostazione predefinita l'algoritmo Nagle perché, per la maggior parte dei protocolli dell'applicazione, l'algoritmo Nagle può offrire miglioramenti significativi delle prestazioni. Tuttavia, per alcune applicazioni questo algoritmo può impedire le prestazioni e setockopt con la stessa opzione può essere usata per disattivarla. Queste sono applicazioni in cui vengono inviati molti messaggi di piccole dimensioni e i ritardi di tempo tra i messaggi vengono mantenuti.

Nota Quando si emette una chiamata Winsock bloccante, ad esempio getsockopt, Winsock potrebbe dover attendere un evento di rete prima che la chiamata possa completare. Winsock esegue un'attesa avvisabile in questa situazione, che può essere interrotta da una chiamata di routine asincrona pianificata nello stesso thread. L'emissione di un'altra chiamata winsock bloccata all'interno di un APC che ha interrotto una chiamata winsock in corso sullo stesso thread comporterà un comportamento non definito e non deve mai essere tentato dai client Winsock.

Codice di esempio

Nell'esempio di codice seguente viene illustrato l'uso della funzione 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;
}

Note per i socket IrDA

Il file di intestazione Af_irda.h deve essere incluso in modo esplicito.
Windows restituisce WSAENETDOWN per indicare che il driver transceiver sottostante non è riuscito a inizializzare con lo stack di protocolli IrDA.
IrDA supporta diverse opzioni di socket speciali:

Valore Type Significato

IRLMP_ENUMDEVICES *DEVICELIST Descrive i dispositivi nell'intervallo.

IRLMP_IAS_QUERY *IAS_QUERY Recuperare gli attributi IAS.

Valore	Type	Significato
IRLMP_ENUMDEVICES	*DEVICELIST	Descrive i dispositivi nell'intervallo.
IRLMP_IAS_QUERY	*IAS_QUERY	Recuperare gli attributi IAS.

Prima di avviare una connessione socket IrDA, è necessario ottenere un indirizzo del dispositivo eseguendo una chiamata di funzione getsockopt(,IRLMP_ENUMDEVICES,) che restituisce un elenco di tutti i dispositivi IrDA disponibili. Un indirizzo del dispositivo restituito dalla chiamata alla funzione viene copiato in una struttura SOCKADDR_IRDA , che a sua volta viene utilizzata da una chiamata successiva alla chiamata alla funzione di connessione .

L'individuazione può essere eseguita in due modi:

Prima di tutto, l'esecuzione di una chiamata di funzione getsockopt con l'opzione IRLMP_ENUMDEVICES causa l'esecuzione di un'individuazione singola in ogni scheda inattiva. L'elenco dei dispositivi individuati e dei dispositivi memorizzati nella cache (nelle schede attive) viene restituito immediatamente.

Il codice seguente illustra questo approccio.

#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;
}

Il secondo approccio all'esecuzione dell'individuazione degli indirizzi del dispositivo IrDA consiste nell'eseguire un'individuazione lazy; in questo approccio l'applicazione non viene notificata fino a quando l'elenco dei dispositivi individuati cambia dall'ultima esecuzione dell'individuazione dallo stack.

La struttura DEVICELIST illustrata nella colonna Type nella tabella precedente è una matrice estendibile di descrizioni dei dispositivi. IrDA riempie tutte le descrizioni dei dispositivi che possono essere inserite nel buffer specificato. La descrizione del dispositivo è costituita da un identificatore di dispositivo necessario per formare una struttura sockaddr_irda e una stringa visualizzabile che descrive il dispositivo.

La struttura IAS_QUERY illustrata nella colonna Type della tabella precedente viene usata per recuperare un singolo attributo di una singola classe dal database IAS di un dispositivo peer. L'applicazione specifica il dispositivo e la classe per eseguire query e il tipo di attributo e attributo. Si noti che il dispositivo sarebbe stato ottenuto in precedenza da una chiamata a getsockopt(IRLMP_ENUMDEVICES). Si prevede che l'applicazione alloca un buffer, delle dimensioni necessarie, per i parametri restituiti.

Molte opzioni del socket a livello non sono significative per IrDA; sono supportati solo SO_LINGER e SO_DONTLINGER.

Windows Phone 8: questa funzione è supportata per le app Windows Phone Store in Windows Phone 8 e versioni successive.

Windows 8.1 e Windows Server 2012 R2: questa funzione è supportata per le app di Windows Store in Windows 8.1, Windows Server 2012 R2 e versioni successive.

Requisiti

Requisito	Valore
Client minimo supportato	Windows 8.1, Windows Vista [app desktop \| App UWP]
Server minimo supportato	Windows Server 2003 [app desktop \| App UWP]
Piattaforma di destinazione	Windows
Intestazione	winsock.h (include Winsock2.h)
Libreria	Ws2_32.lib
DLL	Ws2_32.dll