Unix Sockets 简明教程

Stream Sockets − Delivery in a networked environment is guaranteed. If you send through the stream socket three items "A, B, C", they will arrive in the same order − "A, B, C". These sockets use TCP (Transmission Control Protocol) for data transmission. If delivery is impossible, the sender receives an error indicator. Data records do not have any boundaries.

Datagram Sockets − Delivery in a networked environment is not guaranteed. They’re connectionless because you don’t need to have an open connection as in Stream Sockets − you build a packet with the destination information and send it out. They use UDP (User Datagram Protocol).

Raw Sockets − These provide users access to the underlying communication protocols, which support socket abstractions. These sockets are normally datagram oriented, though their exact characteristics are dependent on the interface provided by the protocol. Raw sockets are not intended for the general user; they have been provided mainly for those interested in developing new communication protocols, or for gaining access to some of the more cryptic facilities of an existing protocol.

Sequenced Packet Sockets − They are similar to a stream socket, with the exception that record boundaries are preserved. This interface is provided only as a part of the Network Systems (NS) socket abstraction, and is very important in most serious NS applications. Sequenced-packet sockets allow the user to manipulate the Sequence Packet Protocol (SPP) or Internet Datagram Protocol (IDP) headers on a packet or a group of packets, either by writing a prototype header along with whatever data is to be sent, or by specifying a default header to be used with all outgoing data, and allows the user to receive the headers on incoming packets.

Class A addresses begin with 0xxx, or 1 to 126 decimal.

Class B addresses begin with 10xx, or 128 to 191 decimal.

Class C addresses begin with 110x, or 192 to 223 decimal.

Class D addresses begin with 1110, or 224 to 239 decimal.

Class E addresses begin with 1111, or 240 to 254 decimal.

A subnet address within the network address itself; and

A host address on the subnet.

2-tier architecture − In this architecture, the client directly interacts with the server. This type of architecture may have some security holes and performance problems. Internet Explorer and Web Server work on two-tier architecture. Here security problems are resolved using Secure Socket Layer (SSL).

3-tier architectures − In this architecture, one more software sits in between the client and the server. This middle software is called ‘middleware’. Middleware are used to perform all the security checks and load balancing in case of heavy load. A middleware takes all requests from the client and after performing the required authentication, it passes that request to the server. Then the server does the required processing and sends the response back to the middleware and finally the middleware passes this response back to the client. If you want to implement a 3-tier architecture, then you can keep any middleware like Web Logic or WebSphere software in between your Web Server and Web Browser.

Iterative Server − This is the simplest form of server where a server process serves one client and after completing the first request, it takes request from another client. Meanwhile, another client keeps waiting.

Concurrent Servers − This type of server runs multiple concurrent processes to serve many requests at a time because one process may take longer and another client cannot wait for so long. The simplest way to write a concurrent server under Unix is to fork a child process to handle each client separately.

Create a socket with the socket() system call.

Connect the socket to the address of the server using the connect() system call.

Send and receive data. There are a number of ways to do this, but the simplest way is to use the read() and write() system calls.

Create a socket with the socket() system call.

Bind the socket to an address using the bind() system call. For a server socket on the Internet, an address consists of a port number on the host machine.

Listen for connections with the listen() system call.

Accept a connection with the accept() system call. This call typically blocks the connection until a client connects with the server.

Send and receive data using the read() and write() system calls.

struct servent *getservbyname(char *name, char *proto) − This call takes service name and protocol name, and returns the corresponding port number for that service.

struct servent *getservbyport(int port, char *proto) − This call takes port number and protocol name, and returns the corresponding service name.

unsigned short htons(unsigned short hostshort) − This function converts 16-bit (2-byte) quantities from host byte order to network byte order.

unsigned long htonl(unsigned long hostlong) − This function converts 32-bit (4-byte) quantities from host byte order to network byte order.

unsigned short ntohs(unsigned short netshort) − This function converts 16-bit (2-byte) quantities from network byte order to host byte order.

unsigned long ntohl(unsigned long netlong) − This function converts 32-bit quantities from network byte order to host byte order.

The listen function converts an unconnected socket into a passive socket, indicating that the kernel should accept incoming connection requests directed to this socket.

The second argument to this function specifies the maximum number of connections the kernel should queue for this socket.

Put the accept statement and the following code in an infinite loop.

After a connection is established, call fork() to create a new process.

The child process will close sockfd and call doprocessing function, passing the new socket file descriptor as an argument. When the two processes have completed their conversation, as indicated by doprocessing() returning, this process simply exits.

The parent process closes newsockfd. As all of this code is in an infinite loop, it will return to the accept statement to wait for the next connection.

struct servent *getservbyname(char *name, char *proto) − This call takes a service name and a protocol name and returns the corresponding port number for that service.

struct servent *getservbyport(int port, char *proto) − This call takes a port number and a protocol name and returns the corresponding service name.

unsigned short htons (unsigned short hostshort) − This function converts 16-bit (2-byte) quantities from host byte order to network byte order.

unsigned long htonl (unsigned long hostlong) − This function converts 32-bit (4-byte) quantities from host byte order to network byte order.

unsigned short ntohs (unsigned short netshort) − This function converts 16-bit (2-byte) quantities from network byte order to host byte order.

unsigned long ntohl (unsigned long netlong) − This function converts 32-bit quantities from network byte order to host byte order.

int inet_aton (const char *strptr, struct in_addr *addrptr) − This function call converts the specified string, in the Internet standard dot notation, to a network address, and stores the address in the structure provided. The converted address will be in Network Byte Order (bytes ordered from left to right). It returns 1 if the string is valid and 0 on error.

in_addr_t inet_addr (const char *strptr) − This function call converts the specified string, in the Internet standard dot notation, to an integer value suitable for use as an Internet address. The converted address will be in Network Byte Order (bytes ordered from left to right). It returns a 32-bit binary network byte ordered IPv4 address and INADDR_NONE on error.

char *inet_ntoa (struct in_addr inaddr) − This function call converts the specified Internet host address to a string in the Internet standard dot notation.

int socket (int family, int type, int protocol) − This call returns a socket descriptor that you can use in later system calls or it gives you -1 on error.

int connect (int sockfd, struct sockaddr *serv_addr, int addrlen) − The connect function is used by a TCP client to establish a connection with a TCP server. This call returns 0 if it successfully connects to the server, otherwise it returns -1.

int bind(int sockfd, struct sockaddr *my_addr,int addrlen) − The bind function assigns a local protocol address to a socket. This call returns 0 if it successfully binds to the address, otherwise it returns -1.

int listen(int sockfd, int backlog) − The listen function is called only by a TCP server to listen for the client request. This call returns 0 on success, otherwise it returns -1.

int accept (int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen) − The accept function is called by a TCP server to accept client requests and to establish actual connection. This call returns a non-negative descriptor on success, otherwise it returns -1.

int send(int sockfd, const void *msg, int len, int flags) − The send function is used to send data over stream sockets or CONNECTED datagram sockets. This call returns the number of bytes sent out, otherwise it returns -1.

int recv (int sockfd, void *buf, int len, unsigned int flags) − The recv function is used to receive data over stream sockets or CONNECTED datagram sockets. This call returns the number of bytes read into the buffer, otherwise it returns -1 on error.

int sendto (int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen) − The sendto function is used to send data over UNCONNECTED datagram sockets. This call returns the number of bytes sent, otherwise it returns -1 on error.

int recvfrom (int sockfd, void *buf, int len, unsigned int flags struct sockaddr *from, int *fromlen) − The recvfrom function is used to receive data from UNCONNECTED datagram sockets. This call returns the number of bytes read into the buffer, otherwise it returns -1 on error.

int close (int sockfd) − The close function is used to close a communication between the client and the server. This call returns 0 on success, otherwise it returns -1.

int shutdown (int sockfd, int how) − The shutdown function is used to gracefully close a communication between the client and the server. This function gives more control in comparison to close function. It returns 0 on success, -1 otherwise.

int select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout) − This function is used to read or write multiple sockets.

int write (int fildes, const void *buf, int nbyte) − The write function attempts to write nbyte bytes from the buffer pointed to by buf to the file associated with the open file descriptor, fildes. Upon successful completion, write() returns the number of bytes actually written to the file associated with fildes. This number is never greater than nbyte. Otherwise, -1 is returned.

int read (int fildes, const void *buf, int nbyte) − The read function attempts to read nbyte bytes from the file associated with the open file descriptor, fildes, into the buffer pointed to by buf. Upon successful completion, write() returns the number of bytes actually written to the file associated with fildes. This number is never greater than nbyte. Otherwise, -1 is returned.

int fork (void) − The fork function creates a new process. The new process, called the child process, will be an exact copy of the calling process (parent process).

void bzero (void *s, int nbyte) − The bzero function places nbyte null bytes in the string s. This function will be used to set all the socket structures with null values.

int bcmp (const void *s1, const void *s2, int nbyte) − The bcmp function compares the byte string s1 against the byte string s2. Both the strings are assumed to be nbyte bytes long.

void bcopy (const void *s1, void *s2, int nbyte) − The bcopy function copies nbyte bytes from the string s1 to the string s2. Overlapping strings are handled correctly.

void *memset(void *s, int c, int nbyte) − The memset function is also used to set structure variables in the same way as bzero.