|
The Berkeley sockets application programming interface (API) comprises a library for developing applications in the C programming language that perform inter-process communication, most commonly across a computer network. 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 Berkeley socket API forms the de facto standard abstraction for network sockets. Most other programing languages use an interface similar to the C API. 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. Berkeley socket interface The Berkeley socket interface, an API, allows communications between hosts or between processes on one computer, using the concept of a socket. It can work with many different I/O devices and drivers, although support for these depends on the operating-system implementation. This interface implementation is implicit for TCP/IP, and it is therefore one of the fundamental technologies underlying the Internet. It was first developed at the University of California, Berkeley for use on Unix systems. All modern operating systems now have some implementation of the Berkeley socket interface, as it has become the standard interface for connecting to the Internet. 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. The header files The Berkeley socket development library has many associated header files. They include:Core BSD socket functions and data structures. AF_INET and AF_INET6 address families. Widely used on the Internet, these include IP addresses and TCP and UDP port numbers. AF_UNIX address family. Used for local communication between programs running on the same computer. Not used on networks. Functions for manipulating numeric IP addresses. Functions for translating protocol names and host names into numeric addresses. Searches local data as well as DNS. TCP TCP provides the concept of a connection. A process creates a TCP socket by calling the socket() function with the parameters PF_INET or PF_INET6 and SOCK_STREAM.Server Setting up a simple TCP server involves the following steps: socket().bind(). Before calling bind(), a programmer must declare a sockaddr_in structure, clear it (with bzero() or memset()), and the sin_family (AF_INET or AF_INET6), and fill its sin_port (the listening port, in network byte order) fields. Converting a short int to network byte order can be done by calling the function htons() (host to network short).listen().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.send() and recv().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.Client Setting up a TCP client involves the following steps: socket().connect, passing a sockaddr_in structure with the sin_family set to AF_INET or AF_INET6, sin_port set to the port the endpoint is listening (in network byte order), and sin_addr set to the IPv4 or IPv6 address of the listening server (also in network byte order.)send()ing and recv()ing.close(). Again, if there were any calls to fork(), each process must close() the socket.UDP UDP consists of a connectionless protocol with no guarantee of delivery. UDP packets may arrive out of order, become duplicated and arrive more than once, or even not arrive at all. Due to the minimal guarantees involved, UDP has considerably less overhead than TCP. Being connectionless means that there is no concept of a stream or connection between two hosts, instead, data arrives in datagrams. UDP address space, the space of UDP port numbers (in ISO terminology, the TSAPs), is completely disjoint from that of TCP ports. Server Code may set up a UDP server on port 7654 as follows: sock = socket(PF_INET,SOCK_DGRAM,IPPROTO_IP); sa.sin_addr.s_addr = INADDR_ANY; sa.sin_port = htons(7654); bound = bind(sock,(struct sockaddr fprintf(stderr, "bind(): %s ",strerror(errno)); bind() binds the socket to an address/port pair. while (1) This infinite loop receives any UDP datagrams to port 7654 using recvfrom(). It uses the parameters: Client A simple demo to send a UDP packet containing "Hello World!" to address 127.0.0.1, port 7654 might look like this: int main(int argc, char In this code, buffer provides a pointer to the data to send, and buffer_length specifies the size of the buffer contents.socket() socket() creates an endpoint for communication and returns a descriptor. socket() takes three arguments:PF_INET for network protocol IPv4 or PF_INET6 for IPv6).SOCK_STREAM (reliable stream-oriented service)SOCK_DGRAM (datagram service)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 PF_INET or PF_INET6 and SOCK_STREAM, UDP for those PF_ values and 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. Prototype: int socket(int domain, int type, int protocol);gethostbyname() and gethostbyaddr() The gethostbyname() and 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 Prototypes: struct hostent
struct hostent
connect() connect()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. Prototype: int connect(int sockfd, const struct sockaddr
bind() 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 onmy_addr, a pointer to a sockaddr structure representing the address to bind to.addrlen, a socklen_t field representing the length of the sockaddr structure.Prototype: int bind(int sockfd, struct sockaddr
listen() listen() prepares a bound socket to accept incoming connections. This function is only applicable to the SOCK_STREAM and 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.Prototype: int listen(int sockfd, int backlog);accept() 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_t integer that will indicate to accept() how large the sockaddr structure pointed to by cliaddr is. When accept() returns, the socklen_t integer then indicates how many bytes of the cliaddr structure were actually used.The function returns a socket corresponding to the accepted connection, or -1 if an error occurs. Prototype: int accept(int sockfd, struct sockaddr
Blocking vs. nonblocking Berkeley sockets can operate in one of two modes: blocking or non-blocking. A blocking socket will not "return" until it has sent (or received) all the data specified for the operation. This 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 fcntl() or ioctl() functions.Cleaning up The system will not release the resources allocated by the 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 See also | |||||||
|
| ||||||||
 |
|
| |