linux网络编程之bind函数

NAME

    bind - bind a name to a socket

SYNOPSIS

    #include <sys/socket.h>

    int bind(int socket, const struct sockaddr *address,
           socklen_t address_len);

DESCRIPTION

    The bind() function shall assign a local socket address address to a socket identified by descriptor socket that has no local socket address assigned. Sockets created with the socket() function are initially unnamed; they are identified only by their address family.

    The bind() function takes the following arguments:

    socket
        Specifies the file descriptor of the socket to be bound.
    address
        Points to a sockaddr structure containing the address to be bound to the socket. The length and format of the address depend on the address family of the socket.
    address_len
        Specifies the length of the sockaddr structure pointed to by the address argument.

    The socket specified by socket may require the process to have appropriate privileges to use the bind() function.

RETURN VALUE

    Upon successful completion, bind() shall return 0; otherwise, -1 shall be returned and errno set to indicate the error.




bind — Bind a local name to the socket

The bind socket function binds a unique local name to the socket with descriptor s.
 
Format

#include <sys/socket.h>
int      bind(int s,
              struct sockaddr *name,
              int namelen);

s
    The socket descriptor.
name
    Pointer to a sockaddr structure (buffer) containing the name that is to be bound to s.
namelen
    Size of the buffer pointed to by name, in bytes.

Normal return

Return code 0 indicates that the function was successful.

Error return

The return code -1 indicates an error. You can get the specific error code by calling sock_errno.


Programming considerations

    The bind function binds a unique local name to the socket with descriptor s. After calling socket, a descriptor does not have a name associated with it. The bind procedure also allows servers to specify from which network interfaces they want to receive UDP packets and TCP connection requests.
    The binding of a stream socket is not complete until a successful call to bind, listen, or connect is made. Applications using stream sockets must check the return values of bind, listen, and connect before using any function that requires a bound stream socket.
    When binding a socket to all local IP addresses (that is, INADDR_ANY is specified), the socket is bound to all IP interfaces that are currently active, as well as to any IP interfaces that are subsequently activated.

Examples

    Bind to a specific interface in the internet domain and make sure the sin_zero field is cleared:

    #include <sys/socket.h>
   
    int rc;
    int s;
    struct sockaddr_in myname;
   
    memset(&myname, 0, sizeof(myname));
    myname.sin_family      = AF_INET;
    myname.sin_port        = 5001;
    myname.sin_addr.s_addr = inetaddr("129.5.24.1"); /*specific interface*/
    rc = bind(s, (struct sockaddr *) &myname, sizeof(myname));

    Bind to all network interfaces in the internet domain.

    memset(&myname, 0, sizeof(myname));
    myname.sin_family      = AF_INET;
    myname.sin_port        = 5001;
    myname.sin_addr.s_addr = INADDR_ANY; /* all interfaces */
    rc = bind(s, (struct sockaddr *) &myname, sizeof(myname));

    Bind to a specific interface in the internet domain and let the system choose a port.

    memset(&myname, 0, sizeof(myname));
    myname.sin_family      = AF_INET;
    myname.sin_port        = INADDR_ANY;
    myname.sin_addr.s_addr = inetaddr("129.5.24.1"); /*specific interface*/
    rc = bind(s, (struct sockaddr *) &myname, sizeof(myname));




bind


Assigns a Name to a Socket



SYNOPSIS

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

int bind(int s, const void *addr, int addrlen);

DESCRIPTION

bind assigns a name to an unnamed socket s . When a socket is created, it exists in an address family, but it does not have a name assigned to it. Servers use bind to associate themselves with a well-known port. Servers may also use bind to restrict access by other network addresses on a host with multiple network addresses. bind enables a connectionless client to have an address that the server can use for responses.

For addresses in the AF_INET family, addr points to a sockaddr or sockaddr_in structure. addrlen is the length of the address, in bytes. addrlen should be greater than or equal to the size of the sockaddr or sockaddr_in structure. The INADDR_ANY constant in the <netinet/in.h> header file specifies that the network address is not restricted. If the sin_port field of the sockaddr structure is zero, bind chooses a port. Alternatively, a well-known port number can be passed in the sin_port field. Internet host addresses and port numbers in sockaddr_in are always in network byte order. The remainder of the sockaddr or sockaddr_in structure should be 0 .

Upon return, if a port of 0 was specified, the selected port value is filled in. On return, the structure pointed to by addr should be the same as the structure pointed to by getsockname for this socket s .

RETURN VALUE

If bind is successful, it returns a 0 ; otherwise, it returns a -1 and sets errno to indicate the type of error.

PORTABILITY

bind is portable to other environments, including most UNIX systems, that implement BSD sockets.

EXAMPLE

In this example, bind assigns socket s to an arbitrary port without restriction by network address.

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>
f()
{
   struct sockaddr_in sa;
   int s;
   struct servent *serv;
   .
   .
   .
      /* Specify the port. */
   memset(&sa,'\0',sizeof(sa));
   sa.sin_family = AF_INET;
   sa.sin_addr.s_addr = INADDR_ANY;
   sa.sin_port = serv->s_port;
   if (bind(s, &sa, sizeof(sa)) == -1) {
      perror("bind() failed");
      return -1;
   }
   .
   .
   .
      /* Let TCP/IP choose the port. */
   memset(&sa,'\0',sizeof(sa));
   sa.sin_family = AF_INET;
   sa.sin_addr.s_addr = INADDR_ANY;
   sa.sin_port = 0;
   if (bind(s, &sa, sizeof(sa)) == -1) {
      perror("bind() failed");
      return -1;
   }
   .
   .
   .
}







NAME

       bind - bind a name to a socket

SYNOPSIS

       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int bind(int sockfd, const struct sockaddr *addr,
                socklen_t addrlen);

DESCRIPTION

       When  a  socket  is  created  with socket, it exists in a name space
       (address family) but has no address assigned to it.  bind() assigns the
       address  specified  to  by  addr  to the socket referred to by the file
       descriptor sockfd.  addrlen  specifies  the  size,  in  bytes,  of  the
       address structure pointed to by addr.  Traditionally, this operation is
       called “assigning a name to a socket”.

       It is normally necessary to assign a local address using bind()  before
       a SOCK_STREAM socket may receive connections.

       

       The  actual  structure  passed for the addr argument will depend on the
       address family.  The sockaddr structure is defined as something like:

           struct sockaddr {
               sa_family_t sa_family;
               char        sa_data[14];
           }

       The only purpose of this structure is to  cast  the  structure  pointer
       passed in addr in order to avoid compiler warnings.  See EXAMPLE below.

RETURN VALUE

       On success, zero is returned.  On error, -1 is returned, and  errno  is
       set appropriately.
 

EXAMPLE

      

       The following example shows how to bind a stream  socket  in  the  Unix
       (AF_UNIX) domain, and accept connections:

       #include <sys/socket.h>
       #include <sys/un.h>
       #include <stdlib.h>
       #include <stdio.h>
       #include <string.h>

       #define MY_SOCK_PATH "/somepath"
       #define LISTEN_BACKLOG 50

       #define handle_error(msg) \
           do { perror(msg); exit(EXIT_FAILURE); } while (0)

       int
       main(int argc, char *argv[])
       {
           int sfd, cfd;
           struct sockaddr_un my_addr, peer_addr;
           socklen_t peer_addr_size;

           sfd = socket(AF_UNIX, SOCK_STREAM, 0);
           if (sfd == -1)
               handle_error("socket");

           memset(&my_addr, 0, sizeof(struct sockaddr_un));
                               /* Clear structure */
           my_addr.sun_family = AF_UNIX;
           strncpy(my_addr.sun_path, MY_SOCK_PATH,
                   sizeof(my_addr.sun_path) - 1);

           if (bind(sfd, (struct sockaddr *) &my_addr,
                   sizeof(struct sockaddr_un)) == -1)
               handle_error("bind");

           if (listen(sfd, LISTEN_BACKLOG) == -1)
               handle_error("listen");

           /* Now we can accept incoming connections one
              at a time using accept(2) */

           peer_addr_size = sizeof(struct sockaddr_un);
           cfd = accept(sfd, (struct sockaddr *) &peer_addr,
                        &peer_addr_size);
           if (cfd == -1)
               handle_error("accept");

           /* Code to deal with incoming connection(s)... */

           /* When no longer required, the socket pathname, MY_SOCK_PATH
              should be deleted using unlink(2) or remove(3) */
       }