这是 Connecting IPv4 client to IPv6 server: connection refused 的延续.我正在试验双堆栈套接字，并试图了解 setsockopt with IPV6_V6ONLY 的用途。在链接的问题上，我被告知“如果您还将服务器绑定(bind)到 IPv6 映射的 IPv4 地址，则将 IPV6_V6ONLY 设置为 0 可能很有用”。我在下面完成了此操作，并期望我的服务器能够接受来自 IPv6 和 IPv4 客户端的连接。但令人震惊的是，当我使用 V4 和 V6 套接字运行我的客户端时，两者都无法连接!

谁能告诉我我做错了什么，还是我误解了 IPv6 双栈功能？

服务器:

void ConvertToV4MappedAddressIfNeeded(PSOCKADDR pAddr)
{
// if v4 address, convert to v4 mapped v6 address
if (AF_INET == pAddr->sa_family)
{
    IN_ADDR In4addr;
    SCOPE_ID scope = INETADDR_SCOPE_ID(pAddr);
    USHORT port = INETADDR_PORT(pAddr);
    In4addr = *(IN_ADDR*)INETADDR_ADDRESS(pAddr);
    ZeroMemory(pAddr, sizeof(SOCKADDR_STORAGE));
    IN6ADDR_SETV4MAPPED(
        (PSOCKADDR_IN6)pAddr,
        &In4addr,
        scope,
        port
        );
    }
} 

addrinfo* result, hints;

memset(&hints, 0, sizeof hints); 
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;

int nRet = getaddrinfo("powerhouse", "82", &hints, &result);

SOCKET sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);

int no = 0;
if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&no, sizeof(no)) != 0)
    return -1;

ConvertToV4MappedAddressIfNeeded(result->ai_addr);

if (bind(sock, result->ai_addr, 28/*result->ai_addrlen*/) ==  SOCKET_ERROR)
    return -1;

if (listen(sock, SOMAXCONN) == SOCKET_ERROR)
    return -1;

SOCKET sockClient = accept(sock, NULL, NULL);
printf("Got one!\n");

客户:

addrinfo* result, *pCurrent, hints;
char szIPAddress[INET6_ADDRSTRLEN];

memset(&hints, 0, sizeof hints);    // Must do this!
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;

const char* pszPort = "82";

if (getaddrinfo("powerhouse", "82", &hints, &result) != 0)
    return -1;

SOCKET sock = socket(AF_INET, result->ai_socktype, result->ai_protocol);
int nRet = connect(sock, result->ai_addr, result->ai_addrlen);  

最佳答案

我的C技能有点生疏，所以这里有一个用Python写的反例。我的本地 IPv4 地址是 37.77.56.75，所以这就是我要绑定(bind)的地址。我尽可能简单地关注概念。

这是服务器端:

#!/usr/bin/env python
import socket

# We bind to an IPv6 address, which contains an IPv6-mapped-IPv4-address,
# port 5000 and we leave the flowinfo (an ID that identifies a flow, not used
# a lot) and the scope-id (basically the interface, necessary if using
# link-local addresses)
host = '::ffff:37.77.56.75'
port = 5000
flowinfo = 0
scopeid = 0
sockaddr = (host, port, flowinfo, scopeid)

# Create an IPv6 socket, set IPV6_V6ONLY=0 and bind to the mapped address
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
sock.bind(sockaddr)

# Listen and accept a connection
sock.listen(0)
conn = sock.accept()

# Print the remote address
print conn[1]

此处我们在代码中绑定(bind)了一个 IPv6 地址，但该地址实际上是一个 IPv6 映射的 IPv4 地址，所以实际上我们绑定(bind)的是一个 IPv4 地址。这可以在查看即 netstat 时看到:

$ netstat -an | fgrep 5000
tcp4       0      0  37.77.56.75.5000       *.*                    LISTEN     

然后我们可以使用 IPv4 客户端连接到此服务器:

#!/usr/bin/env python
import socket

# Connect to an IPv4 address on port 5000
host = '37.77.56.75'
port = 5000
sockaddr = (host, port)                   

# Create an IPv4 socket and connect
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) 
conn = sock.connect(sockaddr)

服务器将使用 IPv6 地址表示向我们显示谁连接了:

('::ffff:37.77.56.76', 50887, 0, 0)

在这个例子中，我从 IPv4 主机 37.77.56.76 连接，它选择端口 50887 连接。

在此示例中，我们仅监听 IPv4 地址(使用 IPv6 套接字，但它仍然是 IPv4 地址)，因此纯 IPv6 客户端将无法连接。同时具有 IPv4 和 IPv6 的客户端当然可以使用具有 IPv6 映射 IPv4 地址的 IPv6 套接字，但那样它就不会真正使用 IPv6，而只是 IPv4 连接的 IPv6 表示。

双栈服务器必须:

1. 监听通配符地址，这将使操作系统接受任何地址(IPv4 和 IPv6)上的连接
2. 同时监听 IPv6 地址和 IPv4 地址(通过创建 IPv4 套接字，或通过创建 IPv6 套接字并监听 IPv6 映射的 IPv4 地址，如上所示)

使用通配符地址是最简单的。只需使用上面的服务器示例并替换主机名:

# We bind to the wildcard IPv6 address, which will make the OS listen on both
# IPv4 and IPv6
host = '::'
port = 5000
flowinfo = 0
scopeid = 0
sockaddr = (host, port, flowinfo, scopeid)

我的 Mac OS X 盒子显示为:

$ netstat -an | fgrep 5000
tcp46      0      0  *.5000                 *.*                    LISTEN     

注意 tcp46，它表示它在两个地址系列上都进行监听。不幸的是，在 Linux 上它只显示 tcp6，即使在监听两个系列时也是如此。

现在来看最复杂的例子:监听多个套接字。

#!/usr/bin/env python
import select
import socket

# We bind to an IPv6 address, which contains an IPv6-mapped-IPv4-address
sockaddr1 = ('::ffff:37.77.56.75', 5001, 0, 0)

sock1 = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
sock1.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
sock1.bind(sockaddr1)
sock1.listen(0)

# And we bind to a real IPv6 address
sockaddr2 = ('2a00:8640:1::224:36ff:feef:1d89', 5001, 0, 0)

sock2 = socket.socket(socket.AF_INET6, socket.SOCK_STREAM, 0)
sock2.bind(sockaddr2)
sock2.listen(0)

# Select sockets that become active
sockets = [sock1, sock2]
readable, writable, exceptional = select.select(sockets, [], sockets)
for sock in readable:
    # Accept the connection
    conn = sock.accept()

    # Print the remote address
    print conn[1]

运行这个例子时，两个套接字都是可见的:

$ netstat -an | fgrep 5000
tcp6       0      0  2a00:8640:1::224.5000  *.*                    LISTEN     
tcp4       0      0  37.77.56.75.5000       *.*                    LISTEN     

现在仅支持 IPv6 的客户端可以连接到 2a00:8640:1::224:36ff:feef:1d89，仅支持 IPv4 的客户端可以连接到37.77.56.75。双栈客户端可以选择他们想要使用的协议(protocol)。

关于sockets - 使用 IN6ADDR_SETV4MAPPED 和双堆栈套接字，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16762939/