BSD套接字ip6 inet_pton以及如何获取作用域ID

Question

I am currently working on an IPv6 class and use inet_pton to retrieve the actual binary representation of the IP from a string ie:

    AdressV6::AdressV6(const String & _ip)
    {
        int result = inet_pton(AF_INET6, _ip.c_str(), &(m_nativeAdress));

        if(result <= 0)
            //throw...

        //How can I retrieve the sope ID from that?
    }

Is there a common way to do that? Do you just manually parse the string and look for the "%" that does not sound very bullet proof :(

Thank you!

I tried manual parsing for now which seems to work. Still, if there is a better way please let me know:

        //retrieve scope ID
        uint32 scopeId = 0;
        size_t pos = _ip.find("%");
        if(pos != String::npos)
        {
            String theId = _ip.substr(pos+1);
            scopeId = atoi(theId.c_str());
        }
        m_scopeId = scopeId;

Answer 1

On BSD and BSD based systems (this includes MacOS X for example), the scope ID is embedded into the address itself for link local addresses as the second 16 bit word. Please refer to the FreeBSD Handbook and search for "8.1.1.3 Scope Index" (without the quotes).

So assuming that intf1 has scope ID 1 and intf2 has scope ID 2, inet_pton() will convert the strings as follows on these platforms:

"fe80::1234%intf1" -> fe80:1::1234
"fe80::1234%intf2" -> fe80:2::1234
"fe80::1234"       -> fe80::1234

The last address is simply unscoped and thus cannot be really used for sending out data.

Please note that this is non-standard; inet_pton() does not work that way on Linux or Windows based systems. However, I think even on Linux and Windows based systems, inet_pton() allows a scope ID at the end, it will simply ignore it, though.

For non-link-local address, this trick doesn't work, of course, yet those addresses are usually not scoped. They can be scoped, but usually every interface has an own, unique interface IPv6 address, based on its interface identifier (even if you use DHCPv6, in which case it has a DHCP address assigned by the DHCP server, as well as the auto generated IPv6 interface address, unless this auto generation has been forbidden).

The struct sockaddr_in6 structure has a field for the scope ID but the RFC that defines this field ( RFC 2553 - Section 3.3 ) does not really give much detail how this field is to be interpreted. It only says:

The mapping of sin6_scope_id to an interface or set of interfaces is left to implementation and future specifications on the subject of site identifiers.

So this field is entirely implementation specific.

If you want this field to be filled in correctly, and your code should be as cross-platform as possible, you should use getaddrinfo() :

struct addrinfo hints;
struct addrinfo * result;

memset(&hints, 0, sizeof(hints));
// AI_NUMERICHOST prevents usage of DNS servers,
// it tells getaddrinfo that the input string is a numeric IP address.
hints.flags = AI_NUMERICHOST;
if (getaddrinfo("fe80::1234%intf1", NULL, &hints, &result) == 0) {
    // result->ai_addr claims to be a pointer to struct sockaddr,
    // in fact it will be a pointer to a struct sockaddr_in6 in our case.
    struct sockaddr_in6 * so = (struct sockaddr_in6 *)result->ai_addr;

    // It will be prefilled like this:
    //
    // so->sin6_family   ==> AF_INET6;
    // so->sin6_port     ==> 0
    // so->sin6_flowinfo ==> 0
    // so->sin6_addr     ==> fe80::1234
    // so->sin6_scope_id ==> "intf1" as scope ID

    // Do something with that sockaddr,
    // e.g. set a port number and connect a socket to that address.

    freeaddrinfo(result);
}

One extra tip: If you want to use the returned getaddrinfo() for a server socket (a socket that you want to bind locally and then call accept() on it), you should also set the passive flag:

hints.flags = AI_NUMERICHOST | AI_PASSIVE;

Not that it will play a role in most case but that is the correct way of using getaddrinfo() .

Answer 2

inet_pton() does not support scope IDs. I don't know about other platforms, but on Windows you can use RtlIpv6StringToAddressEx() instead.

Answer 3

inet_pton() semi-supports scope identifiers, the scope is that it will not raise an error when parsing an address with one. The major limitation is that the parameter to the call is a struct in6_addr which does not contain a field for the scope identifier, the super structure struct sockaddr_in6 is required for that.

Easy way forward is to wrap getnameinfo() and getaddrinfo() with struct sockaddr parameters for convenience. For example,

socklen_t
sockaddr_len (
        const struct sockaddr*  sa
        )
{
        socklen_t sa_len;
        switch (sa->sa_family) {
        case AF_INET:   sa_len = sizeof(struct sockaddr_in); break;
        case AF_INET6:  sa_len = sizeof(struct sockaddr_in6); break;
        default:        sa_len = 0; break;
        }
        return sa_len;
}

int
sockaddr_ntop (
        const struct sockaddr* restrict sa,
        char*                  restrict host,
        size_t                          hostlen
        )
{
        return getnameinfo (sa, sockaddr_len (sa),
                            host, hostlen,
                            NULL, 0,
                            NI_NUMERICHOST);
}

int
sockaddr_pton (
        const char*      restrict src,
        struct sockaddr* restrict dst           /* will error on wrong size */
        )
{
        struct addrinfo hints = {
                .ai_family      = AF_UNSPEC,
                .ai_socktype    = SOCK_STREAM,          /* not really */
                .ai_protocol    = IPPROTO_TCP,          /* not really */
                .ai_flags       = AI_NUMERICHOST
        }, *result = NULL;
        const int status = getaddrinfo (src, NULL, &hints, &result);
        if (0 == status) {
                memcpy (dst, result->ai_addr, result->ai_addrlen);
                freeaddrinfo (result);
                return 1;
        }
        return 0;
}

To answer the original premise but given a struct sockaddr , an additional API may be warranted, for example:

uint32_t
sockaddr_scope_id (
        const struct sockaddr*  sa
        )
{
        uint32_t scope_id;
        if (AF_INET6 == sa->sa_family) {
                struct sockaddr_in6 s6;
                memcpy (&s6, sa, sizeof(s6));
                scope_id = s6.sin6_scope_id;
        } else
                scope_id = 0;
        return scope_id;
}