Linux系统下socket编程socket接口介绍（二）

   #include <sys/types.h>
   #include <sys/socket.h>

   ssize_t send(int sockfd, const void *buf, size_t len, int flags);

   #include <sys/types.h>
   #include <sys/socket.h>

   ssize_t recv(int sockfd, void *buf, size_t len, int flags);

   #include <sys/socket.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>

   int inet_aton(const char *cp, struct in_addr *inp);

   in_addr_t inet_addr(const char *cp);

   in_addr_t inet_network(const char *cp);

   char *inet_ntoa(struct in_addr in);

   struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host);

   in_addr_t inet_lnaof(struct in_addr in);

   in_addr_t inet_netof(struct in_addr in);

 inet_aton()  converts  the  Internet  
host  address  cp  from  the  IPv4  
numbers-and-dots notation into binary 
form (in network byte order) and stores it in the 
 structure that inp points to.
   inet_aton() returns nonzero if the address is valid, 
   zero if not.  The address 
 supplied in cp can have one of the following forms:

   a.b.c.d   Each of the four numeric parts specifies a 
  byte of the address; the 
 bytes are assigned in left-to-right order to produce the binary address.

   a.b.c     Parts a and b specify the first two bytes of the binary address.  Part c is interpreted as a 16-bit value that defines the rightmost two bytes of the binary address.  This  notation
             is suitable for specifying (outmoded) Class B network addresses.

   a.b       Part a specifies the first byte of the binary address.  Part b is 
  interpreted as a 24-bit value that defines the
  rightmost three bytes of the binary address.  This notation is suit‐
             able for specifying (outmoded) Class A network addresses.

   a         The value a is interpreted as a 32-bit value that is stored 
   directly into the binary address without any byte rearrangement.

   In all of the above forms, components of the dotted address can be specified
    in decimal, octal (with a leading 0), or hexadecimal, with a leading 0X). 
    Addresses in any  of  these  forms  are
   collectively termed IPV4 numbers-and-dots notation.  The form that uses exactly
    four decimal numbers is referred to as IPv4 dotted-decimal notation (or sometimes: IPv4 dotted-quad notation).

   inet_aton() returns 1 if the supplied string was successfully interpreted, 
  or 0 if the string is invalid (errno is not set on error).

   The  inet_addr()  function converts the Internet 
   host address cp from IPv4 numbers-and-dots notation into 
   binary data in network byte order.  
   If the input is invalid, INADDR_NONE (usually -1)
   is returned.  
   Use of this function is problematic because -1 is a 
  valid address (255.255.255.255). 
   Avoid its use in favor of inet_aton(), inet_pton(3), 
   or  getaddrinfo(3),  which  provide  a
   cleaner way to indicate error return.

 The inet_ntoa() function converts the Internet host 
 address in, given in network byte order, to a string in 
 IPv4 dotted-decimal notation.  The string is returned  
 in  a  statically  allocated
   buffer, which subsequent calls will overwrite.

  #include <arpa/inet.h>

   const char *inet_ntop(int af, const void *src,  char *dst, socklen_t size);

   This  function  converts  the  network address 
   structure src in the af address family into a 
   character string.  The resulting string is copied to 
   the buffer pointed to by dst, which must be a
   non-null pointer.  The caller specifies the number of 
   bytes available in this buffer in the argument size.

   inet_ntop() extends the inet_ntoa(3) function to 
   support multiple address families, inet_ntoa(3) is 
   now considered to be deprecated in favor of 
   inet_ntop().  The  following  address  families
   are currently supported:

   AF_INET
          src  points  to a struct in_addr (in network 
   byte order) which is converted to an IPv4 network 
  address in the dotted-decimal format, 
  "ddd.ddd.ddd.ddd".  The buffer dst must be at least
          INET_ADDRSTRLEN bytes long.

   AF_INET6
          src points to a struct in6_addr (in network 
   byte order) which is converted to a representation of 
   this address in the most appropriate IPv6 network 
   address  format  for  this  address.
          The buffer dst must be at least 
 INET6_ADDRSTRLEN bytes long.

 RETURN VALUE
   On success, inet_ntop() returns a non-null pointer to 
  dst.  NULL is returned if there was an error, with 
  errno set to indicate the error.

ERRORS
   EAFNOSUPPORT
          af was not a valid address family.

   ENOSPC The converted address string would exceed the 
   size given by size.

  #include <arpa/inet.h>

   int inet_pton(int af, const char *src, void *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:

          1. 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).

          2. 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 ::.

          3. 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 
 xs are hexadecimal values that define
             the six most-significant 16-bit pieces of 
 the address (i.e., 96 bits), and the ds 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.

(4)struct in_addr
    {
       in_addr_t s_addr;
    };
(5)struct sockaddr_in
 {
     __SOCKADDR_COMMON (sin_);
     in_port_t   sin_port;                 /* Port number.  */
    struct in_addr sin_addr;            /* Internet address.  */

/* Pad to size of `struct sockaddr'.  */
    unsigned char sin_zero[sizeof (struct sockaddr) -
                       __SOCKADDR_COMMON_SIZE -
                       sizeof (in_port_t) -
                       sizeof (struct in_addr)];
   };