Berkeley sockets (also known as the BSD socket API) originated with the 4.2BSD Unix operating system (released in 1983) as an API. Only in 1989, however, could UC Berkeley release versions of its operating system and networking library free from the licensing constraints of AT&T's copyright-protected Unix.
The STREAMS-based Transport Layer Interface (TLI) API offers an alternative to the socket API. However, the Berkeley socket API predominates convincingly in popularity and in the number of implementations.
Programmers can make the socket interfaces accessible at three different levels, most powerfully and fundamentally at the raw socket level. Very few applications need the degree of control over outgoing communications that this provides, so raw sockets support was intended to be available only on computers used for developing Internet-related technologies. In recent years, most operating systems have implemented support for it anyway, including Windows XP.
socket()function with the parameters
bind(). Before calling
bind(), a programmer must declare a
sockaddr_instructure, clear it (with
memset()), and the
PF_INET6), and fill its
sin_port(the listening port, in network byte order) fields. Converting a
short intto network byte order can be done by calling the function
htons()(host to network short).
accept(). This blocks until an incoming connection is received, and then returns a socket descriptor for the accepted connection. The initial descriptor remains a listening descriptor, and
accept()can be called again at any time with this socket, until it is closed.
close(). Note that if there were any calls to
fork(), each process must close the sockets it knew about (the kernel keeps track of how many processes have a descriptor open), and two processes should not use the same socket at once.
connect(), passing a
sockaddr_instructure with the
sin_portset to the port the endpoint is listening (in network byte order), and
sin_addrset to the IPv4 or IPv6 address of the listening server (also in network byte order.)
close(). Again, if there were any calls to
fork(), each process must
UDP address space, the space of UDP port numbers (in ISO terminology, the TSAPs), is completely disjoint from that of TCP ports.
Code may set up a UDP server on port 7654 as follows:
bind() binds the socket to an address/port pair.
This infinite loop receives any UDP datagrams to port 7654 using recvfrom(). It uses the parameters:
A simple demo to send a UDP packet containing "Hello World!" to address 127.0.0.1, port 7654 might look like this:
In this code,
buffer provides a pointer to the data to send, and
buffer_length specifies the size of the buffer contents.
socket()creates an endpoint for communication and returns a descriptor.
socket()takes three arguments:
SOCK_STREAM(reliable stream-oriented service or Stream Sockets)
SOCK_DGRAM(datagram service or Datagram Sockets)
SOCK_SEQPACKET(reliable sequenced packet service), or
SOCK_RAW(raw protocols atop the network layer).
IPPROTO_IP, which is defined as 0, to represent the default transport protocol for the specified domain and type values (TCP for
SOCK_STREAM, UDP for those
SOCK_DGRAM), but which can also explicitly specify a protocol. These protocols are specified in
The function returns -1 if an error occurred. Otherwise, it returns an integer representing the newly-assigned descriptor.
gethostbyaddr() functions each return a pointer to an object of type struct hostent, which describes an internet host referenced by name or by address, respectively. This structure contains either the information obtained from a name server (ex: named), or broken-out fields from a line in /etc/hosts. If the local name server is not running these routines do a lookup in /etc/hosts. The functions take the following arguments:
The functions return a NULL pointer in case of error, in which case the external integer h_errno may be checked so see whether this is a temporary failure or an invalid or unknown host. Otherwise a valid struct hostent * is returned.
It returns an integer representing the error code: 0 represents success, while -1 represents an error.
Certain types of sockets are connectionless, most commonly user datagram protocol sockets. For these sockets, connect takes on a special meaning: the default target for sending and receiving data gets set to the given address, allowing the use of functions such as send() and recv() on connectionless sockets.
bind() assigns a socket an address. When a socket is created using
socket(), it is given an address family, but not assigned an address. Before a socket may accept incoming connections, it must be bound.
bind() takes three arguments:
sockfd, a descriptor representing the socket to perform the bind on
serv_addr, a pointer to a
sockaddrstructure representing the address to bind to.
socklen_tfield representing the length of the
It returns 0 on success and -1 if an error occurs.
listen() prepares a bound socket to accept incoming connections. This function is only applicable to the
SOCK_SEQPACKET socket types. It takes two arguments:
sockfd, a valid socket descriptor.
backlog, an integer representing the number of pending connections that can be queued up at any one time. The operating system usually places a cap on this value.
Once a connection is accepted, it is dequeued. On success, 0 is returned. If an error occurs, -1 is returned.
accept()is used to accept a connection request from a remote host. It takes the following arguments:
sockfd, the descriptor of the listening socket to accept the connection from.
cliaddr, a pointer to the sockaddr structure that
accept()should put the client's address information into.
addrlen, a pointer to the
socklen_tinteger that will indicate to
accept()how large the sockaddr structure pointed to by
socklen_tinteger then indicates how many bytes of the
cliaddrstructure were actually used.
The function returns a socket corresponding to the accepted connection, or -1 if an error occurs.
Berkeley sockets can operate in one of two modes: blocking or non-blocking. A blocking socket will not return control until it has sent (or received) all the data specified for the operation. This is true only in Linux systems. In other systems, such as FreeBSD, it is normal for a blocking socket not to send all the data. Always check the return value to find out how many bytes have been sent/received. It’s up to you to send the rest of the string It also may cause problems if a socket continues to listen: a program may hang as the socket waits for data that may never arrive.
A socket is typically set to blocking or nonblocking mode using the
The system will not release the resources allocated by the When an issue to the
Information about this standard and ongoing work on it is available from the Austin website The IPv6 extensions to the base socket API are documented in RFC 3493 and RFC 3542.
socket() call until a
close() call occurs. This is especially important if the
connect() call fails and may be retried. Each call to
socket() must have a matching call to
close() in all possible execution paths. Include
close() system call is made only the interface to the socket gets closed, not the socket itself. It is up to the kernel to close the socket. Sometimes, the socket may go into a
TIME_WAIT state, on the server side, for up to 4 minutes.
The "de jure" standard definition of the Sockets interface is contained in the POSIX standard, known as:
When an issue to the
Information about this standard and ongoing work on it is available from the Austin website
The IPv6 extensions to the base socket API are documented in RFC 3493 and RFC 3542.