----------------------------------------------------------------------------

----

1。文件的创建和读写

我假设你已经知道了标准级的文件操作的各个函数(fopen,fread,fwrite等等).当然如果你不清楚的话也不要着急.我们讨论的系统级的文件操作实际上是为标准级文件操作服务的.

当我们需要打开一个文件进行读写操作的时候,我们可以使用系统调用函数open.使用完成以后我们调用另外一个close函数进行关闭操作.

＃include<fcntl.h>

＃include<unistd.h>

＃include<sys/types.h>

＃include<sys/stat.h>

intopen(constchar*pathname,intflags);

intopen(constchar*pathname,intflags,mode_tmode);

intclose(intfd);

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设置用户执行IDS_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<unistd.h>

ssize_tread(intfd,void*buffer,size_tcount);

ssize_twrite(intfd,constvoid*buffer,size_tcount);

fd是我们要进行读写操作的文件描述符,buffer是我们要写入文件内容或读出文件内容的内存地址.count是我们要读写的字节数.

对于普通的文件read从指定的文件(fd)中读取count字节到buffer缓冲区中(记住我们必须提供一个足够大的缓冲区),同时返回count.

如果read读到了文件的结尾或者被一个信号所中断,返回值会小于count.如果是由信号中断引起返回,而且没有返回数据,read会返回-1,且设置errno为EINTR.当程序读到了文件结尾的时候,read会返回0.write从buffer中写count字节到文件fd中,成功时返回实际所写的字节数.

下面我们学习一个实例,这个实例用来拷贝文件.

＃include<unistd.h>

＃include<fcntl.h>

＃include<stdio.h>

＃include<sys/types.h>

＃include<sys/stat.h>

＃include<errno.h>

＃include<string.h>

#defineBUFFER_SIZE1024

intmain(intargc,char**argv)

{

intfrom_fd,to_fd;

intbytes_read,bytes_write;

charbuffer[BUFFER_SIZE];

char*ptr;

if(argc!=3)

{

fprintf(stderr,"Usage:%sfromfiletofile\n\a",argv[0]);

exit(1);

}

/*打开源文件*/

if((from_fd=open(argv[1],O_RDONLY))==-1)

{

fprintf(stderr,"Open%sError:%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%sError:%s\n",argv[2],strerror(errno));

exit(1);

}

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

while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))

{

/*一个致命的错误发生了*/

if((bytes_read==-1)&&(errno!=EINTR))break;

elseif(bytes_read>0)

{

ptr=buffer;

while(bytes_write=write(to_fd,ptr,bytes_read))

{

/*一个致命错误发生了*/

if((bytes_write==-1)&&(errno!=EINTR))break;

/*写完了所有读的字节*/

elseif(bytes_write==bytes_read)break;

/*只写了一部分,继续写*/

elseif(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<unistd.h>

intaccess(constchar*pathname,intmode);

pathname:是文件名称,mode是我们要判断的属性.可以取以下值或者是他们的组合.

R_OK文件可以读,W_OK文件可以写,X_OK文件可以执行,F_OK文件存在.当我们测试成功时,函数返回0,否则如果有一个条件不符时,返回-1.

如果我们要获得文件的其他属性,我们可以使用函数stat或者fstat.

＃include<sys/stat.h>

＃include<unistd.h>

intstat(constchar*file_name,structstat*buf);

intfstat(intfiledes,structstat*buf);

structstat{

dev_tst_dev;/*设备*/

ino_tst_ino;/*节点*/

mode_tst_mode;/*模式*/

nlink_tst_nlink;/*硬连接*/

uid_tst_uid;/*用户ID*/

gid_tst_gid;/*组ID*/

dev_tst_rdev;/*设备类型*/

off_tst_off;/*文件字节数*/

unsignedlongst_blksize;/*块大小*/

unsignedlongst_blocks;/*块数*/

time_tst_atime;/*最后一次访问时间*/

time_tst_mtime;/*最后一次修改时间*/

time_tst_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<unistd.h>

char*getcwd(char*buffer,size_tsize);

我们提供一个size大小的buffer,getcwd会把我们当前的路径考到buffer中.如果buffer太小,函数会返回-1和一个错误号.

Linux提供了大量的目录操作函数,我们学习几个比较简单和常用的函数.

＃include<dirent.h>

＃include<unistd.h>

＃include<fcntl.h>

＃include<sys/types.h>

＃include<sys/stat.h>

intmkdir(constchar*path,mode_tmode);

DIR*opendir(constchar*path);

structdirent*readdir(DIR*dir);

voidrewinddir(DIR*dir);

off_ttelldir(DIR*dir);

voidseekdir(DIR*dir,off_toff);

intclosedir(DIR*dir);

structdirent{

longd_ino;

off_td_off;

unsignedshortd_reclen;

chard_name[NAME_MAX+1];/*文件名称*/

mkdir很容易就是我们创建一个目录,opendir打开一个目录为以后读做准备.readdir读一个打开的目录.rewinddir是用来重读目录的和我们学的rewind函数一样.closedir是关闭一个目录.telldir和seekdir类似与ftee和fseek函数.

下面我们开发一个小程序,这个程序有一个参数.如果这个参数是一个文件名,我们输出这个文件的大小和最后修改的时间,如果是一个目录我们输出这个目录下所有文件的大小和修改时间.

＃include<unistd.h>

＃include<stdio.h>

＃include<errno.h>

＃include<sys/types.h>

＃include<sys/stat.h>

＃include<dirent.h>

＃include<time.h>

staticintget_file_size_time(constchar*filename)

{

structstatstatbuf;

if(stat(filename,&statbuf)==-1)

{

printf("Getstaton%sError:%s\n",

filename,strerror(errno));

return(-1);

}

if(S_ISDIR(statbuf.st_mode))return(1);

if(S_ISREG(statbuf.st_mode))

printf("%ssize:%ldbytes\tmodifiedat%s",

filename,statbuf.st_size,ctime(&statbuf.st_mtime));

return(0);

}

intmain(intargc,char**argv)

{

DIR*dirp;

structdirent*direntp;

intstats;

if(argc!=2)

{

printf("Usage:%sfilename\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("OpenDirectory%sError:%s\n",

argv[1],strerror(errno));

exit(1);

}

while((direntp=readdir(dirp))!=NULL)

if(get_file_size_time(direntp-<d_name)==-1)break;

closedir(dirp);

exit(1);

}

4。管道文件

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

＃include<unistd.h>

intpipe(intfildes[2]);

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

关于进程通信的详细情况请查看进程通信

＃include<stdio.h>

＃include<stdlib.h>

＃include<unistd.h>

＃include<string.h>

＃include<errno.h>

＃include<sys/types.h>

＃include<sys/wait.h>

#defineBUFFER255

intmain(intargc,char**argv)

{

charbuffer[BUFFER+1];

intfd[2];

if(argc!=2)

{

fprintf(stderr,"Usage:%sstring\n\a",argv[0]);

exit(1);

}

if(pipe(fd)!=0)

{

fprintf(stderr,"PipeError:%s\n\a",strerror(errno));

exit(1);

}

if(fork()==0)

{

close(fd[0]);

printf("Child[%d]Writetopipe\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]Readfrompipe\n\a",getpid());

memset(buffer,'''',BUFFER+1);

read(fd[0],buffer,BUFFER);

printf("Parent[%d]Read:%s\n",getpid(),buffer);

exit(1);

}

}

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

＃include<unistd.h>

intdup2(intoldfd,intnewfd);

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

＃include<unistd.h>

＃include<stdio.h>

＃include<errno.h>

＃include<fcntl.h>

＃include<string.h>

＃include<sys/types.h>

＃include<sys/stat.h>

#defineBUFFER_SIZE1024

intmain(intargc,char**argv)

{

intfd;

charbuffer[BUFFER_SIZE];

if(argc!=2)

{

fprintf(stderr,"Usage:%soutfilename\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%sError:%s\n\a",argv[1],strerror(errno));

exit(1);

}

if(dup2(fd,STDOUT_FILENO)==-1)

{

fprintf(stderr,"RedirectStandardOutError:%s\n\a",strerror(errno));

exit(1);

}

fprintf(stderr,"Now,pleaseinputstring");

fprintf(stderr,"(ToquituseCTRL+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等等常用的文件操作命令了.

想不想自己写几个试一试呢?

4)程序设计入门--时间概念

前言:Linux下的时间概念

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

时间的表示

时间的测量

计时器的使用

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

＃include<time.h>

time_ttime(time_t*tloc);

char*ctime(consttime_t*clock);

time函数返回从1970年1月1日0点以来的秒数.存储在time_t结构之中.不过这个函数的返回值对于我们来说没有什么实际意义.这个时候我们使用第二个函数将秒数转化为字符串。

..这个函数的返回类型是固定的:一个可能值为.ThuDec714:58:592000这个字符串的长度是固定的为26

2。时间的测量有时候我们要计算程序执行的时间.比如我们要对算法进行时间分析

..这个时候可以使用下面这个函数.

＃include<sys/time.h>

intgettimeofday(structtimeval*tv,structtimezone*tz);

struttimeval{

longtv_sec;/*秒数*/

longtv_usec;/*微秒数*/

};

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

＃include<sys/time.h<

＃include<stdio.h<

＃include<math.h<

voidfunction()

{

unsignedinti,j;

doubley;

for(i=0;i<1000;i++)

for(j=0;j<1000;j++)

y=sin((double)i);

}

main()

{

structtimevaltpstart,tpend;

floattimeuse;

gettimeofday(&tpstart,NULL);

function();

gettimeofday(&tpend,NULL);

timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+

tpend.tv_usec-tpstart.tv_usec;

timeuse/=1000000;

printf("UsedTime:%f\n",timeuse);

exit(0);

}

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

3。计时器的使用Linux操作系统为每一个进程提供了3个内部间隔计时器.

ITIMER_REAL:减少实际时间.到时的时候发出SIGALRM信号.

ITIMER_VIRTUAL:减少有效时间(进程执行的时间).产生SIGVTALRM信号.

ITIMER_PROF:减少进程的有效时间和系统时间(为进程调度用的时间).这个经常和上面一个使用用来计算系统内核时间和用户时间.产生SIGPROF信号.

具体的操作函数是:

＃include<sys/time.h>

intgetitimer(intwhich,structitimerval*value);

intsetitimer(intwhich,structitimerval*newval,

structitimerval*oldval);

structitimerval{

structtimevalit_interval;

structtimevalit_value;

}

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

＃include<sys/time.h>

＃include<stdio.h>

＃include<unistd.h>

＃include<signal.h>

＃include<string.h>

#definePROMPT"时间已经过去了两秒钟\n\a"

char*prompt=PROMPT;

unsignedintlen;

voidprompt_info(intsigno)

{

write(STDERR_FILENO,prompt,len);

}

voidinit_sigaction(void)

{

structsigactionact;

act.sa_handler=prompt_info;

act.sa_flags=0;

sigemptyset(&act.sa_mask);

sigaction(SIGPROF,&act,NULL);

}

voidinit_time()

{

structitimervalvalue;

value.it_value.tv_sec=2;

value.it_value.tv_usec=0;

value.it_interval=value.it_value;

setitimer(ITIMER_PROF,&value,NULL);

}

intmain()

{

len=strlen(prompt);

init_sigaction();

init_time();

while(1);

exit(0);

}

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

5)Linux程序设计入门--信号处理

Linux下的信号事件

前言:这一章我们讨论一下Linux下的信号处理函数.

Linux下的信号处理函数:

信号的产生

信号的处理

其它信号函数

一个实例

1。信号的产生

Linux下的信号可以类比于DOS下的INT或者是Windows下的事件.在有一个信号发生时候相信的信号就会发送给相应的进程.在Linux下的信号有以下几个.我们使用kill-l命令可以得到以下的输出结果:

1)SIGHUP2)SIGINT3)SIGQUIT4)SIGILL

5)SIGTRAP6)SIGABRT7)SIGBUS8)SIGFPE

9)SIGKILL10)SIGUSR111)SIGSEGV12)SIGUSR2

13)SIGPIPE14)SIGALRM15)SIGTERM17)SIGCHLD

18)SIGCONT19)SIGSTOP20)SIGTSTP21)SIGTTIN

22)SIGTTOU23)SIGURG24)SIGXCPU25)SIGXFSZ

26)SIGVTALRM27)SIGPROF28)SIGWINCH29)SIGIO

30)SIGPWR

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

＃include<sys/types.h>

＃include<signal.h>

＃include<unistd.h>

intkill(pid_tpid,intsig);

intraise(intsig);

unisignedintalarm(unsignedintseconds);

kill系统调用负责向进程发送信号sig.

如果pid是正数,那么向信号sig被发送到进程pid.

如果pid等于0,那么信号sig被发送到所以和pid进程在同一个进程组的进程

如果pid等于-1,那么信号发给所有的进程表中的进程,除了最大的哪个进程号.

如果pid由于-1,和0一样,只是发送进程组是-pid.

我们用最多的是第一个情况.还记得我们在守护进程那一节的例子吗?我们那个时候用这个函数杀死了父进程守护进程的创建

raise系统调用向自己发送一个sig信号.我们可以用上面那个函数来实现这个功能的.

alarm函数和时间有点关系了,这个函数可以在seconds秒后向自己发送一个SIGALRM信号

..下面这个函数会有什么结果呢?

＃include<unistd.h>

main()

{

unsignedinti;

alarm(1);

for(i=0;1;i++)

printf("I=%d",i);

}

SIGALRM的缺省操作是结束进程,所以程序在1秒之后结束,你可以看看你的最后I值为多少,来比较一下大家的系统性能差异(我的是2232).

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

信号操作最常用的方法是信号屏蔽.信号屏蔽要用到下面的几个函数.

＃include<signal.h>

intsigemptyset(sigset_t*set);

intsigfillset(sigset_t*set);

intsigaddset(sigset_t*set,intsigno);

intsigdelset(sigset_t*set,intsigno);

intsigismember(sigset_t*set,intsigno);

intsigprocmask(inthow,constsigset_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<signal.h>

＃include<stdio.h>

＃include<math.h>

＃include<stdlib.h>

intmain(intargc,char**argv)

{

doubley;

sigset_tintmask;

inti,repeat_factor;

if(argc!=2)

{

fprintf(stderr,"Usage:%srepeat_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,"SIGINTsignalblocked\n");

for(i=0;i<repeat_factor;i++)y=sin((double)i);

fprintf(stderr,"Blockedcalculationisfinished\n");

/*取消阻塞*/

sigprocmask(SIG_UNBLOCK,&intmask,NULL);

fprintf(stderr,"SIGINTsignalunblocked\n");

for(i=0;i<repeat_factor;i++)y=sin((double)i);

fprintf(stderr,"Unblockedcalculationisfinished\n");

}

exit(0);

}

程序在运行的时候我们要使用Ctrl+C来结束.如果我们在第一计算的时候发出SIGINT信号,由于信号已经屏蔽了,所以程序没有反映.只有到信号被取消阻塞的时候程序才会结束.注意我们只要发出一次SIGINT信号就可以了,因为信号屏蔽只是将信号加入到信号阻塞集合之中,并没有丢弃这个信号.一旦信号屏蔽取消了,这个信号就会发生作用.

有时候我们希望对信号作出及时的反映的,比如当拥护按下Ctrl+C时,我们不想什么事情也不做,我们想告诉用户你的这个操作不好,请不要重试,而不是什么反映也没有的.这个时候我们要用到sigaction函数.

＃include<signal.h>

intsigaction(intsigno,conststructsigaction*act,

structsigaction*oact);

structsigaction{

void(*sa_handler)(intsigno);

void(*sa_sigaction)(intsiginfo_t*info,void*act);

sigset_tsa_mask;

intsa_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<signal.h>

＃include<stdio.h>

＃include<string.h>

＃include<errno.h>

＃include<unistd.h>

#definePROMPT"你想终止程序吗?"

char*prompt=PROMPT;

voidctrl_c_op(intsigno)

{

write(STDERR_FILENO,prompt,strlen(prompt));

}

intmain()

{

structsigactionact;

act.sa_handler=ctrl_c_op;

sigemptyset(&act.sa_mask);

act.sa_flags=0;

if(sigaction(SIGINT,&act,NULL)<0)

{

fprintf(stderr,"InstallSignalActionError:%s\n\a",strerror(errno));

exit(1);

}

while(1);

}

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

3。其它信号函数由于信号的操作和处理比较复杂,我们再介绍几个信号操作函数.

＃include<unistd.h>

＃include<signal.h>

intpause(void);

intsigsuspend(constsigset_t*sigmask);

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

＃include<sigsetjmp>

intsigsetjmp(sigjmp_bufenv,intval);

voidsiglongjmp(sigjmp_bufenv,intval);

还记得goto函数或者是setjmp和longjmp函数吗.这两个信号跳转函数也可以实现程序的跳转让我们可以从函数之中跳转到我们需要的地方.

由于上面几个函数,我们很少遇到,所以只是说明了一下,详细情况请查看联机帮助.

4。一个实例还记得我们在守护进程创建的哪个程序吗?守护进程在这里我们把那个程序加强一下.下面这个程序会在也可以检查用户的邮件.不过提供了一个开关,如果用户不想程序提示有新的邮件到来,可以向程序发送SIGUSR2信号,如果想程序提供提示可以发送SIGUSR1信号.

＃include<unistd.h>

＃include<stdio.h>

＃include<errno.h>

＃include<fcntl.h>

＃include<signal.h>

＃include<string.h>

＃include<pwd.h>

＃include<sys/types.h>

＃include<sys/stat.h>

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

#defineMAIL_DIR"/var/spool/mail/"

/*睡眠10秒钟*/

#defineSLEEP_TIME10

#defineMAX_FILENAME255

unsignedcharnotifyflag=1;

longget_file_size(constchar*filename)

{

structstatbuf;

if(stat(filename,&;buf)==-1)

{

if(errno==ENOENT)return0;

elsereturn-1;

}

return(long)buf.st_size;

}

voidsend_mail_notify(void)

{

fprintf(stderr,"Newmailhasarrived7\n");

}

voidturn_on_notify(intsigno)

{

notifyflag=1;

}

voidturn_off_notify(intsigno)

{

notifyflag=0;

}

intcheck_mail(constchar*filename)

{

longold_mail_size,new_mail_size;

sigset_tblockset,emptyset;

sigemptyset(&;blockset);

sigemptyset(&;emptyset);

sigaddset(&;blockset,SIGUSR1);

sigaddset(&;blockset,SIGUSR2);

old_mail_size=get_file_size(filename);

if(old_mail_size<0)return1;

if(old_mail_size>0)send_mail_notify();

sleep(SLEEP_TIME);

while(1)

{

if(sigprocmask(SIG_BLOCK,&;blockset,NULL)<0)return1;

while(notifyflag==0)sigsuspend(&;emptyset);

if(sigprocmask(SIG_SETMASK,&;emptyset,NULL)<0)return1;

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);

}

}

intmain(void)

{

charmailfile[MAX_FILENAME];

structsigactionnewact;

structpasswd*pw;

if((pw=getpwuid(getuid()))==NULL)

{

fprintf(stderr,"GetLoginNameError:%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,"TurnOnError:%s\n\a",strerror(errno));

newact.sa_handler=turn_off_notify;

if(sigaction(SIGUSR1,&;newact,NULL)<0)

fprintf(stderr,"TurnOffError:%s\n\a",strerror(errno));

check_mail(mailfile);

exit(0);

}

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