NAME
       fcntl - manipulate file descriptor

SYNOPSIS
       #include <unistd.h>
       #include <fcntl.h>

       int fcntl(int fd, int cmd, ... /* arg */ );

DESCRIPTION
       fcntl() performs one of the operations described below on the open file
       descriptor fd.  The operation is determined by cmd.
       fcntl() can take an optional third argument.  Whether or not this argu‐
       ment  is  required is determined by cmd.  The required argument type is
       indicated in parentheses after  each  cmd  name  (in  most  cases,  the
       required type is int, and we identify the argument using the name arg),
       or void is specified if the argument is not required.
       
RETURN VALUE
       For a successful call, the return value depends on the operation:
       F_DUPFD  The new descriptor.
       F_GETFD  Value of file descriptor flags.
       F_GETFL  Value of file status flags.
       F_GETLEASE
                Type of lease held on file descriptor.
       F_GETOWN Value of descriptor owner.
       F_GETSIG Value of signal sent when read or write becomes  possible,  or
                zero for traditional SIGIO behavior.
       F_GETPIPE_SZ
                The pipe capacity.
       All other commands
                Zero.
On error, -1 is returned, and errno is set appropriately.

#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

void FD_CLR(int fd, fd_set *set);
int  FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);

#include <sys/select.h>

int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);

The timeout
The time structures involved are defined in <sys/time.h> and look like
struct timeval {
    long    tv_sec;         /* seconds */
    long    tv_usec;        /* microseconds */
};
and
struct timespec {
    long    tv_sec;         /* seconds */
   long    tv_nsec;        /* nanoseconds */
};
> (However, see below on the POSIX.1-2001 versions.)

RETURN VALUE
On success, select() and pselect() return the  number  of  file  descriptors  contained  in  the  three returned  descriptor  sets  (that  is,  the  total  number  of  bits that are set in readfds, writefds, exceptfds) which may be zero if the timeout expires before anything interesting happens.  On error,  -1 is  returned,  and errno is set appropriately; the sets and timeout become undefined, so do not rely on their contents after an error.

#include <sys/socket.h>

int shutdown(int sockfd, int how);

DESCRIPTION
	The  shutdown() call causes all or part of a full-duplex connection on the socket associated with sockfd to be shut down. If how is SHUT_RD, further receptions will be disallowed.  If how is SHUT_WR, further transmissions will  be  disallowed. If how is SHUT_RDWR, further receptions and transmissions will be disallowed.

RETURN VALUE
	On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.

ERRORS
	EBADF  
		sockfd is not a valid descriptor.
	EINVAL 
		An invalid value was specified in how (but see BUGS).
	ENOTCONN
		The specified socket is not connected.
	ENOTSOCK
		sockfd is a file, not a socket.

#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

void FD_CLR(int fd, fd_set *set);
int  FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);

#include <sys/select.h>

int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);

int i = 0;
int num = 0;
int maxi = 0; //最大不空闲的套接口下标
int nready = 0;
int maxfd = listenfd;
int conn[FD_SETSIZE] = {0};
fd_set rset;
fd_set allset;
FD_ZERO(&rset);
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
struct sockaddr_in sockname;
socklen_t addrlen = sizeof(sockname);//一定要有初始值，为结构体大小，输入输出型参数。
for(i = 0; i < FD_SETSIZE; i++)//初始化conn数组
{
        conn[i] = -1;
}
while(1)//一个进程处理并发
{
        rset = allset;
        nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
        if(nready == -1)
        {
                //errno 是记录系统的最后一次错误代码。
                //EINTR错误的产生：当阻塞于某个慢系统调用的一个进程捕获某个信号且相应信号处理函数返回时，该系统调用可能返回一个EINTR错误。
                if(errno == EINTR)//如果被信号中断则继续
                        continue;
                ERR_EXIT("select");//其他错误退出
        }
        else if(nready == 0)
        {
                //时间超时,因为这里没有设置超时时间，理论不会出现nready == 0的情况
                continue;
        }
        if(FD_ISSET(listenfd, &rset))//判断监听套接口是否在集合当中,处理监听套接口的数据
        {
                int ret = -1;
                if((ret = accept(listenfd, (struct sockaddr *)&peeraddr, (socklen_t *)&peerlen)) < 0)
                {
                        ERR_EXIT("accept");
                }
                for(i = 0; i < FD_SETSIZE; i++)
                {
                        if(conn[i] < 0)
                        {
                                conn[i] = ret;
                                if(i > maxi)
                                        maxi = i;//最大不空闲套接口下标，优化遍历时间，提高效率
                                break;
                        }
                }
                if(i == FD_SETSIZE)
                {
                        //stderr标准错误
                        fprintf(stderr, "链接的客户端太多了... ...");
                        exit(EXIT_FAILURE);
                }
                //获取远程的地址
                if(0 > getpeername(ret , (struct sockaddr *)&sockname, (socklen_t*)&addrlen))
                {
                        perror("getsockname");
                        exit(EXIT_FAILURE);//退出程序
                }
                printf("远程的IP: %s, Port: %d\n", inet_ntoa(sockname.sin_addr), ntohs(sockname.sin_port));
                FD_SET(ret, &allset);//添加新的套接口到allset中下一次select会检测这个套接口
                if(maxfd < ret)//需要更新最大描述符
                        maxfd = ret;
                if(--nready <= 0)//已经处理完了监听套接口的事件，把nready减一操作，如果等于零，说明没有要处理的事件了，为了提高效率直接continue,如果不小于等于零，说明还有其他事件，即为连接客户端的事件，>然后对客户端的事件进行处理，
                        continue;
        }
        for(i = 0; i <= maxi; i++)
        {
                if(conn[i] == -1)
                        continue;
                if(FD_ISSET(conn[i], &rset))//判断是否在读的集合当中
                {
                        //读取数据
                        char recvbuf[1024] = {0};
                        int ret = readline(conn[i], recvbuf, 1024);
                        if(ret == -1)
                        {
                                ERR_EXIT("readline");
                        }
                        if(0 == ret)
                        {
                                printf("对方关闭了Socket readline\n");
                                FD_CLR(conn[i], &allset);//从allset中清除
                                conn[i] = -1;//标志为-1
                                continue;
                        }
                        printf("服务器接收到的数据:");
                        fputs(recvbuf, stdout);
                        writen(conn[i], recvbuf, strlen(recvbuf));//数据回射回去:
                        if(--nready <= 0)
                                break;
                }
        }
        FD_ZERO(&rset);//清空rset
}

NAME
       getsockopt, setsockopt - get and set options on sockets

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int getsockopt(int sockfd, int level, int optname,
                      void *optval, socklen_t *optlen);
       int setsockopt(int sockfd, int level, int optname,
                      const void *optval, socklen_t optlen);

DESCRIPTION
	getsockopt()  and setsockopt() manipulate options for the socket referred to by the file descriptor sockfd.  Options may exist at multiple protocol levels; they are always present at the uppermost socket level.
	When manipulating socket options, the level at which the option resides and the name of the option  must  be  specified.   To  manipulate options at the sockets API level, level is specified as SOL_SOCKET.  To manipulate options at any other level the protocol number of the appropriate protocol controlling the option is supplied.  For example, to indicate that an option is to be interpreted by the TCP protocol, level should be set to the protocol number of TCP; see getprotoent(3).
	The arguments optval and optlen are used to access option values for setsockopt().  For getsockopt() they identify a buffer  in  which  the  value  for the requested option(s) are to be returned.  For getsockopt(), optlen is a valueresult argument, initially containing the size of the buffer pointed to by optval, and modified on return  to  indicate the actual size of the value returned.  If no option value is to be supplied or returned, optval may be NULL.
	Optname  and  any  specified options are passed uninterpreted to the appropriate protocol module for interpretation. The include file <sys/socket.h> contains definitions for socket level options, described below.   Options  at  other protocol levels vary in format and name; consult the appropriate entries in section 4 of the manual.
	Most  socket-level  options utilize an int argument for optval.  For setsockopt(), the argument should be nonzero to enable a boolean option, or zero if the option is to be disabled.
	For a description of the available socket options see socket(7) and the appropriate protocol man pages.

RETURN VALUE
	On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.

ROLOG
       This  manual  page  is part of the POSIX Programmer's Manual.  The Linux implementation of this interface may differ
       (consult the corresponding Linux manual page for details of Linux behavior), or the interface may not be implemented
       on Linux.

NAME
       fcntl - file control

SYNOPSIS
       #include <unistd.h>
       #include <fcntl.h>

       int fcntl(int fildes, int cmd, ...);

DESCRIPTION
       The  fcntl()  function  shall  perform  the  operations described below on open files. The fildes argument is a file
       descriptor.

       The available values for cmd are defined in <fcntl.h> and are as follows:

F_DUPFD//复制文件描述符
	Return a new file descriptor which shall be the lowest numbered available (that is, not  already  open)  file descriptor  greater  than  or equal to the third argument, arg, taken as an integer of type int. The new file descriptor shall refer to the same open file description as the original file descriptor, and shall share any locks.  The  FD_CLOEXEC  flag  associated with the new file descriptor shall be cleared to keep the file open across calls to one of the exec functions.

F_GETFD//获取文件描述符
	Get the file descriptor flags defined in <fcntl.h> that are associated with the file descriptor fildes.  File descriptor  flags  are associated with a single file descriptor and do not affect other file descriptors that refer to the same file.

F_SETFD//设置文件描述符
	Set the file descriptor flags defined in <fcntl.h>, that are associated with fildes, to the  third  argument, arg,  taken as type int. If the FD_CLOEXEC flag in the third argument is 0, the file shall remain open across the exec functions; otherwise, the file shall be closed upon successful execution of one of  the  exec  func‐ tions.

F_GETFL//获取文件状态标志
	Get  the  file  status flags and file access modes, defined in <fcntl.h>, for the file description associated with fildes. The file access modes can be extracted from the return value using the mask O_ACCMODE, which  is defined in <fcntl.h>. File status flags and file access modes are associated with the file description and do not affect other file descriptors that refer to the same file with different open file descriptions.

F_SETFL//设置文件状态标志
	Set the file status flags, defined in <fcntl.h>, for the file description associated  with  fildes  from  the corresponding  bits in the third argument, arg, taken as type int. Bits corresponding to the file access mode and the file creation flags, as defined in <fcntl.h>, that are set in arg shall be ignored. If  any  bits  in arg other than those mentioned here are changed by the application, the result is unspecified.

F_GETOWN//获取当前接收SIGIO和SIGURG信号的进程嗯IO和进程组ID
	If  fildes  refers  to a socket, get the process or process group ID specified to receive SIGURG signals when out-of-band data is available. Positive values indicate a process ID; negative values, other than  -1,  indi‐cate a process group ID. If fildes does not refer to a socket, the results are unspecified.

F_SETOWN//设置当前接收SIGIO和SIGURG信号的进程嗯IO和进程组ID
        If  fildes  refers  to a socket, set the process or process group ID specified to receive SIGURG signals when out-of-band data is available, using the value of the third argument, arg, taken as type int. Positive values indicate  a process ID; negative values, other than -1, indicate a process group ID. If fildes does not refer to a socket, the results are unspecified.

       The following values for cmd are available for advisory record locking. Record locking shall be supported for  regular files, and may be supported for other files.
      
F_GETLK//获取文件锁
	Get  the  first  lock  which  blocks  the  lock description pointed to by the third argument, arg, taken as a pointer to type struct flock, defined in <fcntl.h>. The information retrieved shall overwrite the information passed  to  fcntl()  in the structure flock. If no lock is found that would prevent this lock from being created, then the structure shall be left unchanged except for the lock type which shall be set to F_UNLCK.

F_SETLK//设置文件锁
	Set or clear a file segment lock according to the lock description pointed to by  the  third  argument,  arg, taken  as  a pointer to type struct flock, defined in <fcntl.h>. F_SETLK can establish shared (or read) locks (F_RDLCK) or exclusive (or write) locks (F_WRLCK), as well as  to  remove  either  type  of  lock  (F_UNLCK). F_RDLCK, F_WRLCK, and F_UNLCK are defined in <fcntl.h>.  If a shared or exclusive lock cannot be set, fcntl() shall return immediately with a return value of -1.

F_SETLKW//与F_SETLK设置文件锁类似，不过等待返回
	This command shall be equivalent to F_SETLK except that if a shared or exclusive lock  is  blocked  by  other locks, the thread shall wait until the request can be satisfied. If a signal that is to be caught is received while fcntl() is waiting for a region, fcntl() shall be interrupted. Upon return  from  the  signal  handler, fcntl() shall return -1 with errno set to [EINTR], and the lock operation shall not be done.

int read_timeout(int fd, unsinged int wait_seconds)
{
        int ret = 0;
        if(wait_seconds > 0)
        {
                fd_set rset;
                FD_ZERO(&rset);
                FD_SET(fd, &rset);//把fd添加到集合当中
                struct timeval time;
                time.tv_sec = wait_seconds;
                time_tv_usec = 0;
                do
                {       //超时检测，时间到了，却未发生可读事件，返回0
                        ret = select(fd + 1, &rset, NULL, NULL, &timeout);
                }while(ret < 0 && errno == EINTR);//中断后重启
                //如果ret < 0 则说明select函数是被中断的
                //errno是记录程序的最后一次错误代码
                //EINTR:当阻塞于某个慢系统调用的一个进程捕获某个信号且相应信号处理函数返回时，该系统调用可能返回一个EINTR错误。（查看网络编程的day09）
                if(ret == 0)
                {
                        ret = -1;
                        errno = ETIMEOUT;
                }
                else if(ret == 1)
                {
                        ret = 1;
                }
        }
        return ret;
}

TAB就是制表符,单独拿出来做一节是因为这个东西确实很有用.
    >                 输入此命令则光标所在行向右移动一个tab.
    5>>                输入此命令则光标后5行向右移动一个tab.
    :12,24>            此命令将12行到14行的数据都向右移动一个tab.
    :12,24>>           此命令将12行到14行的数据都向右移动两个tab.
    那么如何定义tab的大小呢?有人愿意使用8个空格位,有人用4个,有的用2个.
    有的人希望tab完全用空格代替,也有的人希望tab就是tab.没关系,vim能
    帮助您.以下的配置一般也都先写入配置文档中,免得老敲.
    :set shiftwidth=4  配置自动缩进4个空格,当然要设自动缩进先.
    :set sts=4         即配置softtabstop为4.输入tab后就跳了4格.
    :set tabstop=4     实际的tab即为4个空格,而不是缺省的8个.
    :set expandtab     在输入tab后,vim用恰当的空格来填充这个tab.
命令模式
  	dG从前行一直删除到文件末尾。
	u：撤销操作，类似win的ctrl + z
	ctrl + r:重做上一个操作

#include <sys/time.h>
#include <sys/resource.h>

int getrlimit(int resource, struct rlimit *rlim);
int setrlimit(int resource, const struct rlimit *rlim);
int prlimit(pid_t pid, int resource, const struct rlimit *new_limit, struct rlimit *old_limit);

resource:这里是获取进程能够打开的最大文件描述符个数，所以第一个参数为，RLIMIT_NOFILE。
RLIMIT_NOFILE
	Specifies a value one greater than the maximum file descriptor number that can be  opened  by  this  process. Attempts  (open(2), pipe(2), dup(2), etc.)  to exceed this limit yield the error EMFILE.  (Historically, this limit was named RLIMIT_OFILE on BSD.)

第二个参数的结构体：使用时自己不需要再定义了。
    struct rlimit {
        rlim_t rlim_cur;  /* Soft limit */
        rlim_t rlim_max;  /* Hard limit (ceiling for rlim_cur) */
    };

RETURN VALUE
       On success, these system calls return 0.  On error, -1 is returned, and errno is set appropriately.

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/resource.h>

#define ERR_EXIT(err) {perror(err); exit(EXIT_FAILURE);}


int main()
{
        struct rlimit limit;
        if(-1 == getrlimit(RLIMIT_NOFILE, &limit))//获取本进程limit信息
        {
                ERR_EXIT("getrlimit");
        }
        printf("old: current = %lld max = %lld\n", limit.rlim_cur, limit.rlim_max);

        limit.rlim_cur = 2048;
        limit.rlim_max = 2048;

        if(-1 == setrlimit(RLIMIT_NOFILE, &limit))//重新设置
        {
                ERR_EXIT("setrlimit");
        }
        if(-1 == getrlimit(RLIMIT_NOFILE, &limit))//获取修改后的信息
        {
                ERR_EXIT("getrlimit");
        }
        printf("new: current = %lld max = %lld\n", limit.rlim_cur, limit.rlim_max);

        return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <signal.h>
#include <sys/select.h>

#define ERR_EXIT(err) {perror(err); exit(EXIT_FAILURE);}

//只作连接操作
int main()
{
        int tag = 0;
        while(1)
        {
                int sock;
                int i = 0;
                struct sockaddr_in servaddr;//一个服务器的地址

                sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
                if(sock < 0)
                {
                        perror("创建scoket失败\n");
                        exit(EXIT_FAILURE);//退出程序
                }
                memset(&servaddr, 0, sizeof(servaddr));//初始化地址
                servaddr.sin_family = AF_INET;//地址族
                servaddr.sin_port = htons(6000);//端口号，网络字节序转化为主机字节序
                servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");//指定服务端的地址

                int conn = -1;
                if((conn = connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0))
                {
                        printf("连接服务器失败\n");
                        exit(EXIT_FAILURE);
                }

                //获取本地的地址
                struct sockaddr_in sockname;
                socklen_t addrlen = sizeof(sockname);
                if(0 > getsockname(sock, (struct sockaddr *)&sockname, (socklen_t *)&addrlen))
                {
                        perror("getsockname");
                        exit(EXIT_FAILURE);//退出程序
                }
                tag++;
                printf("%d\n", tag);
        }
        return 0;
}

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {
    int   fd;         /* file descriptor */
    short events;     /* requested events */
    short revents;    /* returned events */
};
结构体的成员变量events：
The bits that may be set/returned in events and revents are defined in <poll.h>:

POLLIN //有数据可读时
	There is data to read.
POLLPRI
	There  is  urgent  data  to read (e.g., out-of-band data on TCP socket; pseudoterminal master in packet mode has seen state change in slave).

POLLOUT
	Writing now will not block.

POLLRDHUP (since Linux 2.6.17)
	Stream socket peer closed connection, or shut down writing half of connection.   The  _GNU_SOURCE  feature  test macro must be defined (before including any header files) in order to obtain this definition.

POLLERR
	Error condition (output only).

POLLHUP
	Hang up (output only).

POLLNVAL
	Invalid request: fd not open (output only).

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define ERR_EXIT(x) do{perror(x); exit(EXIT_FAILURE);}while(0)

void echo_srv(int sock)
{
	int ret = 0;
	char recvbuf[1024] = {0};
	struct sockaddr_in peeraddr;
	socklen_t peerlen = sizeof(peeraddr);
	while(1)
	{
		memset(recvbuf, 0, sizeof(recvbuf));
		ret = recvfrom(sock, recvbuf, 1024, 0, (struct sockaddr *)&peeraddr, &peerlen);
		if(ret < 0)
		{
			if(errno == EINTR)
				continue;
			ERR_EXIT("recvfrom");
			
		}
		else if(ret > 0)
		{
			fputs(recvbuf, stdout);
			sendto(sock, recvbuf, strlen(recvbuf), 0, (struct sockaddr *)&peeraddr, peerlen);
		}
	}
	close(sock);
}


int main()
{
	int sock = 0;
	sock = socket(PF_INET, SOCK_DGRAM, 0);//参数一表示为IPV4地址家族，第二个参数IPV4对应的UDP套接口，第三个参数0表示内核自动选择协议根据前两个可以确定通信协议为UDP的
	if(sock < 0)
	{
		ERR_EXIT("socket");
	}
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = 6000;
	//servaddr.sin_addr = htonl("127.0.0.1");//和下面的一样作用，绑定指定的地址，和绑定任意一个地址。
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	if(bind(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
		ERR_EXIT("bind");
	//不需要监听，直接连接的。
	echo_srv(sock);
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>

#define ERR_EXIT(x) do{perror(x); exit(EXIT_FAILURE);}while(0)

void echo_cli(int sock)
{
	struct sockaddr_in servaddr;
        memset(&servaddr, 0, sizeof(servaddr));
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = 6000;
	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");//绑定服务器地址
	if(connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)//连接后只能给指定的IP发送数据，则sendto可以不需要指定IP和端口了,UDP的connect是进行了一个弱绑定，不会进行三次握手和四次挥手
		ERR_EXIT("connect");
	int ret = 0;
	char sendbuf[1024] = {0};
	char recvbuf[1024] = {0};
	while(1)
	{
		memset(sendbuf, 0, sizeof(sendbuf));
		memset(recvbuf, 0, sizeof(recvbuf));
		if(fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
			ERR_EXIT("fgets");
		//sendto(sock, sendbuf, strlen(sendbuf), 0, NULL, 0);
		send(sock, sendbuf, strlen(sendbuf), 0);
		ret = recvfrom(sock, recvbuf, sizeof(recvbuf), 0, NULL, NULL);
		if(ret < 0)
		{
			if(errno == EINTR)
				continue;
			ERR_EXIT("recvbrom");
		}
		fputs(recvbuf, stdout);
	}
	
}

int main()
{
	int sock = 0;
	sock = socket(PF_INET, SOCK_DGRAM, 0);//参数一表示为IPV4地址家族，第二个参数IPV4对应的UDP套接口，第三个参数0表示内核自动选择协议根据前两个可以确定通信协议为UDP的
	if(sock < 0)
	{
		ERR_EXIT("socket");
	}
	echo_cli(sock);
	return 0;
}

SYNOPSIS
    #include <sys/epoll.h>

    int epoll_create(int size);
    int epoll_create1(int flags);

DESCRIPTION
	epoll_create()  creates  an  epoll(7)  instance.   Since  Linux 2.6.8, the size argument is ignored, but must be greater than zero; see NOTES below.
	epoll_create() returns a file descriptor referring to the new epoll  instance.   This  file descriptor  is  used  for  all the subsequent calls to the epoll interface.  When no longer required, the file  descriptor  returned  by  epoll_create()  should  be  closed  by  using close(2).   When  all file descriptors referring to an epoll instance have been closed, the kernel destroys the instance and releases the associated resources for reuse.

epoll_create1()
	If flags is 0, then, other than the fact  that  the  obsolete  size  argument  is  dropped, epoll_create1()  is  the  same  as  epoll_create().  The following value can be included in flags to obtain different behavior:

EPOLL_CLOEXEC
	Set the close-on-exec (FD_CLOEXEC)  flag  on  the  new  file  descriptor.   See  the description of the O_CLOEXEC flag in open(2) for reasons why this may be useful.

RETURN VALUE
	On  success,  these  system  calls  return  a nonnegative file descriptor.  On error, -1 is returned, and errno is set to indicate the error.

SYNOPSIS
       #include <sys/epoll.h>

       int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

DESCRIPTION
       This system call performs control operations on the epoll(7) instance referred to by the file descriptor epfd.  It requests that the operation op be performed for the target file descriptor, fd.

Valid values for the op argument are :

EPOLL_CTL_ADD
	Register the target file descriptor fd on the epoll instance referred to by the  file  descriptor epfd and associate the event event with the internal file linked to fd.

EPOLL_CTL_MOD
	Change the event event associated with the target file descriptor fd.

EPOLL_CTL_DEL
	Remove  (deregister)  the  target file descriptor fd from the epoll instance referred to by epfd. The event is ignored and can be NULL (but see BUGS below). The event argument describes the object linked to the file descriptor fd.   The  struct  epoll_event  is defined as :
	
    typedef union epoll_data {
        void        *ptr;
        int          fd;
        uint32_t     u32;
        uint64_t     u64;
    } epoll_data_t;

    struct epoll_event {
        uint32_t     events;      /* Epoll events */
        epoll_data_t data;        /* User data variable */
    };

//epoll_event成员events的参数
The events member is a bit set composed using the following available event types:

EPOLLIN
	The associated file is available for read(2) operations.

EPOLLOUT
	The associated file is available for write(2) operations.

EPOLLRDHUP (since Linux 2.6.17)
	Stream  socket  peer  closed  connection, or shut down writing half of connection.  (This flag is especially useful for writing simple code to detect peer shutdown when using Edge Triggered monitoring.)

EPOLLPRI
	There is urgent data available for read(2) operations.

EPOLLERR
	Error  condition  happened on the associated file descriptor.  epoll_wait(2) will always wait for this event; it is not necessary to set it in events.

EPOLLHUP
	Hang up happened on the associated file descriptor.  epoll_wait(2)  will  always  wait  for  this event; it is not necessary to set it in events.

EPOLLET
	Sets  the  Edge  Triggered behavior for the associated file descriptor.  The default behavior for epoll is Level Triggered.  See epoll(7) for more detailed information about Edge and Level  Triggered event distribution architectures.

EPOLLONESHOT (since Linux 2.6.2)
	Sets the one-shot behavior for the associated file descriptor.  This means that after an event is pulled out with epoll_wait(2) the associated file descriptor is internally disabled and no  other events  will  be  reported  by  the  epoll  interface.   The  user  must  call  epoll_ctl()  with EPOLL_CTL_MOD to rearm the file descriptor with a new event mask.

SYNOPSIS
	#include <sys/epoll.h>

	int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
	int epoll_pwait(int epfd, struct epoll_event *events,int maxevents, int timeout, const sigset_t *sigmask);

DESCRIPTION
	The  epoll_wait()  system call waits for events on the epoll(7) instance referred to by the file descriptor epfd.  The memory area pointed to by events will contain  the  events  that will  be available for the caller.  Up to maxevents are returned by epoll_wait().  The maxevents argument must be greater than zero.

	The timeout argument specifies the minimum number of milliseconds  that  epoll_wait()  will block.   (This  interval  will  be  rounded  up to the system clock granularity, and kernel scheduling delays mean that the blocking interval may overrun by a small amount.)  Specifying  a  timeout of -1 causes epoll_wait() to block indefinitely, while specifying a timeout equal to zero cause epoll_wait() to return immediately, even if no events are available.

The struct epoll_event is defined as :

    typedef union epoll_data {
        void    *ptr;
        int      fd;
        uint32_t u32;
        uint64_t u64;
    } epoll_data_t;

    struct epoll_event {
        uint32_t     events;    /* Epoll events */
        epoll_data_t data;      /* User data variable */
    };

	The data of each returned structure will contain  the  same  data  the  user  set  with  an epoll_ctl(2)  (EPOLL_CTL_ADD,EPOLL_CTL_MOD)  while  the  events  member  will  contain  the returned event bit field.

#define UNIX_PATH_MAX 108
struct sockaddr_un
{
    sa_family_t sun_family; //为AF_UNIX
    char sun_path[UNIX_PATH_MAX]; //pathname
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/un.h>

#define ERR_EXIT(x) do{perror(x); exit(EXIT_FAILURE);}while(0)

void echo_srv(int conn)
{
	int ret = 0;
	char recvbuf[1024] = {0};
	while(1)
	{
		memset(recvbuf, 0, sizeof(recvbuf));
		ret = read(conn, recvbuf, sizeof(recvbuf));
		if(ret < 0)
		{
			if(errno = EINTR)
				continue;
			 ERR_EXIT("read");
		}
		else if(ret == 0)
		{
			printf("对方关闭连接");
			break;
		}
		fputs(recvbuf, stdout);
		ret = write(conn, recvbuf, strlen(recvbuf));
	}
	close(conn);
}


int main()
{
	int conn;
	int listenfd;
	unlink("test_socket");//删除一个文件的目录项并减少它的链接数，若成功则返回0，否则返回-1，错误原因存于error。如果想通过调用这个函数来成功删除文件，你就必须拥有这个文件的所属目录的写和执行权
	if((listenfd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
		ERR_EXIT("socket");
	struct sockaddr_un servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sun_family = AF_UNIX;
	strcpy(servaddr.sun_path, "test_socket");
	if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)	
		ERR_EXIT("bind");
	if(listen(listenfd, SOMAXCONN) < 0)
		ERR_EXIT("listen");
	
	pid_t pid;
	while(1)
	{
		conn = accept(listenfd, NULL, NULL);	
		if(conn == -1)
		{
			//用户态资源并没有准备好，返回EINTR错误。以便用户态可以做出自己的决定。
			if(errno = EINTR)
				continue;
			ERR_EXIT("accept");
		}
		pid = fork();
		if(pid < 0)
			ERR_EXIT("fork");
		else if(pid == 0)//子进程处理新的连接
		{
			close(listenfd);//子进程不需要处理监听
			echo_srv(conn);
			exit(EXIT_SUCCESS);
		}
		close(conn);//父进程不需要处理连接
	}
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/un.h>

#define ERR_EXIT(x) do{perror(x); exit(EXIT_FAILURE);}while(0)

void echo_cli(int sock)
{
	int ret = 0;
	char sendbuf[1024] = {0};
	char recvbuf[1024] = {0};
	while(fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
	{
		ret = write(sock, sendbuf, sizeof(sendbuf));
		ret = read(sock, recvbuf, sizeof(recvbuf));
		fputs(recvbuf, stdout);
		memset(sendbuf, 0, sizeof(sendbuf));
		memset(recvbuf, 0, sizeof(recvbuf));
	}
	close(sock);
}
int main()
{
	int sock;
	if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
		ERR_EXIT("socket");
	struct sockaddr_un servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sun_family = AF_UNIX;
	strcpy(servaddr.sun_path, "test_socket");
	if(connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
		ERR_EXIT("connect");
	
	echo_cli(sock);
	return 0;
}

struct msghdr {
    void         *msg_name;       /* optional address */
    socklen_t     msg_namelen;    /* size of address */
    struct iovec *msg_iov;        /* scatter/gather array */与readv和writev有关，真正所发送的数据。struct iovec
    size_t        msg_iovlen;     /* # elements in msg_iov */发送的iovec()的个数
    void         *msg_control;    /* ancillary data, see below */辅助控制信息，为struct cmsghdr
    size_t        msg_controllen; /* ancillary data buffer len */
    int           msg_flags;      /* flags on received message */
};

// struct iovec *msg_iov;  
struct iovec {                    /* Scatter/gather array items */
    void  *iov_base;              /* Starting address */
    size_t iov_len;               /* Number of bytes to transfer */
};
//void	*msg_control;
struct cmsghdr {
    size_t cmsg_len;    /* Data byte count, including header (type is socklen_t in POSIX) */
    int    cmsg_level;  /* Originating protocol */
    int    cmsg_type;   /* Protocol-specific type */
    /* followed by 
    unsigned char cmsg_data[]; 
    */
};

ssize_t readv(int fd, const struct iovec *iov, int iovcnt);
ssize_t writev(int fd, const struct iovec *iov, int iovcnt);

#include <sys/socket.h>

struct cmsghdr *CMSG_FIRSTHDR(struct msghdr *msgh);
struct cmsghdr *CMSG_NXTHDR(struct msghdr *msgh, struct cmsghdr *cmsg);
size_t CMSG_ALIGN(size_t length);
size_t CMSG_SPACE(size_t length);
size_t CMSG_LEN(size_t length);
unsigned char *CMSG_DATA(struct cmsghdr *cmsg);

struct cmsghdr {
    size_t cmsg_len;    /* Data byte count, including header
    (type is socklen_t in POSIX) */
    int    cmsg_level;  /* Originating protocol */
    int    cmsg_type;   /* Protocol-specific type */
    /* followed by
    unsigned char cmsg_data[]; */
};

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


#define ERR_EXIT(x) do{perror(x); exit(EXIT_FAILURE);}while(0)


void send_fd(int sock_fd, int send_fd)
{
	int ret;
	struct msghdr msg;
	struct cmsghdr *p_cmsg;//struct msghdr的第五个成员变量msg_control的辅助控制信息,p_cmsg需要指向一块缓冲区
	struct iovec vec;
	char cmsgbuf[CMSG_SPACE(sizeof(send_fd))];//使用send_fd通过CMSG_SPACE算出来辅助空间的大小，CMEG_SPACE是一个宏.
	int * p_fds;
	char sendchar = 0;

	msg.msg_control = cmsgbuf;//将msg_control指向cmsgbuf辅助数据
	msg.msg_controllen = sizeof(cmsgbuf);//长度为sizeof(cmsgbuf)

	p_cmsg = CMSG_FIRSTHDR(&msg);//通过宏CMSG_FIRSTHDR获取msg里面的第一个消息,通过CMSGNXTHDR获取第二个消息，特此说明：是CMSGNXTHDR不是CMSGNEXTHDR这个宏的NEXT没有E。
	p_cmsg->cmsg_level = SOL_SOCKET;//和下面一句共同表示传递的是文件描述字
	p_cmsg->cmsg_type = SCM_RIGHTS;
	p_cmsg->cmsg_len = CMSG_LEN(sizeof(send_fd));//通过宏得到长度
	p_fds = (int *)CMSG_DATA(p_cmsg);//得到数据的首地址
	*p_fds = send_fd;//真正的存放数据的步骤。
	
	//填充struct msghdr结构体变量msg
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_iov = &vec;
	msg.msg_iovlen = 1;//发送一个字符所以为1
	msg.msg_flags = 0;

	//填充struct iovec结构体变量vec
	vec.iov_base = &sendchar;//因为只发送一个字符
	vec.iov_len = sizeof(sendchar);//大小为一个字节

	//数据终于在这里填充完毕了，可以发送数据了
	ret = sendmsg(sock_fd, &msg, 0);
	if(ret != 1)
	{
		ERR_EXIT("sendmsg");
	}
}

int  recv_fd(int sock_fd)
{
	int ret;
	struct msghdr msg;
	char recvchar;
	struct iovec vec;
	int recv_fd;
	char cmsgbuf[CMSG_SPACE(sizeof(send_fd))];//使用send_fd通过CMSG_SPACE算出来辅助空间的大小，CMEG_SPACE是一个宏.
	struct cmsghdr *p_cmsg;//struct msghdr的第五个成员变量msg_control的辅助控制信息,p_cmsg需要指向一块缓冲区
	int * p_fds;

	//填充struct iovec结构体变量vec
	vec.iov_base = &recvchar;//因为只发送一个字符
	vec.iov_len = sizeof(recvchar);//大小为一个字节

	//填充struct msghdr结构体变量msg
	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_iov = &vec;
	msg.msg_iovlen = 1;//发送一个字符所以为1
	msg.msg_flags = 0;
	msg.msg_control = cmsgbuf;//将msg_control指向cmsgbuf辅助数据
	msg.msg_controllen = sizeof(cmsgbuf);//长度为sizeof(cmsgbuf)
	msg.msg_flags = 0;

	p_fds = (int *)(CMSG_DATA(CMSG_FIRSTHDR(&msg)));//得到数据的首地址
	*p_fds = -1;//真正的存放数据的步骤。

	//数据终于在这里填充完毕了，可以接收数据了
	ret = recvmsg(sock_fd, &msg, 0);
	if(ret != 1)
	{
		ERR_EXIT("recvmsg");
	}
	p_cmsg = CMSG_FIRSTHDR(&msg);
	if(p_cmsg == NULL)
	{
		-ERR_EXIT("CMSG_FIRSTHDR");
	}
	
	p_fds = (int *)CMSG_DATA(p_cmsg);
	recv_fd = *p_fds;
	if(recv_fd == -1)
	{
		ERR_EXIT("CMSG_DATA");
	}
	return recv_fd;
}

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/un.h>
#include "sendmsg.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


#define ERR_EXIT(x) do{perror(x); exit(EXIT_FAILURE);}while(0)

void send_fd(int sock_fd, int send_fd);
int  recv_fd(int sock_fd);

int main()
{
	int sockfds[2];
	if(socketpair(PF_UNIX, SOCK_STREAM, 0, sockfds) < 0)
		ERR_EXIT("sockfdsetpair");
	pid_t pid;
	pid = fork();
	if(pid < 0)
	{
		ERR_EXIT("fork");
	}
	else if(pid == 0)
	{
		//close(sockfds[1]);
		int fd;
		fd = open("text.txt", O_RDONLY);
		if(fd == -1)
		{
			ERR_EXIT("open");	
		}
		send_fd(sockfds[0], fd);
	}
	else
	{
		char buf[1024];
		//close(sockfds[0]);
		int fd = recv_fd(sockfds[1]);
		read(fd, buf, sizeof(buf));
		printf("buf = %s\n", buf);
	}
	return 0;
}

package main

import "fmt"

/*
 * 三种不同的打印语句
 * 1. fmt.Println()，可以打印字符串和变量，输出后自动增加一个换行
 * 2. fmt.Printf()，格式化输出
 * 3. fmt.Print()，打印字符串常量
 **/

func main() { // { 不能单独放一行
	var i int
	for i = 1; i <= 9; i++ {
		for j := 1; j <= i ; j++ {
			// fmt.Print(i, "*", j, "=", i*j, "  ")
			fmt.Printf("%d * %d =%2d ", i, j, i*j)
			// fmt.Println(i, "*", j, "=", i*j, "  ") // 最后会换行，无法格式打印9x9乘法表
		}
		fmt.Println()
	}
}