Wywołania funkcji dla aplikacji Winsock IPv6

Nowe funkcje zostały wprowadzone do interfejsu Windows Sockets specjalnie zaprojektowane w celu ułatwienia programowania windows Sockets. Jedną z zalet tych nowych funkcji Windows Sockets jest zintegrowana obsługa protokołów IPv6 i IPv4.

Te nowe funkcje windows Sockets obejmują następujące elementy:

WSAConnectByName
WSAConnectByList
rodziny funkcji getaddrinfo (getaddrinfo, GetAddrInfoEx, GetAddrInfoW, freeaddrinfo, FreeAddrInfoEx, FreeAddrInfoWi SetAddrInfoEx)
rodziny funkcji getnameinfo (getnameinfo i GetNameInfoW)

Ponadto dodano nowe funkcje pomocnika IP z obsługą protokołów IPv6 i IPv4 w celu uproszczenia programowania gniazd systemu Windows. Te nowe funkcje pomocnika adresów IP obejmują następujące elementy:

GetAdaptersAddresses

Podczas dodawania obsługi protokołu IPv6 do aplikacji należy użyć następujących wskazówek:

Użyj WSAConnectByName, aby nawiązać połączenie z punktem końcowym przy użyciu nazwy hosta i portu. Funkcja WSAConnectByName jest dostępna w systemie Windows Vista i nowszych wersjach.
Użyj WSAConnectByList, aby nawiązać połączenie z jedną z kolekcji możliwych punktów końcowych reprezentowanych przez zestaw adresów docelowych (nazwy hostów i porty). Funkcja WSAConnectByList jest dostępna w systemie Windows Vista i nowszych wersjach.
Zastąp wywołania funkcji gethostbyname wywołaniami jednej z nowych getaddrinfo funkcji Windows Sockets. Funkcja getaddrinfo z obsługą protokołu IPv6 jest dostępna w systemie Windows XP i nowszych wersjach. Protokół IPv6 jest również obsługiwany w systemie Windows 2000, gdy jest zainstalowany protokół IPv6 Technology Preview dla systemu Windows 2000.
Zastąp wywołania funkcji gethostbyaddr wywołaniami do jednej z nowych funkcji getnameinfo Windows Sockets. Funkcja getnameinfo z obsługą protokołu IPv6 jest dostępna w systemie Windows XP i nowszych wersjach. Protokół IPv6 jest również obsługiwany w systemie Windows 2000, gdy jest zainstalowany protokół IPv6 Technology Preview dla systemu Windows 2000.

WSAConnectByName

Funkcja WSAConnectByName upraszcza nawiązywanie połączenia z punktem końcowym przy użyciu gniazda opartego na strumieniu, biorąc pod uwagę nazwę hosta lub adres IP miejsca docelowego (IPv4 lub IPv6). Ta funkcja zmniejsza kod źródłowy wymagany do utworzenia aplikacji IP niezależnej od używanej wersji protokołu IP. WSAConnectByName zastępuje następujące kroki w typowej aplikacji TCP do pojedynczego wywołania funkcji:

Rozpoznawanie nazwy hosta na zestaw adresów IP.
Dla każdego adresu IP:
- Utwórz gniazdo odpowiedniej rodziny adresów.
- Próbuje nawiązać połączenie ze zdalnym adresem IP. Jeśli połączenie zakończyło się pomyślnie, zwraca wartość ; w przeciwnym razie zostanie podjęta próba następnego zdalnego adresu IP hosta.

Funkcja WSAConnectByName wykracza poza rozpoznawanie nazwy, a następnie próbuje nawiązać połączenie. Funkcja używa wszystkich adresów zdalnych zwracanych przez rozpoznawanie nazw i wszystkich źródłowych adresów IP maszyny lokalnej. Najpierw próbuje nawiązać połączenie przy użyciu par adresów z największą szansą na powodzenie. W związku z tym WSAConnectByName nie tylko gwarantuje, że połączenie zostanie nawiązane, jeśli to możliwe, ale także minimalizuje czas nawiązywania połączenia.

Aby włączyć komunikację zarówno IPv6, jak i IPv4, użyj następującej metody:

Funkcja setsockopt musi być wywoływana w gniazdie utworzonym dla rodziny adresów AF_INET6, aby wyłączyć opcję gniazda IPV6_V6ONLY przed wywołaniem WSAConnectByName. Jest to realizowane przez wywołanie funkcji setsockopt w gniazdie z parametrem na poziomie ustawionym na IPPROTO_IPV6 (zobacz IPPROTO_IPV6 Opcje gniazda), parametr optname ustawiony na IPV6_V6ONLY, a optvalue wartość parametru ustawioną na zero.

Jeśli aplikacja musi powiązać z określonym lokalnym adresem lub portem, WSAConnectByName nie można użyć, ponieważ parametr gniazda do WSAConnectByName musi być niezwiązanym gniazdem.

Poniższy przykład kodu pokazuje, że do zaimplementowania aplikacji niezależnej od wersji adresu IP jest potrzebnych tylko kilka wierszy kodu.

Nawiązywanie połączenia przy użyciu WSAConnectByName

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

SOCKET OpenAndConnect(LPWSTR NodeName, LPWSTR PortName) 
{
    SOCKET ConnSocket;
    DWORD ipv6only = 0;
    int iResult;
    BOOL bSuccess;
    SOCKADDR_STORAGE LocalAddr = {0};
    SOCKADDR_STORAGE RemoteAddr = {0};
    DWORD dwLocalAddr = sizeof(LocalAddr);
    DWORD dwRemoteAddr = sizeof(RemoteAddr);
  
    ConnSocket = socket(AF_INET6, SOCK_STREAM, 0);
    if (ConnSocket == INVALID_SOCKET){
        return INVALID_SOCKET;
    }

    iResult = setsockopt(ConnSocket, IPPROTO_IPV6,
        IPV6_V6ONLY, (char*)&ipv6only, sizeof(ipv6only) );
    if (iResult == SOCKET_ERROR){
        closesocket(ConnSocket);
        return INVALID_SOCKET;       
    }

    bSuccess = WSAConnectByName(ConnSocket, NodeName, 
            PortName, &dwLocalAddr,
            (SOCKADDR*)&LocalAddr,
            &dwRemoteAddr,
            (SOCKADDR*)&RemoteAddr,
            NULL,
            NULL);
    if (bSuccess){
        return ConnSocket;
    } else {
        return INVALID_SOCKET;
    }
}

WSAConnectByList

Funkcja WSAConnectByList ustanawia połączenie z hostem przy użyciu zestawu możliwych hostów (reprezentowanych przez zestaw docelowych adresów IP i portów). Funkcja przyjmuje wszystkie adresy IP i porty dla punktu końcowego i wszystkich adresów IP komputera lokalnego oraz próbuje nawiązać połączenie przy użyciu wszystkich możliwych kombinacji adresów.

WSAConnectByList jest powiązana z funkcją WSAConnectByName. Zamiast przyjmować jedną nazwę hosta, WSAConnectByList akceptuje listę hostów (adresy docelowe i pary portów) i łączy się z jednym z adresów i portów na podanej liście. Ta funkcja jest przeznaczona do obsługi scenariuszy, w których aplikacja musi łączyć się z dowolnym dostępnym hostem z listy potencjalnych hostów.

Podobnie jak WSAConnectByName, funkcjaWSAConnectByList znacznie zmniejsza kod źródłowy wymagany do utworzenia, powiązania i połączenia gniazda. Ta funkcja znacznie ułatwia implementowanie aplikacji niezależnej od wersji adresu IP. Lista adresów hosta zaakceptowanego przez tę funkcję może być adresami IPv6 lub IPv4.

Aby umożliwić przekazywanie zarówno adresów IPv6, jak i IPv4 na jednej liście adresów zaakceptowanej przez funkcję, przed wywołaniem funkcji należy wykonać następujące kroki:

Funkcja setsockopt musi być wywoływana w gniazdie utworzonym dla rodziny adresów AF_INET6, aby wyłączyć opcję gniazda IPV6_V6ONLY przed wywołaniem WSAConnectByList. Jest to realizowane przez wywołanie funkcji setsockopt w gniazdie z parametrem na poziomie ustawionym na IPPROTO_IPV6 (zobacz IPPROTO_IPV6 Opcje gniazda), parametr optname ustawiony na IPV6_V6ONLY, a optvalue wartość parametru ustawioną na zero.
Wszystkie adresy IPv4 muszą być reprezentowane w formacie adresów IPv4 mapowanych IPv6, co umożliwia aplikacji IPv6 komunikowanie się tylko z węzłem IPv4. Format adresu IPv4 mapowany za pomocą protokołu IPv6 umożliwia reprezentowanie adresu IPv4 węzła IPv4 jako adresu IPv6. Adres IPv4 jest zakodowany w niskiej kolejności 32 bitów adresu IPv6, a high-order 96 bitów posiadają stały prefiks 0:0:0:0:0:FFFF. Format adresu IPv4 mapowany zamapowany na protokół IPv6 jest określony w specyfikacji RFC 4291. Aby uzyskać więcej informacji, zobacz www.ietf.org/rfc/rfc4291.txt. Makro IN6ADDR_SETV4MAPPED w Mstcpip.h może służyć do konwertowania adresu IPv4 na wymagany format adresu IPv4 mapowanego IPv6.

Ustanawianie połączenia przy użyciu WSAConnectByList

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

SOCKET OpenAndConnect(SOCKET_ADDRESS_LIST *AddressList) 
{
    SOCKET ConnSocket;
    DWORD ipv6only = 0;
    int iResult;
    BOOL bSuccess;
    SOCKADDR_STORAGE LocalAddr = {0};
    SOCKADDR_STORAGE RemoteAddr = {0};
    DWORD dwLocalAddr = sizeof(LocalAddr);
    DWORD dwRemoteAddr = sizeof(RemoteAddr);

    ConnSocket = socket(AF_INET6, SOCK_STREAM, 0);
    if (ConnSocket == INVALID_SOCKET){
        return INVALID_SOCKET;
    }

    iResult = setsockopt(ConnSocket, IPPROTO_IPV6,
        IPV6_V6ONLY, (char*)&ipv6only, sizeof(ipv6only) );
    if (iResult == SOCKET_ERROR){
        closesocket(ConnSocket);
        return INVALID_SOCKET;       
    }

    // AddressList may contain IPv6 and/or IPv4Mapped addresses
    bSuccess = WSAConnectByList(ConnSocket,
            AddressList,
            &dwLocalAddr,
            (SOCKADDR*)&LocalAddr,
            &dwRemoteAddr,
            (SOCKADDR*)&RemoteAddr,
            NULL,
            NULL);
    if (bSuccess){
        return ConnSocket;
    } else {
        return INVALID_SOCKET;
    }
}

getaddrinfo

Funkcja getaddrinfo również wykonuje przetwarzanie wielu funkcji. Wcześniej wywołania wielu funkcji Gniazd systemu Windows były wymagane do utworzenia, otwarcia, a następnie powiązania adresu z gniazdem. Dzięki funkcji getaddrinfo wiersze kodu źródłowego niezbędne do wykonania takiej pracy mogą zostać znacznie zmniejszone. W poniższych dwóch przykładach pokazano kod źródłowy niezbędny do wykonywania tych zadań za pomocą funkcji getaddrinfo i bez .

Wykonywanie polecenia Open, Connect i Bind Using getaddrinfo

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

SOCKET OpenAndConnect(char *ServerName, char *PortName, int SocketType)
{
    SOCKET ConnSocket;
    ADDRINFO *AI;

    if (getaddrinfo(ServerName, PortName, NULL, &AI) != 0) {
        return INVALID_SOCKET;
    }

    ConnSocket = socket(AI->ai_family, SocketType, 0);
    if (ConnSocket == INVALID_SOCKET) {
        freeaddrinfo(AI);
        return INVALID_SOCKET;
    }

    if (connect(ConnSocket, AI->ai_addr, (int) AI->ai_addrlen) == SOCKET_ERROR) {
        closesocket(ConnSocket);
        freeaddrinfo(AI);
        return INVALID_SOCKET;
    }

    return ConnSocket;
}

Wykonywanie polecenia Open, Connect i Bind Without Using getaddrinfo

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

SOCKET OpenAndConnect(char *ServerName, unsigned short Port, int SocketType) 
{
    SOCKET ConnSocket;
    LPHOSTENT hp;
    SOCKADDR_IN ServerAddr;
    
    ConnSocket = socket(AF_INET, SocketType, 0); /* Open a socket */
    if (ConnSocket < 0 ) {
        return INVALID_SOCKET;
    }

    memset(&ServerAddr, 0, sizeof(ServerAddr));
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(Port);

    if (isalpha(ServerName[0])) {   /* server address is a name */
        hp = gethostbyname(ServerName);
        if (hp == NULL) {
            return INVALID_SOCKET;
        }
        ServerAddr.sin_addr.s_addr = (ULONG) hp->h_addr;
    } else { /* Convert nnn.nnn address to a usable one */
        ServerAddr.sin_addr.s_addr = inet_addr(ServerName);
    } 

    if (connect(ConnSocket, (LPSOCKADDR)&ServerAddr, 
        sizeof(ServerAddr)) == SOCKET_ERROR)
    {
        closesocket(ConnSocket);
        return INVALID_SOCKET;
    }

    return ConnSocket;
}

Zwróć uwagę, że oba te przykłady kodu źródłowego wykonują te same zadania, ale pierwszy przykład, używając funkcji getaddrinfo, wymaga mniejszej liczby wierszy kodu źródłowego i może obsługiwać adresy IPv6 lub IPv4. Liczba wierszy kodu źródłowego wyeliminowanych przy użyciu funkcji getaddrinfo różni się.

Nuta

W kodzie źródłowym produkcyjnym aplikacja będzie iterować przez zestaw adresów zwracanych przez gethostbyname lub funkcji getaddrinfo. Te przykłady pomijają ten krok na rzecz prostoty.

Inny problem należy rozwiązać podczas modyfikowania istniejącej aplikacji IPv4 w celu obsługi protokołu IPv6 jest skojarzony z kolejnością wywoływanych funkcji. Obie getaddrinfo i gethostbyname wymagają wykonania sekwencji wywołań funkcji w określonej kolejności.

Na platformach, na których są używane zarówno protokoły IPv4, jak i IPv6, rodzina adresów nazwy hosta zdalnego nie jest znana z wyprzedzeniem. Rozpoznawanie adresów przy użyciu funkcji getaddrinfo należy wykonać najpierw, aby określić adres IP i rodzinę adresów hosta zdalnego. Następnie funkcję socket można wywołać, aby otworzyć gniazdo rodziny adresów zwrócone przez getaddrinfo. Jest to ważna zmiana sposobu pisania aplikacji Windows Sockets, ponieważ wiele aplikacji IPv4 zwykle używa innej kolejności wywołań funkcji.

Większość aplikacji IPv4 najpierw tworzy gniazdo dla rodziny adresów AF_INET, a następnie wykonuje rozpoznawanie nazw, a następnie użyj gniazda, aby nawiązać połączenie z rozpoznanym adresem IP. Podczas tworzenia takich aplikacji z obsługą protokołu IPv6 wywołanie funkcji gniazda musi być opóźnione do momentu ustalenia nazwy rozpoznawania nazw. Należy pamiętać, że jeśli rozpoznawanie nazw zwraca zarówno adresy IPv4, jak i IPv6, należy użyć oddzielnych gniazd IPv4 i IPv6 w celu nawiązania połączenia z tymi adresami docelowymi. Można uniknąć wszystkich tych złożoności, korzystając z funkcji WSAConnectByName w systemie Windows Vista i nowszych, dlatego deweloperzy aplikacji są zachęcani do korzystania z tej nowej funkcji.

Poniższy przykład kodu przedstawia właściwą sekwencję wykonywania rozpoznawania nazw jako pierwszą (wykonaną w czwartym wierszu w poniższym przykładzie kodu źródłowego), a następnie otwarcie gniazda (wykonywanego w wierszu 19 w poniższym przykładzie kodu). W tym przykładzie znajduje się fragment pliku Client.c znajdujący się w IPv6-Enabled Kod klienta w dodatku B. Funkcja PrintError o nazwie w poniższym przykładzie kodu jest wymieniona w przykładzie Client.c.

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

SOCKET OpenAndConnect(char *Server, char *PortName, int Family, int SocketType)
{

    int iResult = 0;
    SOCKET ConnSocket = INVALID_SOCKET;

    ADDRINFO *AddrInfo = NULL;
    ADDRINFO *AI = NULL;
    ADDRINFO Hints;

    char *AddrName = NULL;

    memset(&Hints, 0, sizeof (Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;

    iResult = getaddrinfo(Server, PortName, &Hints, &AddrInfo);
    if (iResult != 0) {
        printf("Cannot resolve address [%s] and port [%s], error %d: %s\n",
               Server, PortName, WSAGetLastError(), gai_strerror(iResult));
        return INVALID_SOCKET;
    }
    //
    // Try each address getaddrinfo returned, until we find one to which
    // we can successfully connect.
    //
    for (AI = AddrInfo; AI != NULL; AI = AI->ai_next) {

        // Open a socket with the correct address family for this address.
        ConnSocket = socket(AI->ai_family, AI->ai_socktype, AI->ai_protocol);
        if (ConnSocket == INVALID_SOCKET) {
            printf("Error Opening socket, error %d\n", WSAGetLastError());
            continue;
        }
        //
        // Notice that nothing in this code is specific to whether we 
        // are using UDP or TCP.
        //
        // When connect() is called on a datagram socket, it does not 
        // actually establish the connection as a stream (TCP) socket
        // would. Instead, TCP/IP establishes the remote half of the
        // (LocalIPAddress, LocalPort, RemoteIP, RemotePort) mapping.
        // This enables us to use send() and recv() on datagram sockets,
        // instead of recvfrom() and sendto().
        //

        printf("Attempting to connect to: %s\n", Server ? Server : "localhost");
        if (connect(ConnSocket, AI->ai_addr, (int) AI->ai_addrlen) != SOCKET_ERROR)
            break;

        if (getnameinfo(AI->ai_addr, (socklen_t) AI->ai_addrlen, AddrName,
                        sizeof (AddrName), NULL, 0, NI_NUMERICHOST) != 0) {
            strcpy_s(AddrName, sizeof (AddrName), "<unknown>");
            printf("connect() to %s failed with error %d\n", AddrName, WSAGetLastError());
            closesocket(ConnSocket);
            ConnSocket = INVALID_SOCKET;
        }    
    }
    return ConnSocket;
}

Funkcje pomocnika adresów IP

Na koniec aplikacje korzystające z funkcji pomocnika IP GetAdaptersInfoi skojarzonej struktury IP_ADAPTER_INFOmuszą rozpoznać, że zarówno ta funkcja, jak i struktura są ograniczone do adresów IPv4. Zamiany protokołu IPv6 dla tej funkcji i struktury to funkcja GetAdaptersAddresses oraz struktura IP_ADAPTER_ADDRESSES. Aplikacje z obsługą protokołu IPv6 korzystające z interfejsu API pomocnika IP powinny używać funkcji GetAdaptersAddresses oraz odpowiedniej struktury IP_ADAPTER_ADDRESSES z obsługą protokołu IPv6, która jest zdefiniowana w zestawie Sdk (Software Development Kit) systemu Microsoft Windows.

Zalecenia

Najlepszym podejściem do zapewnienia, że aplikacja korzysta z wywołań funkcji zgodnych z protokołem IPv6, jest użycie funkcji getaddrinfo do uzyskiwania tłumaczenia host-to-address. Począwszy od systemu Windows XP, funkcja getaddrinfo sprawia, że gethostbyname funkcji niepotrzebnej, a aplikacja powinna zatem używać funkcji getaddrinfo zamiast przyszłych projektów programistycznych. Chociaż firma Microsoft będzie nadal obsługiwać gethostbyname, ta funkcja nie zostanie rozszerzona w celu obsługi protokołu IPv6. Aby uzyskać przezroczystą obsługę uzyskiwania informacji o hoście IPv6 i IPv4, należy użyć getaddrinfo.

W poniższym przykładzie pokazano, jak najlepiej używać funkcji getaddrinfo. Zwróć uwagę, że funkcja, jeśli jest używana prawidłowo, jak pokazano w tym przykładzie, obsługuje poprawne tłumaczenie hostów IPv6 i IPv4 na adres, ale także uzyskuje inne przydatne informacje o hoście, takie jak obsługiwane typy gniazd. Ten przykład jest fragmentem przykładu Client.c znalezionego w dodatku B.

#ifndef UNICODE
#define UNICODE
#endif

#define WIN32_LEAN_AND_MEAN

#include <winsock2.h>
#include <Ws2tcpip.h>
#include <stdio.h>

// Link with ws2_32.lib
#pragma comment(lib, "Ws2_32.lib")

int ResolveName(char *Server, char *PortName, int Family, int SocketType)
{

    int iResult = 0;

    ADDRINFO *AddrInfo = NULL;
    ADDRINFO *AI = NULL;
    ADDRINFO Hints;

   //
    // By not setting the AI_PASSIVE flag in the hints to getaddrinfo, we're
    // indicating that we intend to use the resulting address(es) to connect
    // to a service.  This means that when the Server parameter is NULL,
    // getaddrinfo will return one entry per allowed protocol family
    // containing the loopback address for that family.
    //
    
    memset(&Hints, 0, sizeof(Hints));
    Hints.ai_family = Family;
    Hints.ai_socktype = SocketType;
    iResult = getaddrinfo(Server, PortName, &Hints, &AddrInfo);
    if (iResult != 0) {
        printf("Cannot resolve address [%s] and port [%s], error %d: %s\n",
               Server, PortName, WSAGetLastError(), gai_strerror(iResult));
        return SOCKET_ERROR;
    }
     return 0;
}

Nuta

Wersja funkcji getaddrinfo, która obsługuje protokół IPv6, jest nową wersją systemu Windows XP systemu Windows.

Kod, aby uniknąć

Tłumaczenie adresów hosta zostało tradycyjnie osiągnięte przy użyciu funkcji gethostbyname. Począwszy od systemu Windows XP:

Funkcja getaddrinfo sprawia, że funkcja gethostbyname przestarzała.
Aplikacje powinny używać funkcji getaddrinfo zamiast funkcji gethostbyname.

Zadania kodowania

Aby zmodyfikować istniejącą aplikację IPv4 w celu dodania obsługi protokołu IPv6

Uzyskaj narzędzie Checkv4.exe. To narzędzie jest instalowane jako część zestawu Windows SDK. Starsza wersja narzędzia Checkv4.exe została również dołączona do wersji Microsoft IPv6 Technology Preview dla systemu Windows 2000.
Uruchom narzędzie Checkv4.exe względem kodu. Zobacz Using the Checkv4.exe Utility (Korzystanie z narzędzia Checkv4.exe), aby dowiedzieć się więcej na temat uruchamiania narzędzia wersji względem plików.
Narzędzie wyświetla alerty dotyczące użycia gethostbyname, gethostbyaddri innych funkcji tylko IPv4 oraz zawiera zalecenia dotyczące zastępowania ich funkcją zgodną z protokołem IPv6, taką jak getaddrinfo i getnameinfo.
Zastąp wszystkie wystąpienia funkcji gethostbyname i skojarzonym kodem zgodnie z potrzebami za pomocą funkcji getaddrinfo. W systemie Windows Vista użyj funkcji WSAConnectByName lub WSAConnectByList.
Zastąp wszystkie wystąpienia funkcji gethostbyaddr i skojarzonym kodem zgodnie z potrzebami za pomocą funkcji getnameinfo.

Alternatywnie możesz wyszukać bazę kodu dla wystąpień gethostbyname i funkcji gethostbyaddr i zmienić wszystkie takie użycie (i inny skojarzony kod, odpowiednio) do getaddrinfo i funkcji getnameinfo.

przewodnik IPv6 dla aplikacji Windows Sockets
zmienianie struktur danych dla aplikacji IPv6 Winsock
Dual-Stack Gniazda dla aplikacji Winsock korzystających z IPv6
używanie zakodowanych na stałe adresów IPv4
problemy z interfejsem użytkownika dla aplikacji IPv6 Winsock
podstawowych protokołów dla aplikacji Winsock protokołu IPv6

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-03-12