void urg_handler(int signo) {
	int n;
	char c;
	if ( (n = recv(server_fd, &c, 1, MSG_OOB)) < 0) {
		if (errno != EWOULDBLOCK) ERR_EXIT("recv error");
	}
	printf("receive heart beat packet from server\n");
	nprobes = 0;
	return ;
}

InetAddress InetAddress::getLocalAddress(int sockfd)
{
    struct sockaddr_in addr;
    socklen_t len = sizeof addr;
    if(::getsockname(sockfd, (SA*)&addr, &len) == -1)
    {
        ERR_EXIT("getsockname");
    }
    return InetAddress(addr);
}

// 开启套接字fd接收带外数据的功能
void activate_oobinline(int fd)
{
	int oob_inline = 1;
	int ret;
	ret = setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &oob_inline, sizeof(oob_inline));
	if (ret == -1)
	{
		ERR_EXIT("setsockopt");
	}
}

int main(int argc, const char *argv[])
{
    int fd = open("3.txt", O_WRONLY | O_CREAT | O_EXCL, 0666);
    if(fd == -1)
        ERR_EXIT("open");
    char buf[1024] = "wang si ke shi yi ge hao gu niang.";
    write(fd, buf, sizeof(buf));
    close(fd);
    return 0;
}

int main(int argc, const char *argv[])
{
    int peerfd = socket(PF_INET, SOCK_STREAM, 0);
    if(peerfd == -1)
        ERR_EXIT("socket");

    struct sockaddr_in peeraddr;
    peeraddr.sin_family = AF_INET;
    peeraddr.sin_port = htons(8080);
    peeraddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if((connect(peerfd, (struct sockaddr*)&peeraddr, sizeof peeraddr)) < 0)
        ERR_EXIT("connect");

    do_service(peerfd);

    close(peerfd);
    return 0;
}

/* 
 * ===  FUNCTION  ======================================================================
 *         Name:  myftw
 *  Description:  
 * =====================================================================================
 */
static int myftw(char *pathname,Myfunc *func){
    fullpath = malloc(sizeof(char)*pathlen);
    if(pathlen <= strlen(pathname)){
        pathlen = strlen(pathname) * 2;
        if((fullpath = realloc(fullpath,pathlen))==NULL)
            ERR_EXIT("relloc failed");
    }
    strcpy(fullpath,pathname);
    return(dopath(func));
}

int main(int argc, const char *argv[])
{
    if(signal(SIGPIPE, SIG_IGN) == SIG_ERR)
        ERR_EXIT("signal");
    int fd_server;
    preprocess(&fd_server);
    do_epoll(fd_server); 
    close(fd_server);
    return 0;
}

int TcpClient(const char* host, uint64_t port)//return peerfd
{
	int peerfd = socket(PF_INET, SOCK_STREAM, 0);		
	if(peerfd == -1)
		ERR_EXIT("socket");	
	
	if(port == 0)//if port=0 then no need to bind
		return peerfd;
	SetAddReuse(peerfd, 1);//add reuse

	SAI addr;	
	memset(&addr, 0, sizeof addr);	
	addr.sin_family = AF_INET; 
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = inet_addr(host);
	if(bind(peerfd, (SA*)&addr, sizeof addr) == -1)
		ERR_EXIT("bind client");
	return peerfd;
}

void SetPortReuse(int sockfd, int optval)//port reuse
{
#ifdef SO_REUSEPORT
    int on = (optval != 0) ? 1 : 0;
    if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0)
        ERR_EXIT("setsockopt SO_REUSEPORT");
#else
    fprintf(stderr, "SO_REUSEPORT is not supported.\n");
#endif //SO_REUSEPORT
}

/*
 * Init dump tool backends
 */
void dt_init(void)
{
	struct dt *dt;
	int i = 0;

	while ((dt = dt_vec[i])) {
		g.fh = zg_open(g.opts.device, O_RDONLY, ZG_CHECK);
		if (!S_ISBLK(g.fh->sb.st_mode))
			ERR_EXIT("Please specify DASD or SCSI device node"
				 "(e.g. /dev/dasdd or /dev/sda )");
		if (dt->init() == 0) {
			l.dt = dt;
			return;
		}
		zg_close(g.fh);
		i++;
	}
	ERR_EXIT("No dump tool found on \"%s\"", g.opts.device);
}

int main(int argc, char *argv[])
{
	int msgid;
	msgid = msgget(1234, 0);
	if (msgid == -1)
		ERR_EXIT("msgget");

	echo_cli(msgid);
	return 0;
}

void set_minprivilage(void)
{
    struct passwd* pwd = getpwnam("nobody");
    if ( NULL == pwd )
        ERR_EXIT("getpwnam error");
    if ( -1 == setegid(pwd->pw_gid))
        ERR_EXIT("setegid error"); 
    if ( -1 == seteuid(pwd->pw_uid))
        ERR_EXIT("seteuid error"); 

    struct __user_cap_header_struct cap_header;
    cap_header.version = _LINUX_CAPABILITY_VERSION_1;
    cap_header.pid = 0;
    struct __user_cap_data_struct cap_data;
    cap_data.effective = cap_data.permitted = 1 << CAP_NET_BIND_SERVICE;
    cap_data.inheritable = 0;
    if ( -1 == capset(&cap_header,&cap_data))
        ERR_EXIT("capset error");
}

int main(int argc, const char *argv[])
{
    int iret;
    if(argc == 1){
        ERR_EXIT("too few args");
    }else{
        iret = mkdir(argv[1], 0777);
    }
    return 0;
}

void priv_sock_init(session_t *sess)
{
    int fds[2];
    /* 创建一对UNIX域的套接字，用于进程间通信 */
    if(socketpair(PF_UNIX, SOCK_STREAM, 0, fds) == -1)
        ERR_EXIT("socketpair");

    sess->nobody_fd = fds[0];
    sess->proto_fd = fds[1];
}

int main(int argc, const char *argv[])
{
    int fd = open("test.txt", O_RDONLY, 0666);
    if(fd == -1)
        ERR_EXIT("open");

    char buf[1024] = {0};
    int ret = read(fd, buf, 5);
    if(ret == -1)
        ERR_EXIT("read");
    printf("buf ---- %s\n", buf);

    off_t len = lseek(fd, 0, SEEK_CUR);
    printf("len ---- %d\n", (int)len);

    len = lseek(fd, 5, SEEK_CUR);
    printf("len ---- %d\n", (int)len);
    return 0;
}

int main(int argc, char* argv[])
{
    int peerfd = socket(AF_INET, SOCK_STREAM, 0);
    if(peerfd == -1)
    {
        ERR_EXIT("socket");
    }
    struct sockaddr_in client_addr;
    memset(client_addr, 0, sizeo(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = inet_addr("192.168.175.128");
    client_addr.sin_port = htons(9999);
    socklen_t sock_len = sizeof(client_addr);
    if(-1 == connect(sockdf, (struct sockaddr&)*client_addr, sock_len))
    {
        ERR_EXIT("connect");
    }
    do_service(peerfd);
}

int sem_setval(int semid, int val)
{
	union semun su;
	su.val = val;
	int ret;
	ret = semctl(semid, 0, SETVAL, su);
	if(ret == -1)
	  ERR_EXIT("semctl");
	return 0;
}

int main() {
    int listen_fd;
    // create a socket for listening
    if ((listen_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
        ERR_EXIT("socket function return negative");
    }
    unlink(SOCKET_FILE);
    struct sockaddr_un server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sun_family = AF_UNIX;
    strcpy(server_addr.sun_path, SOCKET_FILE);
    // bind a address to the listening socket for clients to connect
    if (bind(listen_fd, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0) {
        ERR_EXIT("bind error");
    }
    // start to listen for connecting request
    if (listen(listen_fd, SOMAXCONN) < 0) {
        ERR_EXIT("listen error");
    }

    while (1) {
        // create a new socket, which implies a new connection between server and client
        int conn_fd = accept(listen_fd, NULL, NULL);
        if (conn_fd == -1) {
            if (conn_fd == EINTR) continue;
            ERR_EXIT("acccept error");
        }

        pid_t pid = fork();
        if (pid == -1) {
            ERR_EXIT("fork error");
        }
        if (pid == 0) {
            close(listen_fd);
            echo_server(conn_fd);
            exit(EXIT_SUCCESS);
        }

        close(conn_fd);
    }

    return 0;
}

int main(void)
{
	int sock;
	if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
		ERR_EXIT("socket");

	echo_cli(sock);

	return 0;
}

long get_time_sec()
{
	int ret = gettimeofday(&s_curr_time, NULL);
	if (ret < 0)
	{
		ERR_EXIT("gettimeofday");
	}
	return s_curr_time.tv_sec;
	
}