int main(int argc,char **argv)
{
	int i,fd;
	unsigned char c,*ptr;
	struct stat stat;
	
	if(argc!=2)
		err_quit("usgae: shmread <name>");
	fd=Shm_open(argv[1],O_RDONLY,FILE_MODE);
	Fstat(fd,&stat);
	ptr=Mmap(NULL,stat.st_size,PROT_READ,MAP_SHARED,fd,0);

	Close(fd);

	for(i=0;i<stat.st_size;i++)
		if((c=*ptr++)!=(i%256))
			err_ret("ptr[%d] =%d",i,c);
	exit(0);
}

int
swap_straddr(char *src, char *dst)
{
	char a[3];
	int i, slen;
	char *crow, *tmp, *atom;
	int count = 0, offset = 0;

	slen = strlen(src);
	if (slen > DNS_MAX_HNAME_LEN)
		goto mlf_addr;
	tmp = src;
	for (i = 0; i < 4; i++) {
		count = 0;
		atom = a;
		while (*tmp && *tmp != '.') {
			if (count > 2)
				goto mlf_addr;
			*atom++ = *tmp++;
			count++;
		}
		if (!count)
			goto mlf_addr;
		crow = dst + slen - count - offset;
		strncpy(crow, a, count);
		offset += count;
		if (!(*tmp))
			break;
		else {
			if (i == 3)
				goto mlf_addr;
			*(crow - 1) = '.';
			offset++;
			tmp++;
		}

	}
	*(dst + slen) = 0;
	return 0;
  mlf_addr:
	debug(DBG_INSANE, "in swap_straddr: invalid address `%s`.\n", src);
	err_ret(ERR_DNSMDD, -1);
}

/* 
 * Descend through the hierachy, starting at "fullpath".
 * If "fullpath" is anything other than a directory, we lstat() it,
 * recursively for each name in the directory.
 */
static int dopath(Func *func)
{
	struct stat statbuf;
	struct dirent *dirp;
	DIR *dp;
	int ret, n;

	if (lstat(fullpath, &statbuf) < 0) /* stat error */
		return (func(fullpath, &statbuf, FTW_NS));
	if (S_ISDIR(statbuf.st_mode) == 0) /* not a directory */
		return (func(fullpath, &statbuf, FTW_F));

	/*
	 * It's a directory. First call func() for the directory,
	 * then process each filename in the directory.
	 */
	if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
		return (ret);
	n = strlen(fullpath);
	if (n + NAME_MAX + 2 > pathlen) { /* expand path buffer */
		pathlen *= 2;
		if ((realloc(fullpath, pathlen)) == NULL)
			err_sys("realloc failed");
	}
	fullpath[n++] = '/';
	fullpath[n] = 0;

	if ((dp = opendir(fullpath)) == NULL) /* cannot read directory */
		return(func(fullpath, &statbuf, FTW_DNR));

	while ((dirp = readdir(dp)) != NULL) {
		if (strcmp(dirp->d_name, ".") == 0 ||
		    strcmp(dirp->d_name, "..") == 0)
			continue; /* ignore dot and dot-dot */
		strcpy(&fullpath[n], dirp->d_name); /* append after "/" */
		if ((ret = dopath(func)) != 0)
			break;	/* time to leave */
	}
	fullpath[n-1] = 0;	/* erase everything from slash onward */
	if (closedir(dp) < 0)
		err_ret("Cannot close dir: %s", fullpath);
	return ret;
}

/*
 * Descend through the hierarchy, starting at "fullpath".
 * If "fullpath" is anything other than a directory, we lstat() it,
 * call func(), and return. For a directory, we all ourself
 * recursively for each name in the directory.
 */
static int dopath(Myfunc* func)             /* we return whatever func() returns */
{   
    struct stat         statbuf;
    struct dirent       *dirp;
    DIR                 *dp;
    int                 ret;
    char                *ptr;

    if (lstat(fullpath, &statbuf) < 0)      /* stat error */
        return(func(fullpath, &statbuf, FTW_NS));
    if (S_ISDIR(statbuf.st_mode) == 0)      /* not a directory */
        return(func(fullpath, &statbuf, FTW_F));

    /*
     * It's a directory. First call func() for the directory,
     * then process each filename in the directory.
     */
    if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
        return(ret);
    
    ptr = fullpath + strlen(fullpath);      /* point to end of fullpath */
    *ptr++ = '/';
    *ptr = 0;

    if ((dp = opendir(fullpath)) == NULL)   /* can't read directory */
        return(func(fullpath, &statbuf, FTW_DNR));

    while ((dirp = readdir(dp)) != NULL) {
        if (strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0)
            continue;                       /* ignore dot and dot-dot */

        strcpy(ptr, dirp->d_name);          /* append name after slash */

        if ((ret = dopath(func)) != 0)      /* recursive */
            break;                          /* time to leave */
    }
    ptr[-1] = 0;                            /* erase everything from slash onward */

    if (closedir(dp) < 0)
        err_ret("can't close directory %s", fullpath);
    return(ret);
}

int main (int argc, char **argv)
{
	int fd;
	int i;

	if (argc < 2)
		err_quit ("Usage: isastream file ...");

	for (i = 1; i < argc; i++) {
		if ((fd = open (argv [i], O_RDONLY)) == -1) {
			err_ret ("Can't open %s", argv [i]);
			continue;
		}

		printf ("%s %s a STREAMS device\n", argv [i],
			(isastream (fd)) ? "is" : "is not");
	}

	return (0);
}

/*
 * Takes a label: is there a ptr?
 * Returns:
 *      -1  is a malformed label is found
 *       0  if there's no pointer
 *      <offset from start_pkt> if a pointer is found
 */
int
getlblptr(char *buf)
{
	uint16_t dlbl;
	char c[2];

	memcpy(c, buf, 2);

	if (!LBL_PTR(*c))			/* No ptr */
		return 0;
	if (LBL_PTR(*c) != LBL_PTR_MASK) {
		debug(DBG_INSANE, "In getlblptr: invalid octet %02x",
			  (unsigned char) c[0]);
		err_ret(ERR_DNSMLO, -1);
	}
	(*c) &= LBL_PTR_OFF_MASK;
	memcpy(&dlbl, c, 2);
	dlbl = ntohs(dlbl);
	return dlbl;				/* offset */
}

int
delete_ntk_forward_chain(iptc_handle_t * t)
{
	int res;

	res = iptc_is_chain(NTK_MARK_CHAIN, *t);
	if (!res)
		return 0;
	res = iptc_flush_entries(NTK_MARK_CHAIN, t);
	if (!res)
		goto cannot_delete;
	res = iptc_delete_chain(NTK_MARK_CHAIN, t);
	if (!res)
		goto cannot_delete;
	return 0;

  cannot_delete:
	error("In delete_ntk_forward_chain: -> %s", iptc_strerror(errno));
	err_ret(ERR_NETDEL, -1);
}

int main(int argc, char *argv[])
{
	int i;
	struct stat buf;
	for (i = 1; i < argc; i++) {
		printf("%s: ", argv[i]);
		if (stat(argv[i], &buf) < 0) {
			err_ret("stat error");
			continue;
		}
		printf("dev = %d/%d", major(buf.st_dev), minor(buf.st_dev));
		if (S_ISCHR(buf.st_mode) || S_ISBLK(buf.st_mode)) {
			printf(" (%s) rdev = %d/%d",
					(S_ISCHR(buf.st_mode)) ? "character" : "block",
					major(buf.st_dev), minor(buf.st_dev));
		}
		printf("/n");
	}
	exit(0);
}

/*
 * Disassembles a DNS qst_section_set.
 * Use the above function for each question section.
 * -1 on error. Number of bytes readed on success.
 *  If -1 is returned, rcode ha sto be set to E_INTRPRT
 */
int
d_qsts_u(char *start_buf, char *buf, dns_pkt * dp, int limit_len)
{
	int offset = 0, res;
	int i, count;

	if (!(count = DP_QDCOUNT(dp)))
		return 0;				/* No questions. */

	for (i = 0; i < count; i++) {
		if ((res =
			 d_qst_u(start_buf, buf + offset, dp,
					 limit_len - offset)) == -1) {
			error(err_str);
			err_ret(ERR_DNSMDD, -1);
		}
		offset += res;
	}
	return offset;
}

int main(int argc, char *argv[]) {
    int i;
    struct stat buf;
    char *ptr;

    for (i = 1; i < argc; i++) {
        if (stat(argv[i], &buf) < 0) {
            err_ret("lstat error");
            continue;
        }
        if (S_ISREG(buf.st_mode) ) 
            ptr = "regular";
        else if (S_ISDIR(buf.st_mode) ) 
            ptr = "directory";

        printf("%s\n", ptr);
    }

    exit(0);
}

int main(void){
    char buf[MAXLINE];
    pid_t pid;
    int status;
    printf("%% ");
    while(fgets(buf,MAXLINE,stdin)!=NULL){
        buf[strlen(buf)-1]=0;
        if((pid=fork())<0)
            err_sys("fork error");
        else if(pid==0){
            execlp(buf,buf,(char*)0);
            err_ret("could not execute:%s",buf);
            exit(127);
        }
        if((pid=waitpid(pid,&status,0))<0)
            err_sys("waitpid error");
        printf("%% ");
    }
    exit(0);
}

int main(int argc, char const *argv[])
{
  int apipe[2], len;
  char buf[BUFSIZE];

  if (pipe(apipe) == -1)
    err_ret("pipe error", "");

  printf("Got a pipe. It is descriptors: %d, %d\n", apipe[0], apipe[1]);

  if ((fgets(buf, BUFSIZE, stdin)) != NULL)
  {
    write(apipe[1], buf, strlen(buf));
  }

  len = read(apipe[0], buf, BUFSIZE);
  write(1, buf, len);

  return 0;
}

int main(void)
{
	STARTUPINFO si;
	PROCESS_INFORMATION pi;
	DWORD dwChildID = 0;
	char szBuff[MAXLINE];

	// Initialize data
	ZeroMemory( &si, sizeof(si) );
	si.cb = sizeof(si);
	ZeroMemory( &pi, sizeof(pi) );

	printf("%% ");	/* print prompt (printf requires %% to print %) */
	while (fgets(szBuff, MAXLINE, stdin) != NULL) {
		szBuff[strlen(szBuff) - 1] = 0;	/* replace newline with null */

		/* Start the child process */
		if ( ! CreateProcess( 
			NULL,  // No module name (use command line)
			szBuff,  // Command line
			NULL,  // Process handle not inheritable
			NULL,  // Thread handle not inheritable. 
			FALSE,  // Set handle inheritance to FALSE. 
			0,  // No creation flags. 
			NULL,  // Use parent's environment block. 
			NULL,  // Use parent's starting directory. 
			&si,  // Pointer to STARTUPINFO structure.
			&pi )  // Pointer to PROCESS_INFORMATION struct
		)
		{
			err_ret( "CreateProcess failed." );
		}

		/* parent */
		/* wait for normal termination of child process */
		WaitForSingleObject(pi.hProcess, INFINITE);

		printf("%% ");
	}
	exit(0);
}

int main(int argc, char **argv)
{
    char *ptr, **pptr;
    char str[16]; /* ddd.ddd.ddd.ddd\0 */
    struct hostent *hptr;

    while (--argc > 0) {
        ptr = *++argv;
        if ((hptr = gethostbyname(ptr)) == NULL) {
            err_msg("gethostbyname error for host: %s: %s",
                    ptr, hstrerror(h_errno));
            continue;
        }
        printf("official hostname: %s\n", hptr->h_name);

        for (pptr = hptr->h_aliases; *pptr != NULL; pptr++)
            printf("\talias: %s\n", *pptr);

        switch (hptr->h_addrtype) {
            case AF_INET:
                pptr = hptr->h_addr_list;
                for (; *pptr != NULL; pptr++) {
                    printf("\taddress: %s\n",
                            Inet_ntop(hptr->h_addrtype, *pptr, str, sizeof(str)));
                    hptr = gethostbyaddr(*pptr, hptr->h_length, hptr->h_addrtype);
                    if (hptr == NULL)
                        err_msg("gethostbyaddr error: %s", hstrerror(h_errno));
                    else if (hptr ->h_name != NULL)
                        printf("\tname: %s\n", hptr->h_name);
                    else
                        printf("\t(no hostname returned by gethostbyaddr)\n");
                }
                break;
            default:
                err_ret("unknown address type");
                break;
        }
    }
    exit(0);

}

static int do_path(myfunc* func)
{
	struct stat statbuf;
	struct dirent *dirp;
	DIR *dp;
	int ret, n;

	if (lstat(fullpath, &statbuf) < 0)
		return(func(fullpath, &statbuf, FTW_NS));
	if (S_ISDIR(statbuf.st_mode) == 0)
		return(func(fullpath, &statbuf, FTW_F));
	if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
		return ret;

	n = strlen(fullpath);
	if (n + NAME_MAX + 2 > pathlen)
	{
		pathlen *= 2;
		if ((fullpath = realloc(fullpath, pathlen)) == NULL)
			err_sys("realloc failed");
	}
	fullpath[n++] = '/';
	fullpath[n] = 0;
	if ((dp = opendir(fullpath)) == NULL)
		return(func(fullpath, &statbuf, FTW_DNR));

	while ((dirp = readdir(dp)) != NULL)
	{
		if (strcmp(dirp->d_name, ".") == 0 ||
			strcmp(dirp->d_name, "..") == 0)
			continue;
		strcpy(&fullpath[n], dirp->d_name);
		if ((ret = do_path(func)) != 0)
			break;
	}
	fullpath[n-1] = 0;

	if (closedir(dp) < 0)
		err_ret("cannot close directory %s", fullpath)	;
	return ret;
}

int main (int argc,char **argv)
{
	int		i;
	struct	stat buf;
	char	*ptr;
	for(i=1;i<argc;i++)
	{
		printf("%s: \n \t",argv[i]);
		if(lstat(argv[i],&buf)<0)
		{
			err_ret("lstat error");
			continue;
		}
		if(S_ISREG(buf.st_mode))
			ptr="regular file";
		else if(S_ISDIR(buf.st_mode))
			ptr="directory file";
		else if(S_ISCHR(buf.st_mode))
			ptr="character special";
		else if(S_ISBLK(buf.st_mode))
			ptr="block special";
		else if(S_ISFIFO(buf.st_mode))
			ptr="fifo ";
		else if(S_ISLNK(buf.st_mode))
			ptr="symbolic link";
		else if(S_ISSOCK(buf.st_mode))
			ptr="socket";
		else
			ptr="** unknown mode **";
		printf("%s\n",ptr);

	}
	exit(0);







}

int CXSPAsyncSocket::SocketEpollDel(const int sockfd, const int event)
{
	EPOLLEVENT epollevent;
	epollevent.data.fd = sockfd;
	epollevent.events = event;
	pthread_t thrid = pthread_self();
	struct EpollWaitObject *pEwobj=NULL;
	if(m_ThreadId2Ewobj.Find(thrid, pEwobj) == 0)
	{
		int ret = epoll_ctl(pEwobj->epollId, EPOLL_CTL_DEL, sockfd, &epollevent);
		if(-1 == ret)
		{
			err_ret(GetLastError(ERROR_EPOLL_CTL));
			return -1;
		}
		m_ThreadId2Ewobj.Set(thrid, pEwobj);
		SafeDecreaseEvent();
		return ret;
	}
	return -2;
}

int main(int argc, char **argv)
{
	int i, fd;
	struct stat stat;
	unsigned char c, *ptr;

	if (argc != 2)
		err_quit("Usage: read <name>");

	//open, get size, map
	fd = Shm_open(argv[1], O_RDONLY, FILE_MODE);
	Fstat(fd, &stat);
	ptr = Mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd, 0);
	Close(fd);

	//check teh ptr[0] = 0, ptr[1] = 1, etc.
	for (i = 0; i < stat.st_size; i++)
		if ((c = *ptr++) != (i % 256))
			err_ret("ptr[%d] = %d", i, c);
	exit(0);
}

int main(int argc, char *argv[])
{
  int fd, pid;

  if ((pid = fork()) == -1)
    err_ret("fork", "");
  else if (pid == 0)
  {
    fd = open(argv[1], O_RDONLY);
    close(0);
    dup(fd);
    close(fd);

    execlp("sort", "sort", NULL);
  }
  else
  {
    wait(NULL);
  }
  return 0;
}

static int dopath(Myfunc* func)
{
    struct stat statbuf;
    struct dirent *dirp;
    DIR *dp;
    int ret;
    char *ptr;
    
    if(lstat(fullpath, &statbuf) < 0)
        return (func(fullpath, &statbuf, FTW_NS));
    if(S_ISDIR(statbuf.st_mode) == 0)//not a dir
        return (func(fullpath, &statbuf, FTW_F));
    //dir
    if((ret = func(fullpath, &statbuf, FTW_D)) != 0)
        return (ret);
	
    //printf("%s_______fullpath_in_dopath\n", fullpath);
    ptr = fullpath + strlen(fullpath);//point to end of path
    *ptr++ = '/';//这里不需要了，fullpath=realpath,realpath后面有已经有'/'
	//printf("after_/_fullpath______%s\n", fullpath);
    *ptr = 0;
    //if can't read dir
    if ((dp = opendir(fullpath)) == NULL)
        return (func(fullpath, &statbuf, FTW_DNR));
    //read
    while((dirp = readdir(dp)) != NULL)
    {
        if(strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0)
            continue;
        strcpy(ptr, dirp->d_name);//append dname after '/'
        
        if((ret = dopath(func)) != 0)//recursive 递归，循环
            break;//time to leave
    }

    //ptr[-1] = 0;//erase everything from slash onwards  ???
    if(closedir(dp) < 0)
        err_ret("can't close dir %s", fullpath);
    return (ret);
}