#include <sys/socket.h>
int listen(int sockfd, int backlog);

/*服务端的处理过程*/:
void process_conn_server(int s)
{
    ssize_t size = 0;
    char buffer[1024];/*数据的缓冲区*/
    for(;;){
        size = recv(s, buffer, 1024,0);/*从套接字中读取数据放到缓冲区buffer中*/
        if(size == 0){ /*没有数据*/
       		 return;
        }
        sprintf(buffer, "%d bytes altogether\n", size);/*构建响应字符,为接收到客户端字节的数量*/
        send(s, buffer, strlen(buffer)+1,0);/*发给客户端*/
    }
}

/*客户端的处理过程*/
void process_conn_server(int s)
{
    ssize_t size = 0;
    char buffer[1024]; /*数据的缓冲区*/
    for(;;){ 
        size = recv(s, buffer, 1024,0);/*从套接字中读取数据放到缓冲区buffer中*/
        if(size == 0){ /*没有数据*/
       		 return;
        }
        sprintf(buffer, "%d bytes altogether\n", size);/*构建响应字符,为接收到客户端字节的数量*/
        send(s, buffer, strlen(buffer)+1,0);/*发给客户端*/
    }
}

void process_conn_server(int s)/*服务器对客户端的处理*/
{
    char buffer[30];/*向量的缓冲区*/
    ssize_t size = 0;
    struct iovec*v = (struct iovec*)malloc(3*sizeof(struct iovec));/*申请3个向量*/
    if(!v){
    printf("Not enough memory\n");
    return;
    }
    vs = v; /**挂接全局变量,便于释放管理*/
			/*每个向量10个字节的空间*/
    v[0].iov_base = buffer; /*0~9*/
    v[1].iov_base = buffer + 10; /*10~19*/
    v[2].iov_base = buffer + 20;/*20~29*/
    v[0].iov_len = v[1].iov_len = v[2].iov_len = 10;/*初始化长度为10*/
    for(;;){ 
        size = readv(s, v, 3); /*从套接字中读取数据放到向量缓冲区中*/
        if(size == 0){ /*没有数据*/
        return;
    }
		/*构建响应字符,为接收到客户端字节的数量,分别放到3个缓冲区中*/
    sprintf(v[0].iov_base, "%d ", size); /*长度*/
    sprintf(v[1].iov_base, "bytes alt"); /* "bytes alt"字符*/
    sprintf(v[2].iov_base, "ogether\n");/* "ogetherIn"字符*/
										/*写入字符串长度*/
    v[0].iov_len = strlen(v[0].iov_base);
    v[1].iov_len = strlen(v[1].iov_base);
    v[2].iov_len = strlen(v[2].iov_base);
    writev(s, v, 3); /*发给客户端*/
    }
}

void process_conn_client(int s)/*客户端的处理过程*/
{
    char buffer[30]; /*向量的缓冲区*/
    ssize_t size = 0;
    /*申请3个向量*/
    struct iovec*v = (struct iovec*)malloc(3*sizeof(struct iovec));
    if(!v){
        printf("Not enough memory\n");
        return;
    }
    /**挂接全局变量,便于释放管理*/
    vc = v;
    /*每个向量10个字节的空间*/
    v[0].iov_base = buffer; /*0~9*/
    v[1].iov_base = buffer + 10; /*10~19*/
    v[2].iov_base = buffer + 20; /*20~29*/
    /*初始化长度为10*/
    v[0].iov_len = v[1].iov_len = v[2].iov_len = 10;
    int i = 0;
    for(;;){ 
       /*从标准输入中读取数据放到缓冲区buffer中*/
        size = read(0, v[0].iov_base, 10);
        if(size > 0){ /*读到数据*/
        v[0].iov_len= size;
        writev(s, v,1); /*发送给服务器*/
        v[0].iov_len = v[1].iov_len = v[2].iov_len = 10;
        size = readv(s, v, 3); /*从服务器读取数据*/
        for(i = 0;i<3;i++){
        if(v[i].iov_len > 0){
        write(1, v[i].iov_base, v[i].iov_len);/*写到标准输出*/
            	}
            }
        }
    }
}

#include <sys/uio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
static struct iovec*vs=NULL,*vc=NULL;
/*服务器对客户端的处理*/
void process_conn_server(int s)
{
    char buffer[30]; /*向量的缓冲区*/
    ssize_t size = 0;
    struct msghdr msg;/*消息结构*/
    /*申请3个向量*/
    struct iovec*v = (struct iovec*)malloc(3*sizeof(struct iovec));
    if(!v){
        printf("Not enough memory\n");
        return;
    }
    /**挂接全局变量,便于释放管理*/
    vs = v;
    /*初始化消息*/
    msg.msg_name = NULL; /*没有名字域*/
    msg.msg_namelen = 0; /*名字域长度为0*/
    msg.msg_control = NULL; /*没有控制域*/
    msg.msg_controllen = 0; /*控制域长度为0*/
    msg.msg_iov = v;/*挂接向量指针*/
    msg.msg_iovlen = 30; /*接收缓冲区长度为30*/
    msg.msg_flags = 0; /*无特殊操作*/
    /*每个向量10个字节的空间*/
    v[0].iov_base = buffer; /*0~9*/
    v[1].iov_base = buffer + 10; /*10~19*/
    v[2].iov_base = buffer + 20; /*20~29*/
    /*初始化长度为10*/
    v[0].iov_len = v[1].iov_len = v[2].iov_len = 10;
    for(;;){ 
        /*从套接字中读取数据放到向量缓冲区中*/
        size = recvmsg(s, &msg, 0);
        if(size == 0){ /*没有数据*/
        	return;
    	}
        /*构建响应字符,为接收到客户端字节的数量,分别放到3个缓冲区中*/
        sprintf(v[0].iov_base, "%d ", size); /*长度*/
        sprintf(v[1].iov_base, "bytes alt"); /* "bytes alt"字符*/
        sprintf(v[2].iov_base, "ogether\n"); /* “ogetherIn"字符*/
        /*写入字符串长度*/
        v[0].iov_len = strlen(v[0].iov_base);
        v[1].iov_len = strlen(v[1].iov_base);
        v[2].iov_len = strlen(v[2].iov_base);
        sendmsg(s, &msg, 0); /*发给客户端*/
    }
}

void process_conn_client(int s)/*客户端的处理过程*/
{
    char buffer[30]; /*向量的缓冲区*/
    ssize_t size = 0;
    struct msghdr msg; /*消息结构*/
     /*申请3个向量*/
    struct iovec*v = (struct iovec*)malloc(3*sizeof(struct iovec));
    if(!v){
        printf("Not enough memory\n");
        return;
    }
    /**挂接全局变量,便于释放管理*/
    vc = v;
    /*初始化消息*/
    msg.msg_name = NULL; /*没有名字域*/
    msg.msg_namelen = 0; /*名字域长度为0*/
    msg.msg_control = NULL; /*没有控制域*/
    msg.msg_controllen = 0; /*控制域长度为0*/
    msg.msg_iov = v;/*挂接向量指针*/
    msg.msg_iovlen = 30; /*接收缓冲区长度为30*/
    msg.msg_flags = 0; /*无特殊操作*/
    /*每个向量10个字节的空间*/
    v[0].iov_base = buffer; /*0~9*/
    v[1].iov_base = buffer + 10; /*10~19*/
    v[2].iov_base = buffer + 20; /*20~29*/
    /*初始化长度为10*/
    v[0].iov_len = v[1].iov_len = v[2].iov_len = 10;
    int i = 0;
    for(;;){
        /*从标准输入中读取数据放到缓冲区buffer中*/
        size = read(0, v[0].iov_base, 10);
        if(size > 0){ /*读到数据*/
            v[0].iov_len= size;
            sendmsg(s, &msg,0); /*发送给服务器*/
            v[0].iov_len = v[1].iov_len = v[2].iov_len = 10;
            size = recvmsg(s, &msg,0); /*从服务器读取数据*/
            for(i = 0;i<3;i++){
                if(v[i].iov_len > 0){
                	write(1, v[i].iov_base, v[i].iov_len);/*写到标准输出*/
                }
            }
        }
    }
}

struct sockaddr_in local; /*本地的地址信息*/
int from_len = sizeof(from);/*地址结构的长度*/
local. sin _family = AF_INET; /*协议族*/
local. sin _port = htons(8888); /*本地端口*/
local. sin _addr.s_addr = htonl(INADDR_ANY); /*任意本地地址*/
s = socket(AF_INET, SOCK_DGRAM, 0); /*初始化一个IPv4族的数据报套接字*/
if (s == -1) { /*检查是否正常初始化socket*/
perror("socket");
exit(EXIT_FAILURE);
}
bind(s, (struct sockaddr*)&local,sizeof(local)); /*套接字绑定*/

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
int main(int argc, char*argv[])
{
    int s; /*套接字文件描述符*/
    struct sockaddr_in from; /*发送方的地址信息*/
    struct sockaddr_in local; /*本地的地址信息*/
    int from_len = sizeof(from); /*地址结构的长度*/
    int n; /*接收到的数据长度*/
    char buf[128]; /*接收数据缓冲区*/
    s = socket(AF_INET, SOCK_DGRAM, 0); /*初始化一个IPv4族的数据报套接字*/
    if (s == -1) { /*检查是否正常初始化socket*/
        perror("socket");
        exit(EXIT_FAILURE);
    }
    
    local. sin _family = AF_INET; /*协议族*/
    local. sin _port = htons(8888); /*本地端口*/
    local. sin _addr.s_addr = htonl(INADDR_ANY); /*任意本地地址*/
    bind(s, (struct sockaddr*)&local,sizeof(local)); /*套接字绑定*/
    n = recvfrom(s, buff, 128, 0, (struct sockaddr*)&from, &from_len);
    if(n == -1){ /*接收数据出错*/
        perror("recvfrom");
        exit(EXIT_FAILURE);
    }
    /*处理数据*/
}

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
int main(int argc, char*argv[])
{
    int s; /*套接字文件描述符*/
    struct sockaddr_in to; /*接收方的地址信息*/
    int n; /*发送到的数据长度*/
    char buf[128]; /*发送数据缓冲区*/
    s = socket(AF_INET, SOCK_DGRAM, 0); /*初始化一个IPv4族的数据报套接字*/
    if (s == -1) { /*检查是否正常初始化socket*/
        perror("socket");
        exit(EXIT_FAILURE);
    }
    to.sin_family = AF_INET; /*协议族*/
    to.sin_port = htons(8888);/*本地端口*/
    to.sin_addr.s_addr = inet_addr("192.168.1.1");
    /*将数据发送到主机192.169.1.1上*/
    n = sendto(s, buff, 128, 0, (struct sockaddr*)&to, sizeof (to));
    /*将数据buff发送到主机to上*/
    if(n == -1){ /*发送数据出错*/
        perror("sendto");
        exit(EXIT_FAILURE);
    }
    /*处理数据*/
}

struct ip_mreq
{
    struct in_addr imn_multiaddr; /*加入或者退出的广播组IP地址*/
    struct in_addr imr_interface; /*本机需要加入或者退出的网络接口IP地址,为INADDR_ANY时，,选择默认组播接口*/
};

/*
*broadcast_server.c - 多播服务程序例子
*/
#define MCAST_PORT 8888;
#define MCAST_ADDR "224.0.0.88" /*一个局部连接多播地址,路由器不进行转发*/
#define MCAST_DATA "BROADCAST TEST DATA" /*多播发送的数据*/
#define MCAST_INTERVAL 5 /*发送间隔时间*/
int main(int argc, char*argv)
{
    int s;
    struct sockaddr_in mcast_addr;
    s = socket(AF_INET, SOCK_DGRAM, 0); /*建立套接字*/
    if (s == -1)
    {
        perror("socket()");
        return -1;
    }
    memset(&mcast_addr, 0, sizeof(mcast_addr));/*初始化IP多播地址为0*/
    mcast_addr.sin_family = AF_INET; /*设置协议族类行为AF*/
    mcast_addr.sin_addr.s_addr = inet_addr(MCAST_ADDR);/*设置多播IP地址*/
    mcast_addr.sin_port = htons(MCAST_PORT); /*设置多播端口*/

    while(1) {
        int n = sendto(s, 
       	 	MCAST_DATA, /*数据*/
        	sizeof(MCAST_DATA), /*长度*/
        	0,
        	(struct sockaddr*)&mcast_addr,
        	sizeof(mcast_addr)) ;
        if( n < 0)
        {
            perror("sendto()");
            return -2;
        }
        sleep(MCAST_INTERVAL); /*等待一段时间*/
    }
    return 0;
}

/*
*broadcast_client.c - 多播客户端
*/
#define MCAST_PORT 8888;
#define MCAST_ADDR "224.0.0.88" /*一个局部连接多播地址,路由器不进行转发*/
#define MCAST_INTERVAL 5 /*发送间隔时间*/
#define BUFF_SIZE 256 /*接收缓冲区大小*/
int main(int argc, char*argv[])
{
    int s; /*套接字文件描述符*/
    struct sockaddr_in local_addr;/*本地地址*/
    int err = -1;
    s = socket(AF_INET, SOCK_DGRAM, 0); /*建立套接字*/
    if (s == -1)
    {
    perror("socket()");
    return -1;
    }

    memset(&local_addr, 0, sizeof(local_addr));
    local_addr.sin_family = AF_INET;
    local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    local_addr.sin_port = htons(MCAST_PORT);
    /*绑定 socket*/
    err = bind(s,(struct sockaddr*)&local_addr, sizeof(local_addr)) ;
    if(err < 0)
    {
        perror("bind()");
        return -2;
    }
    /*设置回环许可*/
    int loop = 1;
    err = setsockopt(s,IPPROTO_IP, IP_MULTICAST_LOOP,&loop, sizeof(loop));
    if(err < 0)
    {
        perror("setsockopt():IP_MULTICAST_LOOP");
        return -3;
    }
    struct ip_mreq mreq;/*加入广播组*/
    mreq.imr_multiaddr.s_addr = inet_addr(MCAST_ADDR); /*广播地址*/
    mreq.imr_interface.s_addr = htonl(INADDR_ANY); /*网络接口为默认*/
    /*将本机加入广播组*/
    err = setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP,&mreq, sizeof
    (mreq));
    if (err < 0)
    {
        perror("setsockopt():IP_ADD_MEMBERSHIP");
        return -4;
    }
    int times = 0;
    int addr_len = 0;
    char buff[BUFF_SIZE];
    int n = 0;
    /*循环接收广播组的消息,5次后退出*/
    for(times = 0;times<5;times++)
    {
        addr_len = sizeof(local_addr);
        memset(buff, 0, BUFF_SIZE);/*清空接收缓冲区*/
        /*接收数据*/
        n = recvfrom(s, buff, BUFF_SIZE, 0,(struct sockaddr*)&local_addr,&addr_len);
        if( n== -1)
        {
       		 perror("recvfrom()");
        }
       /*打印信息**/
        printf("Recv %dst message from server:%s\n", times, buff);
        sleep(MCAST_INTERVAL);
    }
    /*退出广播组*/
    err = setsockopt(s, IPPROTO_IP, IP_DROP_MEMBERSHIP,&mreq, sizeof
    (mreq));
    close(s);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <assert.h>
int main(int argc,char **argv)
{
    int err = -1; /*返回值*/
    int s = -1; /*socket描述符*/
    int snd_size = 0; /*发送缓冲区大小*/
    int rcv_size = 0; /*接收缓冲区大小*/
    socklen_t optlen; /*选项值长度*/
    /* 建立一个TCP套接字*/
    s = socket(PF_INET,SOCK_STREAM,0);
    if( s == -1){
        printf("建立套接字错误\n");
        return -1;
    }
    /*
    * 先读取缓冲区设置的情况
    * 获得原始发送缓冲区大小
    */
    optlen = sizeof(snd_size);
    err = getsockopt(s, SOL_SOCKET, SO_SNDBUF,&snd_size, &optlen);
    if(err){
    	printf("获取发送缓冲区大小错误\n");
    }
    /*
    * 打印原始缓冲区设置情况
    */
    printf("发送缓冲区原始大小为: %d 字节\n",snd_size);
    printf("接收缓冲区原始大小为: %d 字节\n",rcv_size);
    /*
    * 获得原始接收缓冲区大小
    */
    optlen = sizeof(rcv_size);
    err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen);
    if(err){
    	printf("获取接收缓冲区大小错误\n");
	}
    /*
    * 设置发送缓冲区大小
    */
    snd_size = 4096; /*发送缓冲区大小为8K*/
    optlen = sizeof(snd_size);
    err = setsockopt(s, SOL_SOCKET, SO_SNDBUF, &snd_size, optlen);
    if(err){
    	printf("设置发送缓冲区大小错误\n");
    }
    /*
    * 设置接收缓冲区大小
    */
    rcv_size = 8192; /*接收缓冲区大小为8K*/
    optlen = sizeof(rcv_size);
    err = setsockopt(s,SOL_SOCKET,SO_RCVBUF, &rcv_size, optlen);
    if(err){
    	printf("设置接收缓冲区大小错误\n");
    }
    /*
    * 检查上述缓冲区设置的情况
    * 获得修改后发送缓冲区大小
    */
    optlen = sizeof(snd_size);
    err = getsockopt(s, SOL_SOCKET, SO_SNDBUF,&snd_size, &optlen);
    if(err){
    printf("获取发送缓冲区大小错误\n");
    }
    /*
    * 获得修改后发送缓冲区大小
    */
    optlen = sizeof(rcv_size);
    err = getsockopt(s, SOL_SOCKET, SO_RCVBUF, &rcv_size, &optlen);
    if(err){
    printf("获取接收缓冲区大小错误\n");
    }
    /*
    * 打印结果
    */
    printf(" 发送缓冲区大小为: %d 字节\n",snd_size);
    printf(" 接收缓冲区大小为: %d 字节\n",rcv_size);
    close(s);
    return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
int main(int argc, char *argv[])
{
	int s;									/*服务器套接字文件描述符*/
	struct sockaddr_in local, to;			/*本地地址*/
	time_t now;								/*时间*/
	char buff[BUFFLEN];						/*收发数据缓冲区*/
	int n = 0;	
	socklen_t len = sizeof(to);
	
	s = socket(AF_INET, SOCK_DGRAM, 0);	/*建立UDP套接字*/
	
	/*初始化地址*/
	memset(&local, 0, sizeof(local));		/*清零*/
	local.sin_family = AF_INET;				/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);	/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s, (struct sockaddr*)&local, sizeof(local));
	/*主处理过程*/
	while(1)
	{
		memset(buff, 0, BUFFLEN);			/*清零*/
		n = recvfrom(s, buff, BUFFLEN,0,(struct sockaddr*)&to, &len);
		/*接收发送方数据*/
		if(n > 0 && !strncmp(buff, "TIME", 4))		/*判断是否合法接收数据*/
		{
			memset(buff, 0, BUFFLEN);		/*清零*/
			now = time(NULL);				/*当前时间*/
			sprintf(buff, "%24s\r\n",ctime(&now));/*将时间复制入缓冲区*/
			sendto(s, buff, strlen(buff),0, (struct sockaddr*)&to, len);
			/*发送数据*/
		}
	}
	close(s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
int main(int argc, char *argv[])
{
	int s;									/*服务器套接字文件描述符*/
	struct sockaddr_in server;				/*本地地址*/
	char buff[BUFFLEN];						/*收发数据缓冲区*/
	int n = 0;								/*接收字符串长度*/
	socklen_t len = 0;							/*地址长度*/
	
	s = socket(AF_INET, SOCK_DGRAM, 0);	/*建立UDP套接字*/
	
	/*初始化地址初始化*/
	memset(&server, 0, sizeof(server));	/*清零*/
	server.sin_family = AF_INET;			/*AF_INET协议族*/
	server.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	server.sin_port = htons(SERVER_PORT);			/*服务器端口*/	
	
	memset(buff, 0, BUFFLEN);				/*清零*/
	strcpy(buff, "TIME");					/*复制发送字符串*/
	/*发送数据*/
	sendto(s, buff, strlen(buff), 0, (struct sockaddr*)&server, 
	sizeof(server));
	memset(buff, 0, BUFFLEN);				/*清零*/
	/*接收数据*/
	len = sizeof(server);
	n = recvfrom(s, buff, BUFFLEN, 0, (struct sockaddr*)&server, &len);
	/*打印消息*/
	if(n >0){
		printf("TIME:%s",buff);	
	}
	close(s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 		1024
#define SERVER_PORT 	8888
#define BACKLOG 		5
int main(int argc, char *argv[])
{
	int s_s, s_c;							/*服务器套接字文件描述符*/
	struct sockaddr_in local, from;				/*本地地址*/
	time_t now;										/*时间*/
	char buff[BUFFLEN];								/*收发数据缓冲区*/
	int n = 0;
	socklen_t len = sizeof(from);
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址*/
	memset(&local, 0, sizeof(local));				/*清零*/
	local.sin_family = AF_INET;						/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);		/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);			/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
	listen(s_s, BACKLOG);						/*侦听*/
	
	/*主处理过程*/
	while(1)
	{
		/*接收客户端连接*/
		s_c = accept(s_s, (struct sockaddr*)&from, &len);
		memset(buff, 0, BUFFLEN);					/*清零*/
		n = recv(s_c, buff, BUFFLEN,0);			/*接收发送方数据*/
		if(n > 0 && !strncmp(buff, "TIME", 4))		/*判断是否合法接收数据*/
		{
			memset(buff, 0, BUFFLEN);				/*清零*/
			now = time(NULL);						/*当前时间*/
			sprintf(buff, "%24s\r\n",ctime(&now));/*将时间复制入缓冲区*/
			send(s_c, buff, strlen(buff),0);		/*发送数据*/
		}
		close(s_c);
	}
	close(s_s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
int main(int argc, char *argv[])
{
	int s;										/*服务器套接字文件描述符*/
	struct sockaddr_in server;					/*本地地址*/
	char buff[BUFFLEN];							/*收发数据缓冲区*/
	int n = 0;									/*接收字符串长度*/
	
	/*建立TCP套接字*/
	s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址*/
	memset(&server, 0, sizeof(server));		/*清零*/
	server.sin_family = AF_INET;				/*AF_INET协议族*/
	server.sin_addr.s_addr = htonl(INADDR_ANY);/*任意本地地址*/
	server.sin_port = htons(SERVER_PORT);		/*服务器端口*/	
	
	/*连接服务器*/
	connect(s, (struct sockaddr*)&server,sizeof(server));
	memset(buff, 0, BUFFLEN);					/*清零*/
	strcpy(buff, "TIME");						/*复制发送字符串*/
	/*发送数据*/
	send(s, buff, strlen(buff), 0);
	memset(buff, 0, BUFFLEN);					/*清零*/
	/*接收数据*/	
	n = recv(s, buff, BUFFLEN, 0);
	/*打印消息*/
	if(n >0){
		printf("TIME:%s",buff);	
	}
	close(s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define PIDNUMB 2
static void handle_connect(int s)
{	
	struct sockaddr_in from;						/*客户端地址*/
	socklen_t len = sizeof(from);
	int n = 0;
	char buff[BUFFLEN];
	time_t now;										/*时间*/
	
	/*主处理过程*/
	while(1)
	{
		memset(buff, 0, BUFFLEN);					/*清零*/
		/*接收客户端连接*/
		n = recvfrom(s, buff, BUFFLEN,0,(struct sockaddr*)&from, &len);
		/*接收发送方数据*/
		if(n > 0 && !strncmp(buff, "TIME", 4))		/*判断是否合法接收数据*/
		{
			memset(buff, 0, BUFFLEN);				/*清零*/
			now = time(NULL);						/*当前时间*/
			sprintf(buff, "%24s\r\n",ctime(&now));	/*将时间复制入缓冲区*/
			sendto(s, buff, strlen(buff),0, (struct sockaddr*)&from, len);/*发送数据*/			
		}
	}		
}
void sig_int(int num)								/*SIGINT信号处理函数*/
{
	exit(1);	
}
int main(int argc, char *argv[])
{
	int s_s;						/*服务器套接字文件描述符*/
	struct sockaddr_in local;						/*本地地址*/	
	
	signal(SIGINT, sig_int);
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_DGRAM, 0);
	
	/*初始化地址*/
	memset(&local, 0, sizeof(local));				/*清零*/
	local.sin_family = AF_INET;						/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);		/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);			/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
		
	/*处理客户端连接*/
	pid_t pid[PIDNUMB];
	int i =0;
	for(i=0;i<PIDNUMB;i++)
	{
		pid[i] = fork();
		if(pid[i] == 0)					/*子进程*/
		{
			handle_connect(s_s);
		}
	}
	while(1);

	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define PIDNUMB 3
static void handle_connect(int s_s)
{	
	int s_c;									/*客户端套接字文件描述符*/
	struct sockaddr_in from;					/*客户端地址*/
	socklen_t len = sizeof(from);
	
	/*主处理过程*/
	while(1)
	{
		/*接收客户端连接*/
		s_c = accept(s_s, (struct sockaddr*)&from, &len);
		time_t now;								/*时间*/
		char buff[BUFFLEN];						/*收发数据缓冲区*/
		int n = 0;
		memset(buff, 0, BUFFLEN);				/*清零*/
		n = recv(s_c, buff, BUFFLEN,0);		/*接收发送方数据*/
		if(n > 0 && !strncmp(buff, "TIME", 4))	/*判断是否合法接收数据*/
		{
			memset(buff, 0, BUFFLEN);			/*清零*/
			now = time(NULL);					/*当前时间*/
			sprintf(buff, "%24s\r\n",ctime(&now));	/*将时间复制入缓冲区*/
			send(s_c, buff, strlen(buff),0);	/*发送数据*/
		}		
		/*关闭客户端*/
		close(s_c);	
	}
		
}
void sig_int(int num)
{
	exit(1);	
}
int main(int argc, char *argv[])
{
	int s_s;									/*服务器套接字文件描述符*/
	struct sockaddr_in local;					/*本地地址*/	
	signal(SIGINT,sig_int);
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址和端口*/
	memset(&local, 0, sizeof(local));			/*清零*/
	local.sin_family = AF_INET;					/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);		/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
	listen(s_s, BACKLOG);					/*侦听*/
	
	/*处理客户端连接*/
	pid_t pid[PIDNUMB];
	int i =0;
	for(i=0;i<PIDNUMB;i++)
	{
		pid[i] = fork();
		if(pid[i] == 0)							/*子进程*/
		{
			handle_connect(s_s);
		}
	}
	while(1);
	
	close(s_s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
static void handle_request(int s_c)
{
	time_t now;									/*时间*/
	char buff[BUFFLEN];							/*收发数据缓冲区*/
	int n = 0;
	memset(buff, 0, BUFFLEN);					/*清零*/
	n = recv(s_c, buff, BUFFLEN,0);			/*接收发送方数据*/
	if(n > 0 && !strncmp(buff, "TIME", 4))		/*判断是否合法接收数据*/
	{
		memset(buff, 0, BUFFLEN);				/*清零*/
		now = time(NULL);						/*当前时间*/
		sprintf(buff, "%24s\r\n",ctime(&now));	/*将时间复制入缓冲区*/
		send(s_c, buff, strlen(buff),0);		/*发送数据*/
	}		
	/*关闭客户端*/
	close(s_c);	
}
static int handle_connect(int s_s)
{
	
	int s_c;								/*客户端套接字文件描述符*/
	struct sockaddr_in from;				/*客户端地址*/
	socklen_t len = sizeof(from);
	
	/*主处理过程*/
	while(1)
	{
		/*接收客户端连接*/
		s_c = accept(s_s, (struct sockaddr*)&from, &len);
		if(s_c > 0)							/*客户端成功连接*/
		{
			/*创建进程进行数据处理*/
			if(fork() > 0){					/*父进程*/
				close(s_c);					/*关闭父进程的客户端连接套接字*/
			}else{
				handle_request(s_c);		/*处理连接请求*/
				return(0);	
			}
		}
	}		
}
int main(int argc, char *argv[])
{
	int s_s;								/*服务器套接字文件描述符*/
	struct sockaddr_in local;				/*本地地址*/	
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址*/
	memset(&local, 0, sizeof(local));		/*清零*/
	local.sin_family = AF_INET;				/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);	/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
	listen(s_s, BACKLOG);				/*侦听*/
	
	/*处理客户端连接*/
	handle_connect(s_s);
	
	close(s_s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
static void handle_request(void *argv)
{
	int s_c = *((int*)argv);
	time_t now;									/*时间*/
	char buff[BUFFLEN];							/*收发数据缓冲区*/
	int n = 0;
	memset(buff, 0, BUFFLEN);					/*清零*/
	n = recv(s_c, buff, BUFFLEN,0);			/*接收发送方数据*/
	if(n > 0 && !strncmp(buff, "TIME", 4))		/*判断是否合法接收数据*/
	{
		memset(buff, 0, BUFFLEN);				/*清零*/
		now = time(NULL);						/*当前时间*/
		sprintf(buff, "%24s\r\n",ctime(&now));	/*将时间复制入缓冲区*/
		send(s_c, buff, strlen(buff),0);		/*发送数据*/
	}		
	/*关闭客户端*/
	close(s_c);	
}
static void handle_connect(int s_s)
{
	
	int s_c;									/*客户端套接字文件描述符*/
	struct sockaddr_in from;					/*客户端地址*/
	socklen_t len = sizeof(from);
	pthread_t  thread_do;
	
	/*主处理过程*/
	while(1)
	{
		/*接收客户端连接*/
		s_c = accept(s_s, (struct sockaddr*)&from, &len);
		if(s_c > 0)							/*客户端成功连接*/
		{
			/*创建线程处理连接*/
			pthread_create(&thread_do,
					NULL,
					(void*)handle_request,
					&s_c);				
		}
	}		
}
int main(int argc, char *argv[])
{
	int s_s;								/*服务器套接字文件描述符*/
	struct sockaddr_in local;				/*本地地址*/	
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址和端口*/
	memset(&local, 0, sizeof(local));		/*清零*/
	local.sin_family = AF_INET;				/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);		/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
	listen(s_s, BACKLOG);					/*侦听*/
	
	/*处理客户端连接*/
	handle_connect(s_s);
	
	close(s_s);
	
	return 0;		
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define CLIENTNUM 2
/*互斥量*/
pthread_mutex_t ALOCK = PTHREAD_MUTEX_INITIALIZER;
static void *handle_request(void *argv)
{	
	int s_s = *((int*)argv);
	int s_c;								/*客户端套接字文件描述符*/
	struct sockaddr_in from;				/*客户端地址*/
	socklen_t len = sizeof(from);
	for(;;)
	{
		time_t now;							/*时间*/
		char buff[BUFFLEN];					/*收发数据缓冲区*/
		int n = 0;
		
		pthread_mutex_lock(&ALOCK);			/*进入互斥区*/
		s_c = accept(s_s, (struct sockaddr*)&from, &len);
		/*接收客户端的请求*/
		pthread_mutex_unlock(&ALOCK);		/*离开互斥区*/
		
		memset(buff, 0, BUFFLEN);			/*清零*/
		n = recv(s_c, buff, BUFFLEN,0);	/*接收发送方数据*/
		if(n > 0 && !strncmp(buff, "TIME", 4))	/*判断是否合法接收数据*/
		{
			memset(buff, 0, BUFFLEN);		/*清零*/
			now = time(NULL);				/*当前时间*/
			sprintf(buff, "%24s\r\n",ctime(&now));	/*将时间复制入缓冲区*/
			send(s_c, buff, strlen(buff),0);		/*发送数据*/
		}		
		/*关闭客户端*/
		close(s_c);	
	}
	
	return NULL;
}
static void handle_connect(int s)
{	
	int s_s = s;
	pthread_t  thread_do[CLIENTNUM];		/*线程ID*/
	int i = 0;
	for(i=0;i<CLIENTNUM;i++)				/*建立线程池*/
	{
		/*创建线程*/
		pthread_create(&thread_do[i],		/*线程ID*/
					NULL,					/*属性*/
					handle_request,			/*线程回调函数*/
					(void*)&s_s);			/*线程参数*/
	}
	/*等待线程结束*/
	for(i=0;i<CLIENTNUM;i++)
		pthread_join(thread_do[i], NULL);
}
int main(int argc, char *argv[])
{
	int s_s;								/*服务器套接字文件描述符*/
	struct sockaddr_in local;				/*本地地址*/	
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址和端口*/
	memset(&local, 0, sizeof(local));		/*清零*/
	local.sin_family = AF_INET;				/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);		/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
	listen(s_s, BACKLOG);					/*侦听*/
	
	/*处理客户端连接*/
	handle_connect(s_s);
	
	close(s_s);									/*关闭套接字*/
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/select.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define CLIENTNUM 1024						/*最大支持客户端数量*/

/*可连接客户端的文件描述符数组*/
int connect_host[CLIENTNUM];
int connect_number =  0;
static void *handle_request(void *argv)
{	
	time_t now;									/*时间*/
	char buff[BUFFLEN];							/*收发数据缓冲区*/
	int n = 0;
	
	int maxfd = -1;								/*最大侦听文件描述符*/
	fd_set scanfd;								/*侦听描述符集合*/
	struct   timeval   timeout; 					/*超时*/
	timeout.tv_sec     =   1; 					/* 阻塞1s后超时返回 */     
	timeout.tv_usec   =   0;     
    
	int i = 0;
	int err  = -1;
	for(;;)
	{   
		/*最大文件描述符值初始化为-1*/		
		maxfd = -1;
		FD_ZERO(&scanfd);						/*清零文件描述符集合*/
		for(i=0;i<CLIENTNUM;i++)				/*将文件描述符放入集合*/
		{
			if(connect_host[i] != -1)			/*合法的文件描述符*/
			{
				FD_SET(connect_host[i], &scanfd);	/*放入集合*/
				if(maxfd < 	connect_host[i])	/*更新最大文件描述符值*/
				{
					maxfd = connect_host[i];
				}
			}
		}
		/*select等待*/
		err = select(maxfd + 1, &scanfd, NULL, NULL, &timeout) ;		
		switch(err)
		{
			case 0:								/*超时*/
				break;
			case -1:							/*错误发生*/
				break;
			default:							/*有可读套接字文件描述符*/
				if(connect_number<=0)
					break;
				for(i = 0;i<CLIENTNUM;i++)
				{
					/*查找激活的文件描述符*/
					if(connect_host[i] != -1)
					if(FD_ISSET(connect_host[i],&scanfd))   
					{  
						memset(buff, 0, BUFFLEN);/*清零*/
						n = recv(connect_host[i], buff, BUFFLEN,0);
						/*接收发送方数据*/
						if(n > 0 && !strncmp(buff, "TIME", 4))
						/*判断是否合法接收数据*/
						{
							memset(buff, 0, BUFFLEN);			/*清零*/
							now = time(NULL);		/*当前时间*/
							sprintf(buff, "%24s\r\n",ctime(&now));
							/*将时间复制入缓冲区*/
							send(connect_host[i], buff, strlen(buff),0);
							/*发送数据*/
						}
						/*更新文件描述符在数组中的值*/
						connect_host[i] = -1;
						connect_number --;	/*客户端计数器减1*/	
						/*关闭客户端*/
						close(connect_host[i]);
					} 
				}
				break; 	
		}		  
	} 
	
	return NULL;
}
static void *handle_connect(void *argv)
{	
	int s_s = *((int*)argv) ;			/*获得服务器侦听套接字文件描述符*/
	struct sockaddr_in from;
	socklen_t len = sizeof(from);
	/*接收客户端连接*/
	for(;;)
	{
		int i = 0;
		int s_c = accept(s_s, (struct sockaddr*)&from, &len);
		/*接收客户端的请求*/
		printf("a client connect, from:%s\n",inet_ntoa(from.sin_addr));
		/*查找合适位置，将客户端的文件描述符放入*/				
		for(i=0;i<CLIENTNUM;i++)
		{
			if(connect_host[i] == -1)			/*找到*/
			{
				/*放入*/
				connect_host[i]= s_c;
				
				/*客户端计数器加1*/
				connect_number ++;
				/*继续轮询等待客户端连接*/
				break;						
			}	
		}		
	}	
	return NULL;
}


int main(int argc, char *argv[])
{
	int s_s;								/*服务器套接字文件描述符*/
	struct sockaddr_in local;				/*本地地址*/	
	int i = 0;
	memset(connect_host, -1, CLIENTNUM);
	
	/*建立TCP套接字*/
	s_s = socket(AF_INET, SOCK_STREAM, 0);
	
	/*初始化地址*/
	memset(&local, 0, sizeof(local));			/*清零*/
	local.sin_family = AF_INET;					/*AF_INET协议族*/
	local.sin_addr.s_addr = htonl(INADDR_ANY);	/*任意本地地址*/
	local.sin_port = htons(SERVER_PORT);		/*服务器端口*/
	
	/*将套接字文件描述符绑定到本地地址和端口*/
	bind(s_s, (struct sockaddr*)&local, sizeof(local));
	listen(s_s, BACKLOG);					/*侦听*/
	
	pthread_t  thread_do[2];/*线程ID*/
	/*创建线程处理客户端连接*/
	pthread_create(&thread_do[0],				/*线程ID*/
					NULL,						/*属性*/
					handle_connect,				/*线程回调函数*/
					(void*)&s_s);				/*线程参数*/
	/*创建线程处理客户端请求*/					
	pthread_create(&thread_do[1],				/*线程ID*/
					NULL,						/*属性*/
					handle_request,				/*线程回调函数*/
					NULL);						/*线程参数*/
	/*等待线程结束*/
	for(i=0;i<2;i++)
		pthread_join(thread_do[i], NULL);
	
	close(s_s);
	
	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
int getaddrinfo(const char *node,
				const char *service,
				const struct addrinfo *hints,
				struct addrinfo **res);
void freeaddrinfo(struct addrinfo *res);
const char *gai_strerror(int errcode);

struct addrinfo
{
    int ai_flags;
    int ai_family; /*PF xxx地址类型*/
    int ai_socktype; /*SOCK xxxSOCK 类型*/
    int ai_protocol; /*协议的序号,为0或者IPv4和IPv6协议中的某个协ipproto_xxx*/
    size_t ai_addrlen; /*ai addr 地址长度*/
    char *ai_canonname; /*主机名称*/
    struct sockaddr *ai_addr; /*地址结构*/
    struct addrinfo *ai_next; /*下一个地址结构*/
};

#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
struct hostent *getipnodebyname(const char *name,
								int af, int flags,
								int *error_num);
struct hostent *getipnodebyaddr(const void *addr,
								size_t len, int af,
								int *error_num);
void freehostent(struct hostent *ip);

struct hostent {
    char *h_name;
    char **h_aliases;
    int h_addrtype;
    int h_length;
    char **h_addr_list;
};

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#include <arpa/inet.h>
#define BUF_LEN 1024							/*缓冲区长度*/
#define MYPORT 8888								/*服务器侦听端口*/
#define BACKLOG 10								/*服务器侦听长度*/
int main(int argc, char **argv)
{
	int s_s;									/*服务器端套接字文件描述符*/
	int s_c;									/*客户端套接字文件描述符*/
	socklen_t len;
	int err = -1;
	
	struct sockaddr_in6 local_addr;			/*本地地址结构*/
	struct sockaddr_in6 client_addr;			/*客户端地址结构*/
	char buf[BUF_LEN + 1];
	
	s_s = socket(PF_INET6, SOCK_STREAM, 0);		/*建立IPv6套接字*/
	if (s_s == -1) {								/*判断错误*/
		perror("socket error");
		return(1);
	} else{
		printf("socket() success\n");
	}
	
	bzero(&local_addr, sizeof(local_addr));		/*清空地址结构*/
	local_addr.sin6_family = PF_INET6;			/*协议族*/
	local_addr.sin6_port = htons(MYPORT);		/*协议端口*/
	local_addr.sin6_addr = in6addr_any;			/*IPv6任意地址*/
	err = bind(s_s, (struct sockaddr *) &local_addr, sizeof(struct
	sockaddr_in6));
	if (err == -1) {							/*判断错误*/
		perror("bind error");
		return (1);
	} else{
		printf("bind() success\n");
	}
	
	err = listen(s_s, BACKLOG);					/*设置侦听队列*/
	if (err == -1) {								/*判断错误*/
		perror("listen error");
		exit(1);
	} else{
		printf("listen() success\n");
	}
	
	while (1) 
	{
		len = sizeof(struct sockaddr);			/*地址长度*/
		/*等待客户端连接*/
		s_c = accept(s_s, (struct sockaddr *)&client_addr, &len);
		if (s_c == -1) {							/*判断错误*/
			perror("accept error");
			return (errno);
		} else{
			/*将客户端的地址转换成字符串*/
			inet_ntop(AF_INET6, &client_addr.sin6_addr, buf, sizeof(buf));
			printf("a client from ip: %s, port %d, socket %d\n",
				   buf, /*客户端地址*/
				   client_addr.sin6_port,		/*客户端端口*/ 
				   s_c); 						/*客户端套接字文件描述符*/
		}
		
		/* 开始处理每个新连接上的数据收发 */
		bzero(buf, BUF_LEN + 1);				/*清零缓冲区*/
		strcpy(buf,"From Server");			/*复制数据*/
		/* 发消息给客户端 */
		len = send(s_c, buf, strlen(buf), 0);
		if (len < 0) {						/*错误信息*/
			printf("message '%s' send error,errno:%d,'%s'\n",
				 buf, errno, strerror(errno));
		} else{								/*成功信息*/
			printf("message '%s' send success, %dbytes\n",buf, len);
		}
		/*清零缓冲区*/
		bzero(buf, BUF_LEN + 1);
		/* 接收客户端的消息 */
		len = recv(s_c, buf, BUF_LEN, 0);
		if (len > 0)
			printf("recv message success:'%s',%dbytes\n",buf, len);
		else
			printf("recv message failure, errno: %d，'%s'\n",errno, strerror(errno));
		/* 处理每个新连接上的数据收发结束 */
		close(s_c);
	}
	close(s_s);
	return 0;
}

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#define BUF_LEN 1024						/*缓冲区长度*/
#define MYPORT 8888							/*服务器侦听端口*/
#define BACKLOG 10							/*服务器侦听长度*/
int main(int argc, char *argv[])
{
    int s_c;								/*客户端套接字文件描述符*/
    socklen_t len;
    int err = -1;

    struct sockaddr_in6 server_addr;			/*本地地址结构*/
    char buf[BUF_LEN + 1];						/*收发缓冲区*/

    s_c = socket(PF_INET6, SOCK_STREAM, 0);		/*建立IPv6套接字*/
    if (s_c == -1)   							/*判断错误*/
    {
        perror("socket error");
        return(1);
    }
    else
    {
        printf("socket() success\n");
    }

    bzero(&server_addr, sizeof(server_addr));		/*清空地址结构*/
    server_addr.sin6_family = PF_INET6;				/*协议族*/
    server_addr.sin6_port = htons(MYPORT);			/*协议端口*/
    server_addr.sin6_addr = in6addr_any;  			/*IPv6任意地址*/
    /*连接服务器*/
    err = connect(s_c, (struct sockaddr *) &server_addr, sizeof(server_addr));
    if (err == -1)  								/*判断错误*/
    {
        perror("connect error");
        return (1);
    }
    else
    {
        printf("connect() success\n");
    }

    /*清零缓冲区*/
    bzero(buf, BUF_LEN + 1);
    len = recv(s_c, buf, BUF_LEN, 0);				/*接收服务器数据*/
    /*打印信息*/
    printf("RECVED %dbytes:%s\n",len,buf);
    bzero(buf, BUF_LEN + 1);						/*清零缓冲区*/
    strcpy(buf,"From Client");						/*复制客户端的信息*/
    len = send(s_c, buf, strlen(buf), 0);			/*向服务器发送数据*/
    close(s_c);										/*关闭套接字*/

    return 0;
}

struct sk_buff
{
struct sk_buff *next;// sk_buff 链表中的下一个缓冲区
struct sk_buff *prev;//sk_buff 链表中的前一个缓冲区
struct sock *sk;//本网络报文所属的sock结构,此值仅在本机发出的报文中有效,从网络收到的报文此值为空。
ktime_t tstamp;//报文收到的时间截。
struct net_device *dev;//收到此报文的网络设备
union
{
struct dst_entry *dst;
struct rtable *rtable;
};
struct sec_path *sp;
char cb[48];//用于控制缓冲区。每个层都可以使用此指针,将私有的数据放置于此
unsigned int len,//有效数据长度
data_len;//数据长度。
__u16 mac_len,//连接层头部长度,对于以太网,指MAC地址所用的长度,为6
hdr_len;//skb 的可写头部长度。
union
{
    __wsum csum;//校验和(包含开始和偏移)。
    struct
    {
    __u16 csum_start;//当开始计算校验和时从skb->head的偏移。
    __u16 csum_offset;//csum_start开始的偏移
    };
};
__u32 priority;//包队列的优先级。
__u8 local_df:1,//允许本地分片。
cloned:1,
ip_summed:2,
nohdr:1,
nfctinfo:3;
__u8 pkt_type:3,//包的类别
fclone:2,
ipvs_property:1,
peeked:1,
nf_trace:1;
__be16 protocol;
void (*destructor)(struct sk_buff *skb);
struct nf_conntrack *nfct;
struct sk_buff *nfct_reasm;
struct nf_bridge_info *nf_bridge;
int iif;
__u16 queue_mapping;
__u16 tc_index;
__u16 tc_verd;
__u8 ndisc_nodetype:2;
dma_cookie_t dma_cookie;
__u32 secmark;
__u32 mark;
sk_buff_data_t transport_header;//传输层头部
sk_buff_data_t network_header;//网络层头部。
sk_buff_data_t mac_header;//链接层头部
sk_buff_data_t tail;//数据的尾指针
sk_buff_data_t end;//报文缓冲区的尾部。
unsigned char *head,//报文缓冲区的头
*data;//数据的头指针。
unsigned int truesize;//报文缓冲区的大小
atomic_t users;
};