# inet_pton

## NAME



           inet_pton - convert IPv4 and IPv6 addresses from text to binary
           form
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <arpa/inet.h>**
    
           **int inet_pton(int** _af_**, const char *restrict** _src_**, void *restrict** _dst_**);**
    


## DESCRIPTION



           This function converts the character string _src_ into a network
           address structure in the _af_ address family, then copies the
           network address structure to _dst_.  The _af_ argument must be either
           **AF_INET** or **AF_INET6**.  _dst_ is written in network byte order.
    
           The following address families are currently supported:
    
           **AF_INET**
                  _src_ points to a character string containing an IPv4 network
                  address in dotted-decimal format, "_ddd.ddd.ddd.ddd_ ", where
                  _ddd_ is a decimal number of up to three digits in the range
                  0 to 255.  The address is converted to a _struct in_addr_ and
                  copied to _dst_ , which must be _sizeof(struct in_addr)_ (4)
                  bytes (32 bits) long.
    
           **AF_INET6**
                  _src_ points to a character string containing an IPv6 network
                  address.  The address is converted to a _struct in6_addr_ and
                  copied to _dst_ , which must be _sizeof(struct in6_addr)_ (16)
                  bytes (128 bits) long.  The allowed formats for IPv6
                  addresses follow these rules:
    
                  •  The preferred format is _x:x:x:x:x:x:x:x_.  This form
                     consists of eight hexadecimal numbers, each of which
                     expresses a 16-bit value (i.e., each _x_ can be up to 4
                     hex digits).
    
                  •  A series of contiguous zero values in the preferred
                     format can be abbreviated to _::_.  Only one instance of
                     _::_ can occur in an address.  For example, the loopback
                     address _0:0:0:0:0:0:0:1_ can be abbreviated as _::1_.  The
                     wildcard address, consisting of all zeros, can be
                     written as _::_.
    
                  •  An alternate format is useful for expressing IPv4-mapped
                     IPv6 addresses.  This form is written as
                     _x:x:x:x:x:x:d.d.d.d_ , where the six leading _x_ s are
                     hexadecimal values that define the six most-significant
                     16-bit pieces of the address (i.e., 96 bits), and the _d_ s
                     express a value in dotted-decimal notation that defines
                     the least significant 32 bits of the address.  An
                     example of such an address is _::FFFF:204.152.189.116_.
    
                  See RFC 2373 for further details on the representation of
                  IPv6 addresses.
    


## RETURN VALUE



           **inet_pton**() returns 1 on success (network address was successfully
           converted).  0 is returned if _src_ does not contain a character
           string representing a valid network address in the specified
           address family.  If _af_ does not contain a valid address family, -1
           is returned and _errno_ is set to **EAFNOSUPPORT**.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌───────────────────────────────┬───────────────┬────────────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├───────────────────────────────┼───────────────┼────────────────┤
           │ **inet_pton**()                   │ Thread safety │ MT-Safe locale │
           └───────────────────────────────┴───────────────┴────────────────┘
    


## VERSIONS



           Unlike inet_aton(3) and inet_addr(3), **inet_pton**() supports IPv6
           addresses.  On the other hand, **inet_pton**() accepts only IPv4
           addresses in dotted-decimal notation, whereas inet_aton(3) and
           inet_addr(3) allow the more general numbers-and-dots notation
           (hexadecimal and octal number formats, and formats that don't
           require all four bytes to be explicitly written).  For an
           interface that handles both IPv6 addresses, and IPv4 addresses in
           numbers-and-dots notation, see getaddrinfo(3).
    


## STANDARDS



           POSIX.1-2008.
    


## BUGS



           **AF_INET6** does not recognize IPv4 addresses.  An explicit
           IPv4-mapped IPv6 address must be supplied in _src_ instead.
    


## EXAMPLES



           The program below demonstrates the use of **inet_pton**() and
           inet_ntop(3).  Here are some example runs:
    
               $ **./a.out i6 0:0:0:0:0:0:0:0**
               ::
               $ **./a.out i6 1:0:0:0:0:0:0:8**
               1::8
               $ **./a.out i6 0:0:0:0:0:FFFF:204.152.189.116**
               ::ffff:204.152.189.116
    
       **Program source**
    
           #include <arpa/inet.h>
           #include <stdio.h>
           #include <stdlib.h>
           #include <string.h>
    
           int
           main(int argc, char *argv[])
           {
               unsigned char buf[sizeof(struct in6_addr)];
               int domain, s;
               char str[INET6_ADDRSTRLEN];
    
               if (argc != 3) {
                   fprintf(stderr, "Usage: %s {i4|i6|<num>} string\n", argv[0]);
                   exit(EXIT_FAILURE);
               }
    
               domain = (strcmp(argv[1], "i4") == 0) ? AF_INET :
                        (strcmp(argv[1], "i6") == 0) ? AF_INET6 : atoi(argv[1]);
    
               s = inet_pton(domain, argv[2], buf);
               if (s <= 0) {
                   if (s == 0)
                       fprintf(stderr, "Not in presentation format");
                   else
                       perror("inet_pton");
                   exit(EXIT_FAILURE);
               }
    
               if (inet_ntop(domain, buf, str, INET6_ADDRSTRLEN) == NULL) {
                   perror("inet_ntop");
                   exit(EXIT_FAILURE);
               }
    
               printf("%s\n", str);
    
               exit(EXIT_SUCCESS);
           }
    


* * *