Unix/Linux编程：循环的、无连接(UDP)服务器------TIMF

创建被动套接字

无连接服务器调用函数passiveUDP通过调用passivesock为它所提供的服务创建无连接套接字。如果服务器需要使用熟知服务保留的某个端口，服务器进程就必须有特权。

在Linux中，拥有程序只有作为超级用户程序运行，才能由足够特权绑定到编号小于1000的端口上

为易于测试客户和服务器软件，passivesock通过增加全局整数portbase的内容，重新分配所有的端口值。本质上，所有端口值都重新映射到更高的范围上

在给定计算机上，两个服务器程序不能使用相同的端口号。为了能让程序员能在一台计算机上测试新版的客户-服务器软件，有让现有版本继续执行，可以临时将所有端口号映射到更高的范围上去

使用全局变量提供端口映射使得测试更安全，因为这样可以在不全面修改程序的情况下，同时测试服务器的多个版本

/* passiveUDP.c - passiveUDP */
int	passivesock(const char *service, const char *transport,
		int qlen);
/*------------------------------------------------------------------------
 * passiveUDP - create a passive socket for use in a UDP server
 *------------------------------------------------------------------------
 * Arguments:
 *      service - service associated with the desired port
 */
int passiveUDP(const char *service)
{
	return passivesock(service, "udp", 0);
}

passivesock分配一个数据报或者流套接字，将套机自绑定到服务所用的熟知端口，然后为其调用返回套接字描述符

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

#include <netinet/in.h>

#include <stdlib.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>

#include <netinet/in.h>

#include <stdlib.h>
#include <string.h>
#include <netdb.h>


int errexit(const char *format, ...);
unsigned short	portbase = 0;	/* port base, for non-root servers	*/
/*------------------------------------------------------------------------
 * passivesock - allocate & bind a server socket using TCP or UDP
 *------------------------------------------------------------------------
 * Arguments:
 *      service   - service associated with the desired port
 *      transport - transport protocol to use ("tcp" or "udp")
 *      qlen      - maximum server request queue length
 */
int passivesock(const char *service, const char *transport, int qlen)
{
    struct servent	*pse;	/* pointer to service information entry	*/
    struct protoent *ppe;	/* pointer to protocol information entry*/
    struct sockaddr_in sin;	/* an Internet endpoint address		*/
    int	s, type;	/* socket descriptor and socket type	*/

    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = INADDR_ANY;  // 服务器将在机器上的任一IP地址上接收数据

    /* Map service name to port number */
    if ( pse = getservbyname(service, transport) )
        sin.sin_port = htons(ntohs((unsigned short)pse->s_port)
                             + portbase);
    else if ((sin.sin_port=htons((unsigned short)atoi(service))) == 0)
        errexit("can't get \"%s\" service entry\n", service);

    /* Map protocol name to protocol number */
    if ( (ppe = getprotobyname(transport)) == 0)
        errexit("can't get \"%s\" protocol entry\n", transport);

    /* Use protocol to choose a socket type */
    if (strcmp(transport, "udp") == 0)
        type = SOCK_DGRAM;
    else
        type = SOCK_STREAM;

    /* Allocate a socket */
    s = socket(PF_INET, type, ppe->p_proto);
    if (s < 0)
        errexit("can't create socket: %s\n", strerror(errno));

    /* Bind the socket */
    if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
        errexit("can't bind to %s port: %s\n", service,
                strerror(errno));
    if (type == SOCK_STREAM && listen(s, qlen) < 0)
        errexit("can't listen on %s port: %s\n", service,
                strerror(errno));
    return s;
}

/*------------------------------------------------------------------------
 * errexit - print an error message and exit
 *------------------------------------------------------------------------
 */
int errexit(const char *format, ...)
{
    va_list	args;

    va_start(args, format);
    vfprintf(stderr, format, args);
    va_end(args);
    exit(1);
}

进程结构

循环、无连接服务器是单线程的

单线程服务器永远运行着。它使用一个被动的套接字，该套接字已绑定到所提供服务使用的熟知端口。服务器从套接字获取请求，计算出响应，然后将响应返回给使用相同套接字的客户。服务器把请求中的源地址作为应答中的目的地址

TIME服务实现

客户可以使用TIME服务从另一个系统中的服务器获得当前时间。由于TIME几乎不需要计算，因此可以实现为循环式服务器，如下：

/* UDPtimed.c - main */

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

#include <stdio.h>
#include <time.h>
#include <string.h>
#include <time.h>

int	passiveUDP(const char *service);
int	errexit(const char *format, ...);

#define	UNIXEPOCH	2208988800UL	/* UNIX epoch, in UCT secs	*/

/*------------------------------------------------------------------------
 * main - Iterative UDP server for TIME service
 *------------------------------------------------------------------------
 */
int main(int argc, char *argv[])
{
    struct sockaddr_in fsin;	/* the from address of a client	*/
    char	*service = "time";	/* service name or port number	*/
    char	buf[1];			/* "input" buffer; any size > 0	*/
    int	sock;			/* server socket		*/
    time_t	now;			/* current time			*/
    unsigned int	alen;		/* from-address length		*/

    switch (argc) {
        case	1:
            break;
        case	2:
            service = argv[1];
            break;
        default:
            errexit("usage: UDPtimed [port]\n");
    }

    sock = passiveUDP(service);

    while (1) {
        alen = sizeof(fsin);
        if (recvfrom(sock, buf, sizeof(buf), 0,
                     (struct sockaddr *)&fsin, &alen) < 0)
            errexit("recvfrom: %s\n", strerror(errno));
        (void) time(&now);
        now = htonl((unsigned long)(now + UNIXEPOCH));
        (void) sendto(sock, (char *)&now, sizeof(now), 0,
                      (struct sockaddr *)&fsin, sizeof(fsin));
    }
}

与任何服务器类似，UDPtimed进程必须永远运行着。因此，代码主体含有一个无限的循环，该循环每次接收一个请求，计算当前时间，然后给发送请求的客户返回响应。

代码中有几处细节。分析完参数之后，UDPtimed调用passiveUDP为TIME服务创建一个被动套接字。然后进行循环。TIME协议指明，客户可以发送任意一个数据报作为请求。由于服务器不解释数据报的内容，数据报可以是任何长度、可以含有任意值。本例实现使用recvfrom读取下一个数据报，recvfrom将传入数据报放入缓存buf中，并会将发送数据报的端点地址放到结构fsin中。由于它不必查看数据，因此实现只使用了单个字符的缓冲。如果数据报含有的数据多于一个字节，recvfrom就丢弃所有剩余的字节

UDPtimed使用系统函数time获得当前时间，时间是从1970-1-1零时开始计算。从操作系统获得时间后，UDPtimed必须将它转换为用epoch策略的时间值，并用网络字节序存放结构。为完成转换，它定义了一个常量值UNIXEPOCH，值为因特网起始值与Linux计时起始值相差的秒数。然后sendto将结果传回给客户。sendto使用fsin作为目的地址(即它使用了发送数据报的客户的地址)