getsockopt-Funktion (winsock.h)

Die getockopt-Funktion ruft eine Socketoption ab.

Syntax

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

Parameter

[in] s

Ein Deskriptor, der einen Socket identifiziert.

[in] level

Die Ebene, auf der die Option definiert ist. Beispiel: SOL_SOCKET.

[in] optname

Die Socketoption, für die der Wert abgerufen werden soll. Beispiel: SO_ACCEPTCONN. Der Optname-Wert muss eine Socketoption sein, die innerhalb der angegebenen Ebene definiert ist, oder das Verhalten ist nicht definiert.

[out] optval

Ein Zeiger auf den Puffer, in dem der Wert für die angeforderte Option zurückgegeben werden soll.

[in, out] optlen

Ein Zeiger auf die Größe des Optval-Puffers in Bytes.

Rückgabewert

Wenn kein Fehler auftritt, gibt getsockopt null zurück. Andernfalls wird der Wert SOCKET_ERROR zurückgegeben, und ein bestimmter Fehlercode kann durch Aufrufen von WSAGetLastError abgerufen werden.

Hinweise

Die getockopt-Funktion ruft den aktuellen Wert für eine Socketoption ab, die einem Socket eines beliebigen Typs in einem beliebigen Zustand zugeordnet ist, und speichert das Ergebnis in optval. Optionen können auf mehreren Protokollebenen vorhanden sein, sind aber immer auf der obersten Socketebene vorhanden. Optionen wirken sich auf Socketvorgänge aus, z. B. das Paketrouting und die OOB-Datenübertragung.

Der der ausgewählten Option zugeordnete Wert wird im Puffer optval zurückgegeben. Die ganze Zahl, auf die von optlen verwiesen wird, sollte ursprünglich die Größe dieses Puffers enthalten. bei der Rückgabe wird die Größe des zurückgegebenen Werts festgelegt. Für SO_LINGER ist dies die Größe einer LINGER-Struktur . Bei den meisten anderen Optionen entspricht dies der Größe einer ganzzahligen Zahl.

Die Anwendung ist für die Zuweisung von Speicherplatz verantwortlich, auf den direkt oder indirekt durch einen der angegebenen Parameter verwiesen wird.

Wenn die Option nie mit setsockopt festgelegt wurde, gibt getsockopt den Standardwert für die Option zurück.

Die folgenden Optionen werden für getsockopt unterstützt. Die Spalte Typ gibt den Typ der von optval adressierten Daten an.

Weitere Informationen zu Socketoptionen finden Sie unter Socketoptionen.

Die folgende Werttabelle für den optname-Parameter ist gültig, wenn der Levelparameter auf SOL_SOCKET festgelegt ist.

Ebene = IPPROTO_TCP

Weitere Informationen finden Sie unter TCP_NODELAY in IPPROTO_TCP Socketoptionen. Ausführlichere und ausführlichere Informationen zu Socketoptionen für IPPROTO_TCP = finden Sie auch indiesem Thema.  

Die folgende Werttabelle für den optname-Parameter ist gültig, wenn der Levelparameter auf NSPROTO_IPX festgelegt ist.

In der folgenden Tabelle ist der Wert für den Optname aufgeführt, der BSD-Socketoptionen darstellt, die von der getockopt-Funktion nicht unterstützt werden.

Das Aufrufen von getsockopt mit einer nicht unterstützten Option führt dazu, dass ein Fehlercode von WSAENOPROTOOPT von WSAGetLastError zurückgegeben wird.

Ausführlichere Informationen zu einigen Socketoptionen für den optname-Parameter , der von der getockopt-Funktion unterstützt wird, sind unten aufgeführt.

SO_CONNECT_TIME

Diese Option gibt die Anzahl der Sekunden zurück, die ein Socket verbunden wurde. Diese Option gilt nur für verbindungsorientierte Protokolle.

Die Option SO_CONNECT_TIME kann mit der getockopt-Funktion verwendet werden, um zu überprüfen, ob eine Verbindung hergestellt wurde. Diese Option kann auch verwendet werden, während ein ConnectEx-Funktionsaufruf ausgeführt wird. Wenn eine Verbindung hergestellt wird, kann die Option SO_CONNECT_TIME bestimmen, wie lange die Verbindung hergestellt wurde. Wenn der Socket nicht verbunden ist, gibt der getsockopt SOCKET_ERROR zurück. Eine solche Verbindung zu überprüfen ist erforderlich, um festzustellen, ob Verbindungen, die seit einer Weile eingerichtet wurden, ohne Daten zu senden. Es wird empfohlen, diese Verbindungen von Anwendungen zu beenden.

SO_DEBUG

Hinweis Windows Sockets-Dienstanbieter werden ermutigt (aber nicht erforderlich), Ausgabedebuginformationen bereitzustellen, wenn die Option SO_DEBUG von einer Anwendung festgelegt wird. Der Mechanismus zum Generieren der Debuginformationen und der benötigten Form sprengt den Geltungsbereich dieses Dokuments.

 

SO_ERROR

Die option SO_ERROR gibt den pro Socket basierenden Fehlercode zurück und setzt diesen zurück, der sich von dem pro threadbasierten Fehlercode unterscheidet, der mithilfe der Funktionsaufrufe WSAGetLastError und WSASetLastError verarbeitet wird. Ein erfolgreicher Aufruf mithilfe des Sockets setzt den socketbasierten Fehlercode, der von der Option SO_ERROR zurückgegeben wird, nicht zurück.

SO_EXCLUSIVEADDRUSE

Verhindert, dass ein anderer Socket an dieselbe Adresse und denselben Port gebunden wird. Diese Option muss vor dem Aufrufen der Bindungsfunktion festgelegt werden. Weitere Informationen finden Sie in der referenz SO_EXCLUSIVEADDRUSE .

SO_GROUP_ID

Hinweis Diese Option ist reserviert. Diese Option ist auch exklusiv für getsockopt; der Wert sollte NULL sein.

 

SO_GROUP_PRIORITY

Diese Option ist reserviert. Die Gruppenpriorität gibt die Priorität des angegebenen Sockets im Verhältnis zu anderen Sockets innerhalb der Socketgruppe an. Werte sind nicht abegative ganze Zahlen, wobei null der höchsten Priorität entspricht. Prioritätswerte stellen einen Hinweis an den zugrunde liegenden Dienstanbieter dar, wie potenziell knappe Ressourcen zugeordnet werden sollten. Wenn beispielsweise zwei oder mehr Sockets für die Übertragung von Daten bereit sind, sollte der Socket mit der höchsten Priorität (niedrigster Wert für SO_GROUP_PRIORITY) zuerst gewartet werden, während der rest wiederum entsprechend ihren relativen Prioritäten gewartet wird.

Der WSAENOPROTOOPT-Fehlercode wird für Nicht-Gruppensockets oder für Dienstanbieter angegeben, die keine Gruppensockets unterstützen.

SO_KEEPALIVE

Eine Anwendung kann anfordern, dass ein TCP/IP-Dienstanbieter die Verwendung von Keep-Alive-Paketen für TCP-Verbindungen aktiviert, indem sie die SO_KEEPALIVE Socketoption aktiviert. Diese Option fragt den aktuellen Wert der Keep-Alive-Option für einen Socket ab. Ein Windows Sockets-Anbieter muss die Verwendung von Keep-Alive nicht unterstützen: Wenn dies der Fall ist, ist die genaue Semantik implementierungsspezifisch, sollte jedoch Abschnitt 4.2.3.6 der Anforderungen für Internethosts – Kommunikationsebenen gemäß RFC 1122 entsprechen, die auf der IETF-Website verfügbar sind. Wenn eine Verbindung als Ergebnis von keep-alives abgebrochen wird, wird der Fehlercode WSAENETRESET an alle laufenden Aufrufe des Sockets zurückgegeben, und alle nachfolgenden Aufrufe schlagen mit WSAENOTCONN fehl. SO_KEEPALIVE wird auf ATM-Sockets nicht unterstützt, und Anforderungen zum Aktivieren der Verwendung von Keep-Alive-Paketen auf einem ATM-Socket führen zu einem Fehler, der vom Socket zurückgegeben wird.

SO_LINGER

SO_LINGER steuert die Aktion, die ausgeführt wird, wenn nicht gesendete Daten auf einem Socket in die Warteschlange gestellt werden und ein Closesocket ausgeführt wird. Unter closesocket finden Sie eine Beschreibung der Art und Weise, in der sich die SO_LINGER-Einstellungen auf die Semantik von Closesocket auswirken. Die Anwendung ruft das aktuelle Verhalten ab, indem eine LINGER-Struktur abgerufen wird (auf die der optval-Parameter verweist).

SO_MAX_MSG_SIZE

Dies ist eine get-only-Socketoption, die die maximale ausgehende (Sende-)Größe einer Nachricht für nachrichtenorientierte Sockettypen (z. B. SOCK_DGRAM) angibt, die von einem bestimmten Dienstanbieter implementiert wird. Es hat keine Bedeutung für Bytestrom-orientierte Sockets. Es gibt keine Bereitstellung, um die maximale Größe eingehender Nachrichten zu ermitteln.

SO_PROTOCOL_INFO

Dies ist eine get-only-Option, die die WSAPROTOCOL_INFO Struktur bereitstellt, die diesem Socket zugeordnet ist. Weitere Informationen zu dieser Struktur finden Sie unter WSAEnumProtocols .

SO_SNDBUF

Wenn eine Windows Sockets-Implementierung die optionen SO_RCVBUF und SO_SNDBUF unterstützt, kann eine Anwendung verschiedene Puffergrößen anfordern (größer oder kleiner). Der Aufruf von setsockopt kann auch dann erfolgreich sein, wenn die Implementierung nicht den gesamten angeforderten Betrag bereitgestellt hat. Eine Anwendung muss diese Funktion mit derselben Option aufrufen, um die tatsächlich bereitgestellte Puffergröße zu überprüfen.

SO_REUSEADDR

Standardmäßig kann ein Socket nicht an eine bereits verwendete lokale Adresse gebunden werden (siehe Bind). Gelegentlich kann es jedoch notwendig sein, eine Adresse auf diese Weise wiederzuverwenden. Da jede Verbindung durch die Kombination von lokalen und Remoteadressen eindeutig identifiziert wird, ist es kein Problem, zwei Sockets an dieselbe lokale Adresse gebunden zu haben, solange sich die Remoteadressen unterscheiden. Um den Windows Sockets-Anbieter darüber zu informieren, dass eine Bindung für einen Socket nicht unzulässig sein soll, da die gewünschte Adresse bereits von einem anderen Socket verwendet wird, sollte die Anwendung die Option SO_REUSEADDR Socket für den Socket festlegen, bevor die Bindung ausgegeben wird. Beachten Sie, dass die Option nur zum Zeitpunkt der Bindung interpretiert wird: Es ist daher unnötig (aber harmlos), die Option für einen Socket festzulegen, der nicht an eine vorhandene Adresse gebunden werden soll, und die Option festzulegen oder zurückzusetzen, nachdem die Bindung keine Auswirkungen auf dieses oder einen anderen Socket hat. SO_REUSEADDR gilt nicht für ATM-Sockets, und obwohl Anforderungen zur Wiederverwendung und adressieren nicht zu einem Fehler führen, wirken sie sich nicht darauf aus, wenn ein ATM-Socket verwendet wird.

PVD_CONFIG

Diese Option ruft ein undurchsichtiges Datenstrukturobjekt vom Dienstanbieter ab, der Sockets zugeordnet ist. Dieses Objekt speichert die aktuellen Konfigurationsinformationen des Dienstanbieters. Das genaue Format dieser Datenstruktur ist dienstanbieterspezifisch.

TCP_NODELAY

Die option TCP_NODELAY ist spezifisch für TCP/IP-Dienstanbieter. Der Nagle-Algorithmus ist deaktiviert, wenn die Option TCP_NODELAY aktiviert ist (und umgekehrt). Der Nagle-Algorithmus (beschrieben in RFC 896) ist sehr effektiv bei der Reduzierung der Anzahl kleiner Pakete, die von einem Host gesendet werden. Der Prozess umfasst das Puffern von Sendedaten, wenn nicht bekannte Daten bereits im Flight vorhanden sind, oder das Puffern von Sendedaten, bis ein Paket in voller Größe gesendet werden kann. Es wird dringend empfohlen, dass Windows Sockets-Implementierungen den Nagle-Algorithmus standardmäßig aktivieren, da der Nagle-Algorithmus für die überwiegende Mehrheit der Anwendungsprotokolle erhebliche Leistungsverbesserungen liefern kann. Für einige Anwendungen kann dieser Algorithmus jedoch die Leistung beeinträchtigen, und setsockopt mit derselben Option kann verwendet werden, um ihn zu deaktivieren. Dies sind Anwendungen, bei denen viele kleine Nachrichten gesendet werden und die Zeitverzögerungen zwischen den Nachrichten beibehalten werden.

Beispielcode

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

Hinweise zu IrDA-Sockets

• Die Af_irda.h-Headerdatei muss explizit enthalten sein.
• Windows gibt WSAENETDOWN zurück, um anzugeben, dass der zugrunde liegende Transceivertreiber nicht mit dem IrDA-Protokollstapel initialisiert werden konnte.
• IrDA unterstützt mehrere spezielle Socketoptionen:

  Wert	Typ	Bedeutung
  IRLMP_ENUMDEVICES	*DEVICELIST	Beschreibt Geräte im Bereich.
  IRLMP_IAS_QUERY	*IAS_QUERY	Abrufen von IAS-Attributen.

   

Bevor eine IrDA-Socketverbindung initiiert werden kann, muss eine Geräteadresse abgerufen werden, indem ein getsockopt(,,IRLMP_ENUMDEVICES,,)-Funktionsaufruf ausgeführt wird, der eine Liste aller verfügbaren IrDA-Geräte zurückgibt. Eine vom Funktionsaufruf zurückgegebene Geräteadresse wird in eine SOCKADDR_IRDA-Struktur kopiert, die wiederum von einem nachfolgenden Aufruf des Verbindungsfunktionsaufrufs verwendet wird.

Die Ermittlung kann auf zwei Arten durchgeführt werden:

1. Erstens führt die Ausführung eines getockopt-Funktionsaufrufs mit der Option IRLMP_ENUMDEVICES dazu, dass eine einzelne Ermittlung auf jedem Adapter im Leerlauf ausgeführt wird. Die Liste der ermittelten Geräte und zwischengespeicherten Geräte (auf aktiven Adaptern) wird sofort zurückgegeben.

   Der folgende Code veranschaulicht diesen Ansatz.

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

2. Der zweite Ansatz für die Ermittlung von IrDA-Geräteadressen besteht darin, eine verzögerte Ermittlung durchzuführen. bei diesem Ansatz wird die Anwendung erst benachrichtigt, wenn sich die Liste der ermittelten Geräte gegenüber der letzten Ermittlung ändert, die vom Stapel ausgeführt wurde.

Die IAS_QUERY-Struktur , die in der Spalte Typ in der vorherigen Tabelle angezeigt wird, wird verwendet, um ein einzelnes Attribut einer einzelnen Klasse aus der IAS-Datenbank eines Peergeräts abzurufen. Die Anwendung gibt das abzufragende Gerät und die Klasse sowie das Attribut und den Attributtyp an. Beachten Sie, dass das Gerät zuvor durch einen Aufruf von getsockopt(IRLMP_ENUMDEVICES) abgerufen worden wäre. Es wird erwartet, dass die Anwendung einen Puffer der erforderlichen Größe für die zurückgegebenen Parameter zuweist.

Viele Ebenen-Socketoptionen sind für IrDA nicht sinnvoll; nur SO_LINGER und SO_DONTLINGER werden speziell unterstützt.

Windows Phone 8: Diese Funktion wird für Windows Phone Store-Apps ab Windows Phone 8 unterstützt.

Windows 8.1 und Windows Server 2012 R2: Diese Funktion wird für Windows Store-Apps auf Windows 8.1, Windows Server 2012 R2 und höher unterstützt.

Anforderungen

Weitere Informationen

IPPROTO_IP Socketoptionen

IPPROTO_IPV6 Socketoptionen

IPPROTO_RM Socketoptionen

IPPROTO_TCP Socketoptionen

IPPROTO_UDP Socketoptionen

NSPROTO_IPX Socketoptionen

SOL_APPLETALK Socketoptionen

SOL_IRLMP Socketoptionen

SOL_SOCKET Socketoptionen

Socketoptionen

WSAAsyncSelect

WSAConnect

WSAGetLastError

WSAIoctl

WSASetLastError

Winsock-Funktionen

ioctlsocket

Recv

setsockopt

Socket