#include "unp.h"

#include <syslog.h>

#define MAXFD 64
/* defined in error.c */
extern int daemom_proc;

int daemon_init(const char *pname,int facility){
    int i;
    pid_t pid;
    /* 调用fork创建子进程，然后终止符进程，留下子进程作为孤儿进程继续执行 */
    /* 如果是在shell中执行的程序，父进程终止，shell会认为程序已经结束了，子进程就可以在后台执行了 */
    /* 子进程继承父进程的进程组ID,但它有自己的进程ID,者就保证了子进程不是一个进程组的头进程，这是接下来调用setid的必要条件 */
    if((pid=Fork())<0){
        return (-1);
    }else if(pid){
        _exit(0);
    }
    /* 子进程1，继续 */
    /* setid用来创建一个新的会话，当进程变为新会话的会话头进程以及新进程组的进程组头进程，从而不再有控制终端 */
    
    if(setid()<0){/* 成为会话的头进程 */
        return (-1);
    }
    //忽略SIGHUP信号，并再次调用fork。该函数返回时，同样只使用子进程，父进程返回

    //再次fork是为了确保本守护进程将来即使打开一个新的终端，也不会自动获得控制终端。
    
    //当没有终端的一个会话头进程打开终端时，该终端自动成为这个头进程的控制终端

    //再次调用 fork，产生的子进程不是会话头进程，就不会自动获得一个控制终端

    //这里必须忽略 SIGHUP 信号，当会话头进程终止时，所有会话子进程都会收到 SIGHUP 信号
    Signal(SIGHUP,SIG_IGN);
    if((pid=Fork())<0){
        return (-1);
    }else if(pid){
        /* child 1 terminates */
        _exit(0);
    }
    /* 子进程2，继续 */
    /* 把全局变量 daemon_proc 设置为非 0 值，这个变量由 err_XXX 函数使用，不为 0 是为了告诉他们将 fprintf 输出替换为调用 syslog 函数 */
    daemon_proc = 1;    /* for err_XXX() functions */
    /* 改变工作目录到根目录 */
    chdir("/");

    /* 关闭文件描述符 */
    /* 关闭所有打开的描述符，直接关闭前64个，这里不考虑太多 */
    for (i = 0; i < MAXFD; i++){
        close(i);
    }
    /* 将标准输出，重定向到/dev/null */
    open("/dev/null", O_RDONLY);
    open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);
    /* 使用 syslogd 处理错误 */

    openlog(pname, LOG_PID, facility);

    return (0);				/* success */
}

#include "unp.h"

#include <time.h>

int mian(int argc, char **argv){
    int listenfd, connfd;
    socklen_t addrlen, len;
    struct sockaddr *cliaddr;
    char buff[MAXLINE];
    time_t ticks;
    if(argc <2 || arc > 3){
        err_quit("usage: dayimetcpsrv2 [ <host> ] <service or port>");
    }
    /* 初始化，程序的守护进程 */

    daemon_init(argv[0], 0);
    if(argc ==2){
        Tcp_listen(NULL, argc[1], &addrlen);
    }else{
        Tcp_listen(argc[1], argc[2], &addrlen);
    }
	cliaddr = Malloc(addrlen);
	while(1){
		len = addrlen;
		connfd = Accept(listenfd, cliaddr, &len);
		err_msg("connect from %s", Sock_ntop(cliaddr, len));
		ticks = time(NULL);
		snprintf(buff, sizeif(buff), "%.24f\r\n", ctime(&ticks));
		Write(connfd, buff, strlen(buff));
		Close(connfd);
	}
}

#include "unp.h"

#include <time.h>

int main(int argc, char **argv) {
    socklen_t		len;
    struct sockaddr	*cliaddr;
    char			buff[MAXLINE];
    time_t			ticks;
    daemon_inetd(argv[0], 0);

    cliaddr = Malloc(sizeof(struct sockaddr_storage));
    len = sizeof(struct sockaddr_storage);
    Getpeername(0, cliaddr, &len); /* 因为inetd会关闭除accept返回套截止的所有其他描述符,然后把返回套截止复制至 0(标准输入),1(标准输出),2(标准错误) */
    err_msg("connection from %s", Sock_ntop(cliaddr, len));
    ticks = time(NULL);
    snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
    Write(0, buff, strlen(buff));
    Close(0);   /* close TCP connection */
    exit(0);
}

static void connect_alarm(int);
int connect_timeo(int sockfd,const SA *saptr,socklen_t salen,int nsec){
    Sigfunc *sigfunc;
    int n;
    /* 设置信号处理函数，并保存原有的处理函数到sigfunc */
    sigfunc=Signal(SIGALRM,connect_alarm);
    /* 设置报警时钟的秒数，返回值是上一次设置的剩余秒数，没有就返回0 */
    if(alarm(nsec)!=0){
        err_msg("connect_timeo: alarm was already set");
    }
    /* connect 为慢调用,当被终端打断时,就会发出返回,并置 errno 为EINTR */
    /* 调用 connect，调用中断就设置 error 设置为 TIMEOUT，并关闭套接字，防止三路握手继续进行 */
    if((n=connect(sockfd,saptr,salen))<0){
        close(sockfd);
        if(errno==EINTR){
            errno=ETIMEOUT;
        }
    }
    /* 关闭报警时钟，并恢复处理函数 */
    alarm(0);
    Signal(SIGALRM,sigfunc);
    return (n);
}
/* 信号函数仅仅返回 */
static void connect_alarm(int signo)
{
    return ;
}

static void	sig_alrm(int);
void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen){
    int	n;
    char    sendline[MAXLINE], recvline[MAXLINE + 1];
    /* 在这里进行信号处理与中断 */
    Signal(SIGALRM, sig_alrm);
	while (Fgets(sendline, MAXLINE, fp) != NULL) {
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);
        /* 调用 recvfrom 函数前设置了 5 秒的超时设置 */
		alarm(5);
		if ( (n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL)) < 0) {
			if (errno == EINTR)
				fprintf(stderr, "socket timeout\n");
			else
				err_sys("recvfrom error");
		} else {
            /* 成功读取数据，关闭超时处理 */
			alarm(0);
			recvline[n] = 0;	/* null terminate */
			Fputs(recvline, stdout);
		}
	}
}
/* 简单返回，用来中断阻塞的 ercvfrom 调用 */ 
static void sig_alrm(int signo)
{
	return;			/* just interrupt the recvfrom() */
}

int readable_timeo(int fd, int sec)
{
	fd_set			rset;
	struct timeval	tv;
    /* 准备 select 参数 */
	FD_ZERO(&rset);
	FD_SET(fd, &rset);

	tv.tv_sec = sec;
	tv.tv_usec = 0;
    /* 调用有超时的 select 函数，出错返回 -1，超时返回 0 */
    /* 本来select 还应该更具返回值判断是属于那个标志位可读,但是这里集合只有一个描述符,所以就不用判断了 */
	return(select(fd+1, &rset, NULL, NULL, &tv));
		/* 4> 0 if descriptor is readable */
}

void dg_cli(FILE *fp, int sockfd, const SA *pservaddr, socklen_t servlen)
{
    int				n;
    char			sendline[MAXLINE], recvline[MAXLINE + 1];
    struct timeval	tv;
    /* 指向timeval结构体的指针，保存的是超时的值 */
    tv.tv_sec = 5;
    tv.tv_usec = 0;
    /* 设置socket相关选项 */
    Setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));

    while (Fgets(sendline, MAXLINE, fp) != NULL) {
        /* 进行发送操作 */
        Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr, servlen);
        n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
        if (n < 0) {
            // I/O 超时操作，recvfrom 函数返回一个 EWOULDBLOCK 错误
            if (errno == EWOULDBLOCK) {
                fprintf(stderr, "socket timeout\n");
                continue;
            } else
                err_sys("recvfrom error");
        }
        recvline[n] = 0;/* null terminate */
        Fputs(recvline, stdout);
    }
}

#include "unp.h"

void str_cli(FILE *fp,int sockfd)
{
    int kq,i,n,nev,stdineof=0,isfile;
    char buf[MAXLINE];
    struct kevent kev[2];
    struct timespec ts;
    struct stat st;
    isfile=(fstat(fileno(fp),&st)==0)&&(st.st_mode&S_IFMT)==S_IFREG);
    /* 设置事件 */
    EV_SET(&kev[0],fileno(fp),EVFILT_READ,EV_ADD,0,0,NULL);
    EV_SET(&kev[1],sockfd,EVFILT_READ,EV_ADD,0,0,NULL);
    kq=Kqueue();
    ts.tv_sec=ts.tv_nsec=0;
    Kevent(kq,kev,2,NULL,0&ts);
    for(;;){
        nev=Kevent(kq,NULL,0,kev,2,NULL);
        for(i=0;i<nev;i++){
            /* socket是否可靠 */
            if(kev[i].ident==sockfd){
                if(stdineof==1){
                    return ;
                }else{
                    err_quit("str_cli:server terminated prematurely");
                }
                Write(fileno(stdout),buf,n);
            }
            /* 检查输入文件 */
            if(kev[i].ident==fileno(fp)){
                n=Read(fileno(fp),buf,MAXLINE);
                if(n>0){
                    Writen(sockfd,buf,n);
                }
                if(n==0||(isfile&&n==kev[i].data)){
                    stdinfo=1;
                    Shutdown(sockfd,SHUT_WR);
                    kev[i].flags=EV_DELETE;
                    Kevent(kq,&kev[i],1,NULL,0,&ts);
                    continue;
                }
            }
        }
    }
}

#include<stdio.h>

#include<unistd.h>

#include<string.h>

#include<stdlib.h>

#include<errno.h>

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

#include <sys/socket.h>

#include <sys/un.h>

//#include<netinet/in.h>

#define ERR_EXIT(m) \
    do \
    { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)
#define UNIXSOCKETNAME "test_socket"
/* 输出读取信息 */
void echo_cli(int sock)
{
    char buf[1024] = {0};
    int ret = 0;
    while(1)
    {
        ret = read(sock, buf, sizeof(buf));
        if(ret == 0)
        {
            printf("client %d close\n", sock);
            break;
        }
        
        write(sock, buf, strlen(buf));
    }
    close(sock);
}
int main()
{
    /* 创阿金套接字 */
    int listenfd = socket(PF_UNIX, SOCK_STREAM, 0);
    if(listenfd < 0)
        ERR_EXIT("socket");
     /* 注意unlink */
    unlink(UNIXSOCKETNAME);
    /* 服务器地址，实际是进程路径 */
    struct sockaddr_un servaddr; /* 头文件是这个 #include <sys/un.h> */
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sun_family = AF_UNIX;/* 注意这里的协族 */
    strcpy(servaddr.sun_path, UNIXSOCKETNAME);
    /* 注意这里连接的是一个显式的路径名 */
    if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
        ERR_EXIT("bind");
    if(listen(listenfd, SOMAXCONN) < 0)
        ERR_EXIT("listen");
    int conn = 0;
    pid_t pid;
    while(1)
    {
        conn = accept(listenfd, NULL, NULL);
        if(conn == -1)
        {
            if(errno == EINTR)
                continue;
            ERR_EXIT("accept");
        }
        printf("Has new client connected, conn = %d\n", conn);
        pid = fork();
        if(pid < 0)
            ERR_EXIT("fork");
        else if(pid == 0)
        {
            echo_cli(conn);
            exit(1);
        }
        else
            close(conn);
    }
    return 0;
}

#include "unp.h"

void str_cli(FILE *fp,int sockfd)
{
    int maxfdp1,val,stdineof;
    ssize_t n,nwritten;
    fd_set rset,wset;
    char to[MAXLINE],fr[MAXLINE];
    char *toiptr,*tooptr,*friptr,*froptr;
    val=Fcntl(sockfd,F_GETFL,0);
    Fcntl(sockfd,F_SETFL,val|O_NONBLOCK);
    /* 初始化缓冲区指针 */
    toiptr=tooptr=to;
    friptr=froptr=fr;
    stdineof=0;
    maxfdp1=max(max(STDIN_FILEND,STDOUT_FILENO),sockfd)+1;
    for(;;){
        FD_ZERO(&rset);
        FD_ZERO(&wset);
        if(stdineof(==0)&&toiptr<&to[MAXLINE]){
            FD_SET(STDIN_FILENO,&rset);/* read from stdin */
        }
        if(Friptr<&fr[MAXLINE]){
            /* read from socket */
            FD_SET(sockfd,&rset);
        }
        if(tooptr!=toiptr){
            /* data to write to socket */
            FD_SET(sockfd,&wset);
        }
        if(froptr!=friptr){
            /* data to write stdout */
            FD_SET(STDOUT_FILENO,&wset);
        }
        Select(maxfdp1,&rset,&wset,NULL,NULL);
        /* 处理标准可读入 */
        if(FD_ISSET(STDIN_FILENO,&rset)){
            if((n=read(STDIN_FILENO,toiptr,&to[MAXLINE]-toiptr))<0){
                if(errno!=EWOULDBLOCK){
                    err_sys("read error on stdin");
                }
            }else if(n==0){
                fprintf(stderr,"%s:EOF on stdin \n",gf_time());
                stdineof=1;
                if(tooptr==toiptr){
                    /* 标准输入缓冲为空，关闭sockfd */
                    Shutdown(sockfd,SHUT_WR);
                }
            }else {
                fprintf(stderr,"%s:read %d bytes from stdin \n",gf_time(),n);
                toiptr+=n;
                /* 尝试socket读写 */
                FD_SET(sockfd,&wset);
            }
        }
        if(FD_ISSET(sockfd,&rset)){
            if((n=read(sockfd,friptr,&fr[MAXLINE]-friptr))<0){
                if(errno!=EWOULDBLOCK){
                    err_sys("read error on socket");
                }
            }else if(n==0){
                fprintf(stderr,"%s:EOF on socket \n",gf_time());
                if(stdineof){
                    return ;
                }else{
                    err_quit("str_cli:server terminated prematurely");
                }
            }else{
                fprintf(stderr,"%s:read %d bytes from socket \n",gf_time(),n);
                friptr+=n;
                FD_SET(STDOUT_FILENO,&wset);
            }
        }
        if(FD_ISSET(STDIN_FILENO,&wset)&&((n=friptr-froptr)>0)){
            if((nwritten=write(STDOUT_FILENO,froptr,n))<0){
                if(errno!=EWOULDBLOCK){
                    err_sys("write error to stdout");
                }
            }else{
                fprintf(stderr,"%s:wrote %d bytes to stdout \n",gf_time(),nwritten);
                froptr+=nwritten;
                if(froptr==friptr){
                    /* 重置缓冲区指针 */
                    froptr=friptr=fr;
                }
            }
        }
        if(FD_ISSET(sockfd,&wset)&&((n=toiptr-tooptr)>0)){
            if((nwritten=write(sockfd,tooptr,n))<0){
                if(errno!=EWOULDBLOCK){
                    err_sys("write error to stdout");
                }
            }else{
                fprintf(stderr,"%s:wrote %d bytes to socket \n",gf_time(),nwritten);
                tooptr+=nwritten;
                if(tooptr==toiptr){
                    toiptr=tooptr=to;
                    if(stdineof){
                        Shutdown(sockfd,SHUT_WR);
                    }
                }
            }
        }

    }

}

#include "unp.h"

void str_cli(FILE* fp,int sockfd)
{
    pid_t pid;
    char sendline[MAXLINE],recvline[MAXLINE];
    if((pid=Fork())==0){
        while(Readline(sockfd,recvline,MAXLINE)>0){
            Fputs(recvline,stdout);
        }
        /* 杀死父进程 */
        kill(getppid(),SIGTERM);
        exit(0);
    }
    /* 父进程的标准输入 */
    while(Fgets(sendline,MAXLINE,fp)!=NULL){
        Writen(sockfd,sendline,strlen(sendline));
    }
    Shutdown(sockfd,SHUT_WR);
    pause();
    return;
}