1.     【说明】
    幼儿园有n(&lt20)个孩子围成一圈分糖果。老师先随机地发给每个孩子若干颗糖果，
    然后按以下规则调整：每个孩子同时将自己手中的糖果分一半给坐在他右边的小朋友。如共有8个孩子，则第1个将原有的一半分给第2个，第2个将原有的一半分给第3个，……，第8个将原有的一半分给第1个，这样的平分动作同时进行。若平分前，某个孩子手中的糖果是奇数颗，则必须从老师那里要一颗，使他的糖果数变成偶数。小孩人数和每个小孩的初始糖果数由键盘输入。下面的程序可求出经过多少次上述这样的调整，使每个孩子手中的糖果—样多，调整结束时每个孩子有糖果多少颗，在调整过程中老师又新增发了多少颗糖果。
    【程序】
    #include &ltstdio.h＞
    #define N 20
    int allEqual (int a[  ]，int n) /*检查每个孩子手中的糖果是否一样多*/
    {  iht i;
        for(i=1; i＜n; i++)
            if(a[O]!=a[i]) return O;
        return 1;
}
    int a[N], b[N];
    void main (  )
    {  int i, n, addk, loopc;
    printf("Enter n((20)\n"); scanf("%d", &ampn);
    printf ("Enter data\n");
    for( i=O; i(n; i++) scanf("%d", &ampa[i]);
    addk=O;     ;
    while     { /*平分循环*/
    loopc++;
    for ( i=O; i ( n; i++){ /*为一次调整作准备*/
        if(a[i]%2) { a[i]++;     ; }
        if (i＜n-1) b[i+1]=a[i]/2; else   
        a[i]/=2;
        }
    for(i=O; i＜n; i++)    ; /*完成一次调整*/
      }
    printf("调整%d次\n", loopc); printf("每个孩子有%d颗糖果\n", a[0]);
    printf("调整过程中新增发%d颗糖果。\n", addk); }

1.     /*simple ping program*/
    struct sockaddr_in saddr;
    int rawsock;
    unsigned short in_cksum(unsigned short*addr, int len)
    {  int sum=0;
        unsigned short res=0;
        while(1en＞1){
        sum+=*addr++; len-=2;
          }
            if(len=1){
        *((unsigned char *)(&res))=*((unsigned char *)addr); sum+=res;
        }
        sum=(sum＞＞16)+(sam & 0xffff);
        sum+=(sum＞＞16); res=～sum;
        return res;
      }
    void ping(int signo)
    {
    int len;
    int i;
    static unsigned short seq=0;
    char buff[8192];
    struct timeval tv;
    struet icmp*icmph=(struct icmp * )buff;
    long*data=(long*)icmph→icmp_data;
    bzero(buff, 8192);
    gettimeofday(&tv, NULL);
    icmph→icmp_type=ICMP_ECHO;
    icmph→icmp_code=0;
    icmph→icmp_cksum=0;
    icmph→icmp_id=0;
    icmph→icmp_seq=0;
    icmph→icmp_id=getpid()&0xffff;
    icmph→icmp_seq=seq++;
    data[0]=tv.tv_sec;
    data[1]=tv.tv_usec;
    for(i=8; i＜ ; i++)
    icmph→icmp_data[i]=(unsigned char)i;
    icmph→icmp_cksum=in_cksum((unsigned short *)buff, ? 72);
    len; sendto(rawsock, buff, 72, 0, &saddr, sizeof(saddr));
    alarm    ;
    }
    void sigint(int signo)
    {  printf("CATCH SIGINT !!! \n");
        close(rawsock);
        exit(0);
    }
    void dumppkt(char*buf, int len)
    {  struct ip*iph=(struct ip*)buf;
        int i=iph→ip_h1*4;
        struct icmp*icmph=(struct icmp*)&buf[i];
        long*data=(long*)iemph→icmp_data;
        struct timeval tv;
        gettimeofday(&tv, NULL);
        if(icmph→icmp_type! =ICMP_ECHOREPLY)
        return;
        if(icmph→icmp_id! =(getpid()&0xffff))
        return;
        printf("From %s:ttl=% d seq=% d time=%.2f ms\n",
        inet_ntoa(iph→ip_src)，iph→ip_ttl?,
        icmph→icmp_seq,
        (tv.tv_see-data[0])*1000.0+(tv.tv_usec-data[0])/1000.0)；
    }
    int main(int argc, char*argv[])
    {  int len;
        stuct timeval now;
        char recvbuff[8192];
        if    {
        printf("%s aaa.bbb.ccc.ddd\n", argv[0]);
        exit    ;
        }
    rawsock=soeket(AF_INET,     , IPPROTO_ICMP);
    if(rawsock＜0) {
    perror("soeket");
    exit    ;
    }
    bzero ( &saddr, sizeof(saddr));
    saddr.sin_family=    ;
    if( inet_aton( argv[1], &saddr.sin_addr) ＜0) {
    printf("invalid IP address: %s\n", argv[1]);
    exit    ;
    }
    signal(SICALRM, ping);
    signal(SICINT, sigint);
    alarm    ;
    while     {
    len=read     , recvbuff, 8192);
    if( len＜0 && errno=EINTR)
    continue;
    else it( len＜0)
    perror("read");
    else if( len＞0)
    dumppkt(recvbuff, len);
      }
    close     ;
    exit(0);
      }

1.     网络应用的基本模型是客户机/服务器模型，这是一个不对称的编程模型，通信的双方扮演不同的角色：客户机和服务器。本题中的程序，客户机接收用户在键盘上输入的文字内容，服务器将客户机发送来的文字内容直接返回给客户机。
    此程序中，用户自定义函数有：
    int read_all( int fd, void*buf, int nbyte );
    函数read all从参数fd指定的套接字描述符中读取nbytes字节数据至缓冲区buf中，成功返回实际读的字节数(可能小于nbyte)，失败返回-1。
    int write_all( int fd, void*buf, int nbyte );
    函数write_all向参数fd指定的套接字描述符中写入缓冲区buf前nbyte字节的数据，成功返回实际写的字节数(始终等于nbyte)，失败返回-1。
    write_requ函数为客户机发送请求的函数；read_requ函数为服务器获取请求的函数
    服务器主程序部分：
    #define SERVER_PORT 8080    //服务器监听端口号为8080
    #define BACKLOG 5    //连接请求队列长度
    int main( int argc, char*argv[]) {
    int listenfd, connfd    //监听套接字、连接套接字描述符
    struct sockaddr_in servaddr;    //服务器监听地址
    listenfd=    ;    //创建用于监听的套接字
    if (listenfd＜0) {
    fPrintf( stderr，"创建套接字错误!");
    exit    ;
    } //套接字创建失败时打印错误信息
    bzero(&servaddr.sizeof(servadd));//将地址结构置空
    servaddr.sin_family=AF_INET;//设置地址结构遵循TCP/IP协议
    servaddr.sin_addrs_addr=htonl.    ;//设置监听的IP地址为任意合法地址，并将该地址转换为网络字节顺序
    servaddr.sin_port=    ;//设置监听的端口，并转化为网络字节顺序
    if ( bind    ＜0 ) {
    fprintf( stderr,"绑定套接字与地址!");
    exit    ;
    }    //将监听地址与用于监听的套接字绑定，绑定失败时打印错误信息
    if ( listen( listedfd, BACKLOG)＜0) {
    fprintf( stderr,"转换套接字为监听套接字!");
    exit    ;
    }    //将用于监听的套接字由普通套接字转化为监听套接字
    for(;){
    connfd=    ;
    //从监听套接字的连接队列中接收已经完成的连接，并创建新的连接套接字
    if(connfd＜0){
    fprintf(stderr,"接收连接失败!");
    exit    ;
    } //接收失败打印错误信息
    serv_respon(connfd);    //运行服务器的处理函数
        ;//关闭连接套接字 }
    close(listenfd);//关闭监听套接字 }
    服务器通信部分:
    #include＜stdio.h＞
    ……//引用头文件部分略＞
    void serv_respon( int sockfd) {
    int nbytes; char buf[1024];
    for(;;) {
    nbytes=read_requ(sockfd, buf, 1024);
    //读出客户机发出的请求，并分析其中的协议结构，获知请求的内容部分的长度，并将内容复制到缓冲区buf中，
    if ( nbytes=0) return;//如客户机结束发送就退出
    else if ( bytes＜0 ) {
    fprintf( siderr,"读错误情息：%s\n", sterror( errno ));
    return;
    }//读请求错误打印错误信息
    if ( write_all ( sockfd, buf, nbytes)＜0)
    //将请求中的内容部分反向发送回客户机
    fprintf( siderr,"写错误信息：%s\n", strerror( errno ) );
    }
    }
    int read_requ( int sockfd, char*buf int size ) {
    char inbuf[256];
    int n; int i;
    i=read_line( sockfd, inbuf, 256 );
    //从套接字接收缓冲区中读出一行数据，该数据为客户请求的首部
    if(1＜O)return    ;
    else if ( i=0 ) return(0);
    if ( strncmp( inbuf,"",6 )=0)
    sscanf(     ,"%d", &n );//从缓冲区buf中读出长度信息
    else{
    sprintf( buf," ",14 );
    return(14);
    }//取出首部Length域中的数值，该数值为内容部分的长度
    return( read_all( sockfd, buf, n ) );//从接收缓冲区中读出请求的内容部分
    }
    int get_char(int fd, char*ch) {
    static int offset=0;
    static int size=0;
    static char buff[1024];
    //声明静态变量，在get_char多次被调用期间，该变量的内存不释放
    for ( ;size＜=0 ||    ;) {
    size=read(fd,buf,1024);//一次从套接字缓冲区中读出一个数据块
    if ( size＜0 ) {
    if ( errno=EINTR ) {
    size=0;
    confine;
    //EINTR表示本次读操作没有成功，但可以继续使用该套接字读出数i
    }else
    return(-1);
    }
    offset=0;//读出数据后，将偏址置为0
    }
    *ch=buf[    ];//将当前的字符取出，并将偏址移向下一字符
    return    ;
    }
    int read_line(int fd, char*buf, int maxlen) {
    int i,n;
    char ch;
    for ( i=0; i＜maxlen;) {
    n = get_char( fd, &ch );//取出一个字符
    if ( n==1 ){
    buff[i++]=ch;//将字符加入字符串中
    if (     break;
    }else if ( n＜ ) return(-1);
    else break;
    }
    buf[i]='\0';
    return(i);
    }
    //函数read_line的作用是读出请求的首部，其处理的方法是每次调用get_char函数，取出一个字符，检查该字符是否是回车符‘\n’，如果是回车符，就返回请求的首部。
    //get_char的处理方式较为特殊，并不是每次调用read函数读一个字符，而是一次从缓冲区中读一块内容，再一次一个字符提交给函数read_line，如果提交完了就再读一块，这样就可以提高读缓冲区的效率。另外，由于客户机是分两次调用writ_all函数将请求的首部和内容发送给服务器，因此get_char不会取出请求内容部分的字符。

1.     【说明】
    以下是客户机/服务器模型中的一个简单的客户机程序(服务器程序略)，其工作过程非常简单：客户机与服务器建立连接后，接收服务器向客户机返回的一条消息。
    程序中用到了两种结构hostent与sockaddr_in:
    hostent类型的结构定义
    struct hostent { char*h_name;    //主机名称
    char**h_aliases;    //别名列表
    int h_addrtype;    //主机地址类型: AF_XXX
    int H_length;    //主机地址长度: 32位
    char**h_addr_list;    //主机IP地址列表
    }
    #define h_addr h_addr_list[0]
    sockaddr_in类型的结构定义，sockaddr_in是通用套接字结构sockaddr在TCP/IP协议下的结构重定义，为TCP/IP套接字地址结构。
    Struct sockaddrin {
    short int sin_family;//地址类型AF_XXX，其中AF_INET为TCP/IP专用
    unsigned short int sin_port;    //端口号
    struct in_addrsin_addr;    //Internet地址
    //端口号以及Internet地址使用的是网络字节顺序，需要通过函数htons转换
    }
    struct iN_addr {
    _u32 s_addr;    //类型为unsignel_long
    }
    程序中使用到了多个函数：
    struct hostent * gethostbyname( const char*hostname );
    函数gethostbyname查询指定的域名地址对应的IP地址，返回一个hostent结构的指针，如果不成功返回NULL。
    int_socket(int domain, int_type, int protocol);
    函数socket创建一个套接字描述符，如果失败返回-1。domain为地址类型，type为套接字类型，本题中为SOCK_STREAM; protocol指定协议，本题中为0。
    int connect( int sockfd, struct sockaddr*servaddr, int addrlen);
    函数connect与服务器建立一个连接，成功返回0，失败返回-1。servaddr为远程服务器的套接字地址，包括服务器的IP地址和端口号；addrlen为地址的长度。
    int read( int fd, char*buf, int len);
    int write( int fd, char*buf, int len);
    函数read和write从套接字读和写数据，成功返回数据量大小，否则返回-1。buf指定数据缓冲区，len指定接收或发送的数据量大小。
    【socket程序】
    #define PORT4490
    //定义端口号为4490
    int main( int argc, char*argv[ ])
    {
    int sockfd, nbytes;    //套接字描述符、读入缓冲区的字节数
    char buf[1024];    //缓冲区
    stmct hostent*he;    //主机信息类型
    struct sockaddr_in srvaddr;    //Internet套接字结构
    if    
    {perror("调用参数为零，请输入服务器的主机名!\n");exit    ; }
    if    
    {perror("无法通过主机名获得主机信息!\n");exit    ; }
    if    
    {perror("无法创建套按字!\n");exit    ; }
    bzero( &srvaddr, sizeof(srvaddr));//置空srvaddr
    srvaddr, sin_family=AF_INET;
    srvaddr, sin_port:     ; srvaddr.sin_addr:     ;
    if(connect(sockfd,     , sizeof( struct sockaddr))=-1)
    {perror("连接失败!\n");exit    ; }
    //连接服务器，如果失败则提示用户
    if(( nbytes=read ( sockfd, buf, MAXDATASIZE))=-1)
    {perror("读失败!\n");exit    ; }
    //从套容接字中读出数据
    buf[nbytes]='\0';
    prinff("读到的内容：%s", buf);
    close( sockfd);
    //打印数据并关闭套接字
    }

1.     【说明】
    代码实例中的服务器通过socket连接向客户端发送字符串"Hello，you are connected!"。只要在服务器上运行该服务器软件，在客户端运行客户软件，客户端就会收到该字符串。
    客户端程序代码如下：
    #include＜stdio.h＞
    #include＜stdlib.h＞
    #include＜errno.h＞
    #include＜string.h＞
    #include＜netdb.h＞
    #include＜sys/types.h＞
    #include＜netinet/in.h＞
    #include＜sys/socket.h＞
    #define SERVPORT 3333
    #define MAXDATASIZE 100 /*每次最大数据传输量*/
    main(int argc, char*argv[]){
    int sockfd, recvbytes;
    char buf[MAXDATASIZE];
    stmct hostent*host;
    struct sockaddr_in serv_addr;
    if     {
    fprintf(stderr, "Please enter the server's hostname!\n");
    exit    ;
    }
    if＜(host=gethostbyname(argv[1]))=NULL) {
    herror("gethostbyname出错!");
    exit    ;
    }
    if ((sockfd = socket(AF_INET,     , 0))=-1) {
    perror("socket创建出错!");
    exit    ;
    }
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_port=htons(SERVPORT);
    Serv_addr.sin_addr=*((structin_addr*)host→h_addr);
    bzero(&(serv_addr.sin_zero), 8);
    if(connect     , (struct sockaddr *)&serv_addr, \
    sizeof(struct sockaddr))=-1) {
    perror("connect出错!");
    exit    ;
    }
    if((recvbytes=recv     , buf, MAXDATASIZE, 0))=-1) {
    perror("recv出错!");
    exit    ;
    }
    buf[recvbytes]='\0';
    pfintf("Received: %s", buf);
    close(sockfd);
    }