UNIX环境高级编程学习——列出一个目录中的所有文件

        初次接触UNIX环境高级编程，发现很多都已经被作者定义到头文件apue.h，我们根本无法知道那个函数是在那个头文件里面，对于初学者来说无法了解一个程序整个执行的过程。既然说到这里了，那就从第一个程序开始。

/***************************
 * 列出一个目录中的所有文件
 *     2013-07-22
 *      wjy
***************************/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <dirent.h>
#include <stdarg.h>
#include <string.h>

#define MAXLINE     4096

static void err_doit(int errnoflag, int error, const char *fmt, va_list ap)
{
    char buf[MAXLINE];
    vsnprintf(buf, MAXLINE, fmt, ap);
    if(errnoflag)
        snprintf(buf + strlen(buf), MAXLINE - strlen(buf), ": %s", strerror(error));
    strcat(buf, "/n");
    fflush(stdout);
    fputs(buf, stderr);
    fflush(NULL);
}

void err_quit(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    err_doit(0, 0, fmt, ap);
    va_end(ap);
    exit(1);
}

void err_sys(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    err_doit(1, errno, fmt, ap);
    va_end(ap);
    exit(1);
}

int main(int argc, char *argv[])
{
    DIR *dp;
    struct dirent *dirp;
    if(argc != 2)
        err_quit("usage: ls directory_name");
    if((dp = opendir(argv[1])) == NULL)
        err_sys("can't open %s", argv[1]);
    while((dirp = readdir(dp)) != NULL)
        printf("%s\n", dirp->d_name);
    closedir(dp);
    exit(0);
}

程序执行结果：

uestc@Ubuntu:~/code/UNIX环境高级编程/01$ ./main /home/uestc/code/
test_net
.
get_time
..
UNIX环境高级编程

       从上面的结果我们可以知道这个程序是正确运行了的，虽然很简单，但是包含的确实有一些值得深究的，我们从主函数一个一个往下看：

DIR是一个结构体，用来保存当前读取目录的有关信息。

dirent结构如下：

struct dirent
{
	long d_ino; 				// inode number 索引节点号
    off_t d_off; 				// offset to this dirent 在目录文件中的偏移
    unsigned short d_reclen; 	// length of this d_name 文件名长
    unsigned char d_type; 		// the type of d_name 文件类型
   	char d_name[NAME_MAX+1]; 	// 文件名，最长255字符
}

继续向下，接触到的是err_quit函数，这个时候不得不说可变参数函数中用到的va_start、va_arg、va_end三个宏和一个va_list类型，这三个宏在头文件stdarg.h中。

对于可变参数，注意参数列表中的省略号：它提示此处可能传递数量和类型未确定的参数。函数声明了一个名叫ap的va_list类型的变量，用于访问参数列表的未确定部分。这个变量通过调用va_start来初始化。它的第一个参数是va_list变量的名字，就是上面代码中ap。第二个参数是省略号前最后一个有名字的参数。初始化过程把ap变量设置为指向可变参数部分的第一个参数。

为了访问参数，需要使用va_arg，这个宏接受两个参数：va_list变量和参数列表中下一个参数的类型。va_arg返回这个参数的值，并使ap指向下一个可变参数。最后，当访问完毕最后一个可变参数之后，需要调用va_end。可变参数必须从头到尾按照这个顺序访问，如果你在访问几个可变参数后想中途中止，这是可以的。但是，如果你想一开始就访问参数列表中间的参数，那是不行的。另外，由于可变参数列表中并没有原型，所以，所有作为可变参数传递给函数的值都将执行缺省参数类型提升。

void BubbleSort(int a[], int n)//n为数组a的元素个数
{
	int i, j, temp;
	for (j = 0; j < n-1 ; j++)
		for (i = 0; i < n-1-j; i++)
		{
			if (a[i] > a[i+1])//数组元素大小按升序排列
			{
				temp = a[i];
				a[i] = a[i + 1];
				a[i + 1] = temp;
			}
		}
}

//快速排序  
void quick_sort(int s[], int low, int high)  
{  
	if (low < high)  
	{  
		int i = low, j = high, x = s[low];  
		while (i < j)  
		{  
			while(i < j && s[j] >= x) // 从右向左找第一个小于x的数  
				j--;    
			if(i < j)   
				s[i++] = s[j];  

			while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数  
				i++;    
			if(i < j)   
				s[j--] = s[i];  
		}  
		s[i] = x;  
		quick_sort(s, low, i - 1); // 递归调用   
		quick_sort(s, i + 1, high);  
	}  
}  

void InsertionSort(int A[ ], int N)
{
	int j, P;
	int Tmp;

	for(P = 1; P < N; P++)
	{
		Tmp = A[ P ];
		for(j = P; j > 0 && A[ j - 1 ] > Tmp; j--)
			A[ j ] = A[ j - 1 ];
		A[ j ] = Tmp;
	}
}

void Shellsort(int A[ ], int N)
{
	int i, j, Increment;
	int Tmp;

	for(Increment = N / 2; Increment > 0; Increment /= 2)
		for(i = Increment; i < N; i++)
		{
			Tmp = A[i];
			for(j = i; j >= Increment; j -= Increment)
				if(Tmp < A[j - Increment])
					A[j] = A[j - Increment];
				else
					break;
			A[j] = Tmp;
		}
}

#define LeftChild( i )  ( 2 * ( i ) + 1 )

void Swap(int *Lhs, int *Rhs )
{
	int Tmp = *Lhs;
	*Lhs = *Rhs;
	*Rhs = Tmp;
}

void PercDown(int A[ ], int i, int N)
{
	int Child;
	int Tmp;

	for( Tmp = A[ i ]; LeftChild( i ) < N; i = Child )
	{
		Child = LeftChild( i );
		if( Child != N - 1 && A[ Child + 1 ] > A[ Child ] )
			Child++;
		if( Tmp < A[ Child ] )
			A[i] = A[Child];
		else
			break;
	}
	A[ i ] =Tmp;
}

void Heapsort(int A[ ], int N)
{
	int i;

	for(i = N / 2; i >= 0; i--)  /* BuildHeap */
		PercDown( A, i, N );
	for(i = N - 1; i > 0; i--)
	{
		Swap(&A[ 0 ], &A[ i ]);  /* DeleteMax */
		PercDown(A, 0, i);
	}
}

void Merge(int A[ ], int TmpArray[ ], int Lpos, int Rpos, int RightEnd)
{
	int i, LeftEnd, NumElements, TmpPos;

	LeftEnd = Rpos - 1;
	TmpPos = Lpos;
	NumElements = RightEnd - Lpos + 1;

	/* main loop */
	while( Lpos <= LeftEnd && Rpos <= RightEnd )
		if( A[ Lpos ] <= A[ Rpos ] )
			TmpArray[ TmpPos++ ] = A[ Lpos++ ];
		else
			TmpArray[ TmpPos++ ] = A[ Rpos++ ];

	while( Lpos <= LeftEnd )  /* Copy rest of first half */
		TmpArray[ TmpPos++ ] = A[ Lpos++ ];
	while( Rpos <= RightEnd ) /* Copy rest of second half */
		TmpArray[ TmpPos++ ] = A[ Rpos++ ];

	/* Copy TmpArray back */
	for( i = 0; i < NumElements; i++, RightEnd-- )
		A[ RightEnd ] = TmpArray[ RightEnd ];
}

void MSort(int A[ ], int TmpArray[ ], int Left, int Right)
{
	int Center;

	if(Left < Right)
	{
		Center = ( Left + Right ) / 2;
		MSort( A, TmpArray, Left, Center );
		MSort( A, TmpArray, Center + 1, Right );
		Merge( A, TmpArray, Left, Center + 1, Right );
	}
}

void Mergesort(int A[ ], int N)
{
	int *TmpArray;

	TmpArray = malloc(N * sizeof( int ));
	if( TmpArray != NULL )
	{
		MSort( A, TmpArray, 0, N - 1 );
		free( TmpArray );
	}
	else
		return;
}

int MyStrlen(const char *str)
{
	int ret = 0;
	if (NULL == str)
		return 0;
	while (*str++ != '\0')
		ret++;
	return ret;
}

/*
** client客服端
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

#include <sys/socket.h>
#include <netinet/in.h>

#define MAXLINE     1024

int main(int argc, char *argv[])
{
    int sockfd, n;
    char buff[MAXLINE];
    struct sockaddr_in servaddr;

    if (argc != 2)
    {
        printf("Usage: ./client [IP_ADDR]\n");
        return 0;
    }
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        printf("Create socket failed!\n");
        return 0;
    }
    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8989);
    if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0)
    {
        printf("inet_pton failed!\n");
        return 0;
    }

    if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
    {
        printf("connect server failed!\n");
        return 0;
    }

    while ((n = read(sockfd, buff, MAXLINE)) > 0)
    {
        buff[n] = '\0';
        printf("%s\n", buff);
        memset(buff, 0, MAXLINE);
    }

    if (n < 0)
    {
        printf("read data from socket failed!");
        return 0;
    }
    return 0;
}

/*
** server服务器
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include <sys/socket.h>
#include <netinet/in.h>

#define LISTENQ     1024
#define MAXLINE     1024

int main(int argc, char *argv[])
{
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[MAXLINE];
    time_t ticks;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(8989);

    if (bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
    {
        printf("bind socket failed!");
        return 0;
    }

    if (listen(listenfd, LISTENQ) != 0)
    {
        printf("set max listen socket failed!\n");
        return 0;
    }

    for ( ; ; )
    {
        connfd = accept(listenfd, (struct sockaddr *) NULL, NULL);
        ticks = time(NULL);
        snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
        if (write(connfd, buff, strlen(buff)) < 0)
        {
            printf("write data to socket failed!\n");
            return 0;
        }
        close(connfd);
    }

    return 0;
}