Linux程序设计入门--文件操作
%A Linux下文件的操作
%A 前言:
%A 我们在这一节将要讨论linux下文件操作的各个函数.
%A 文件的创建和读写
%A 文件的各个属性
%A 目录文件的操作
%A 管道文件
%A ----------------------------------------------------------------------------
%A ----
%A 1。文件的创建和读写
%A 我假设你已经知道了标准级的文件操作的各个函数(fopen,fread,fwrite等等).当然
%A 如果你不清楚的话也不要着急.我们讨论的系统级的文件操作实际上是为标准级文件操作
%A 服务的.
%A 当我们需要打开一个文件进行读写操作的时候,我们可以使用系统调用函数open.使用完
%A 成以后我们调用另外一个close函数进行关闭操作.
%A ＃i nclude <fcntl.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A
%A int open(const char *pathname,int flags);
%A int open(const char *pathname,int flags,mode_t mode);
%A int close(int fd);
%A open函数有两个形式.其中pathname是我们要打开的文件名(包含路径名称,缺省是认为在
%A 当前路径下面).flags可以去下面的一个值或者是几个值的组合.
%A O_RDONLY:以只读的方式打开文件.
%A O_WRONLY:以只写的方式打开文件.
%A O_RDWR:以读写的方式打开文件.
%A O_APPEND:以追加的方式打开文件.
%A O_CREAT:创建一个文件.
%A O_EXEC:如果使用了O_CREAT而且文件已经存在,就会发生一个错误.
%A O_NOBLOCK:以非阻塞的方式打开一个文件.
%A O_TRUNC:如果文件已经存在,则删除文件的内容.
%A 前面三个标志只能使用任意的一个.如果使用了O_CREATE标志,那么我们要使用open的第
%A 二种形式.还要指定mode标志,用来表示文件的访问权限.mode可以是以下情况的组合.
%A -----------------------------------------------------------------
%A S_IRUSR 用户可以读 S_IWUSR 用户可以写
%A S_IXUSR 用户可以执行 S_IRWXU 用户可以读写执行
%A -----------------------------------------------------------------
%A S_IRGRP 组可以读 S_IWGRP 组可以写
%A S_IXGRP 组可以执行 S_IRWXG 组可以读写执行
%A -----------------------------------------------------------------
%A S_IROTH 其他人可以读 S_IWOTH 其他人可以写
%A S_IXOTH 其他人可以执行 S_IRWXO 其他人可以读写执行
%A -----------------------------------------------------------------
%A S_ISUID 设置用户执行ID S_ISGID 设置组的执行ID
%A -----------------------------------------------------------------
%A 我们也可以用数字来代表各个位的标志.Linux总共用5个数字来表示文件的各种权限.
%A 00000.第一位表示设置用户ID.第二位表示设置组ID,第三位表示用户自己的权限位,第四
%A 位表示组的权限,最后一位表示其他人的权限.
%A 每个数字可以取1(执行权限),2(写权限),4(读权限),0(什么也没有)或者是这几个值的和
%A ..
%A 比如我们要创建一个用户读写执行,组没有权限,其他人读执行的文件.设置用户ID位那么
%A 我们可以使用的模式是--1(设置用户ID)0(组没有设置)7(1+2+4)0(没有权限,使用缺省)
%A 5(1+4)即10705:
%A open("temp",O_CREAT,10705);
%A 如果我们打开文件成功,open会返回一个文件描述符.我们以后对文件的所有操作就可以
%A 对这个文件描述符进行操作了.
%A 当我们操作完成以后,我们要关闭文件了,只要调用close就可以了,其中fd是我们要关闭
%A 的文件描述符.
%A 文件打开了以后,我们就要对文件进行读写了.我们可以调用函数read和write进行文件的
%A 读写.
%A ＃i nclude <unistd.h>
%A ssize_t read(int fd, void *buffer,size_t count);
%A ssize_t write(int fd, const void *buffer,size_t count);
%A fd是我们要进行读写操作的文件描述符,buffer是我们要写入文件内容或读出文件内容的
%A 内存地址.count是我们要读写的字节数.
%A 对于普通的文件read从指定的文件(fd)中读取count字节到buffer缓冲区中(记住我们必
%A 须提供一个足够大的缓冲区),同时返回count.
%A 如果read读到了文件的结尾或者被一个信号所中断,返回值会小于count.如果是由信号中
%A 断引起返回,而且没有返回数据,read会返回-1,且设置errno为EINTR.当程序读到了文件
%A 结尾的时候,read会返回0.
%A write从buffer中写count字节到文件fd中,成功时返回实际所写的字节数.
%A 下面我们学习一个实例,这个实例用来拷贝文件.
%A ＃i nclude <unistd.h>
%A ＃i nclude <fcntl.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <string.h>
%A #define BUFFER_SIZE 1024
%A int main(int argc,char **argv)
%A {
%A int from_fd,to_fd;
%A int bytes_read,bytes_write;
%A char buffer[BUFFER_SIZE];
%A char *ptr;
%A if(argc!=3)
%A {
%A fprintf(stderr,"Usage:%s fromfile tofile\n\a",argv[0]);
%A exit(1);
%A }
%A /* 打开源文件 */
%A if((from_fd=open(argv[1],O_RDONLY))==-1)
%A {
%A fprintf(stderr,"Open %s Error:%s\n",argv[1],strerror(errno));
%A exit(1);
%A }
%A /* 创建目的文件 */
%A if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)
%A {
%A fprintf(stderr,"Open %s Error:%s\n",argv[2],strerror(errno));
%A exit(1);
%A }
%A /* 以下代码是一个经典的拷贝文件的代码 */
%A while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))
%A {
%A /* 一个致命的错误发生了 */
%A if((bytes_read==-1)&&(errno!=EINTR)) break;
%A else if(bytes_read>0)
%A {
%A ptr=buffer;
%A while(bytes_write=write(to_fd,ptr,bytes_read))
%A {
%A /* 一个致命错误发生了 */
%A if((bytes_write==-1)&&(errno!=EINTR))break;
%A /* 写完了所有读的字节 */
%A else if(bytes_write==bytes_read) break;
%A /* 只写了一部分,继续写 */
%A else if(bytes_write>0)
%A {
%A ptr+=bytes_write;
%A bytes_read-=bytes_write;
%A }
%A }
%A /* 写的时候发生的致命错误 */
%A if(bytes_write==-1)break;
%A }
%A }
%A close(from_fd);
%A close(to_fd);
%A exit(0);
%A }
%A 2。文件的各个属性
%A 文件具有各种各样的属性,除了我们上面所知道的文件权限以外,文件还有创建时间
%A ,大小等等属性.
%A 有时侯我们要判断文件是否可以进行某种操作(读,写等等).这个时候我们可以使用acce
%A ss函数.
%A ＃i nclude <unistd.h>
%A
%A int access(const char *pathname,int mode);
%A pathname:是文件名称,mode是我们要判断的属性.可以取以下值或者是他们的组合.
%A R_OK文件可以读,W_OK文件可以写,X_OK文件可以执行,F_OK文件存在.当我们测试成功时
%A ,函数返回0,否则如果有一个条件不符时,返回-1.
%A 如果我们要获得文件的其他属性,我们可以使用函数stat或者fstat.
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <unistd.h>
%A int stat(const char *file_name,struct stat *buf);
%A int fstat(int filedes,struct stat *buf);
%A struct stat {
%A dev_t st_dev; /* 设备 */
%A ino_t st_ino; /* 节点 */
%A mode_t st_mode; /* 模式 */
%A nlink_t st_nlink; /* 硬连接 */
%A uid_t st_uid; /* 用户ID */
%A gid_t st_gid; /* 组ID */
%A dev_t st_rdev; /* 设备类型 */
%A off_t st_off; /* 文件字节数 */
%A unsigned long st_blksize; /* 块大小 */
%A unsigned long st_blocks; /* 块数 */
%A time_t st_atime; /* 最后一次访问时间 */
%A time_t st_mtime; /* 最后一次修改时间 */
%A time_t st_ctime; /* 最后一次改变时间(指属性) */
%A };
%A stat用来判断没有打开的文件,而fstat用来判断打开的文件.我们使用最多的属性是st_
%A mode.通过着属性我们可以判断给定的文件是一个普通文件还是一个目录,连接等等.可以
%A 使用下面几个宏来判断.
%A S_ISLNK(st_mode):是否是一个连接.S_ISREG是否是一个常规文件.S_ISDIR是否是一个目
%A 录S_ISCHR是否是一个字符设备.S_ISBLK是否是一个块设备S_ISFIFO是否 是一个FIFO文
%A 件.S_ISSOCK是否是一个SOCKET文件. 我们会在下面说明如何使用这几个宏的.
%A 3。目录文件的操作
%A 在我们编写程序的时候，有时候会要得到我们当前的工作路径。C库函数提供了get
%A cwd来解决这个问题。
%A ＃i nclude <unistd.h>
%A
%A char *getcwd(char *buffer,size_t size);
%A 我们提供一个size大小的buffer,getcwd会把我们当前的路径考到buffer中.如果buffer
%A 太小,函数会返回-1和一个错误号.
%A Linux提供了大量的目录操作函数,我们学习几个比较简单和常用的函数.
%A ＃i nclude <dirent.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <fcntl.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A int mkdir(const char *path,mode_t mode);
%A DIR *opendir(const char *path);
%A struct dirent *readdir(DIR *dir);
%A void rewinddir(DIR *dir);
%A off_t telldir(DIR *dir);
%A void seekdir(DIR *dir,off_t off);
%A int closedir(DIR *dir);
%A struct dirent {
%A long d_ino;
%A off_t d_off;
%A unsigned short d_reclen;
%A char d_name[NAME_MAX+1]; /* 文件名称 */
%A mkdir很容易就是我们创建一个目录,opendir打开一个目录为以后读做准备.readdir读一
%A 个打开的目录.rewinddir是用来重读目录的和我们学的rewind函数一样.closedir是关闭
%A 一个目录.telldir和seekdir类似与ftee和fseek函数.
%A 下面我们开发一个小程序,这个程序有一个参数.如果这个参数是一个文件名,我们输出这
%A 个文件的大小和最后修改的时间,如果是一个目录我们输出这个目录下所有文件的大小和
%A 修改时间.
%A ＃i nclude <unistd.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A ＃i nclude <dirent.h>
%A ＃i nclude <time.h>
%A static int get_file_size_time(const char *filename)
%A {
%A struct stat statbuf;
%A if(stat(filename,&statbuf)==-1)
%A {
%A printf("Get stat on %s Error:%s\n",
%A filename,strerror(errno));
%A return(-1);
%A }
%A if(S_ISDIR(statbuf.st_mode))return(1);
%A if(S_ISREG(statbuf.st_mode))
%A printf("%s size:%ld bytes\tmodified at %s",
%A filename,statbuf.st_size,ctime(&statbuf.st_mtime));
%A
%A return(0);
%A }
%A int main(int argc,char **argv)
%A {
%A DIR *dirp;
%A struct dirent *direntp;
%A int stats;
%A if(argc!=2)
%A {
%A printf("Usage:%s filename\n\a",argv[0]);
%A exit(1);
%A }
%A if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1);
%A if((dirp=opendir(argv[1]))==NULL)
%A {
%A printf("Open Directory %s Error:%s\n",
%A argv[1],strerror(errno));
%A exit(1);
%A }
%A while((direntp=readdir(dirp))!=NULL)
%A if(get_file_size_time(direntp-<d_name)==-1)break;
%A closedir(dirp);
%A exit(1);
%A }
%A 4。管道文件
%A Linux提供了许多的过滤和重定向程序,比如more cat
%A 等等.还提供了< > | <<等等重定向操作符.在这些过滤和重 定向程序当中,都用到了管
%A 道这种特殊的文件.系统调用pipe可以创建一个管道.
%A ＃i nclude<unistd.h>
%A
%A int pipe(int fildes[2]);
%A pipe调用可以创建一个管道(通信缓冲区).当调用成功时,我们可以访问文件描述符fild
%A es[0],fildes[1].其中fildes[0]是用来读的文件描述符,而fildes[1]是用来写的文件描
%A 述符.
%A 在实际使用中我们是通过创建一个子进程,然后一个进程写,一个进程读来使用的.
%A 关于进程通信的详细情况请查看进程通信
%A ＃i nclude <stdio.h>
%A ＃i nclude <stdlib.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <string.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/wait.h>
%A #define BUFFER 255
%A int main(int argc,char **argv)
%A {
%A char buffer[BUFFER+1];
%A int fd[2];
%A if(argc!=2)
%A {
%A fprintf(stderr,"Usage:%s string\n\a",argv[0]);
%A exit(1);
%A }
%A if(pipe(fd)!=0)
%A {
%A fprintf(stderr,"Pipe Error:%s\n\a",strerror(errno));
%A exit(1);
%A }
%A if(fork()==0)
%A {
%A close(fd[0]);
%A printf("Child[%d] Write to pipe\n\a",getpid());
%A snprintf(buffer,BUFFER,"%s",argv[1]);
%A write(fd[1],buffer,strlen(buffer));
%A printf("Child[%d] Quit\n\a",getpid());
%A exit(0);
%A }
%A else
%A {
%A close(fd[1]);
%A printf("Parent[%d] Read from pipe\n\a",getpid());
%A memset(buffer,‘‘,BUFFER+1);
%A read(fd[0],buffer,BUFFER);
%A printf("Parent[%d] Read:%s\n",getpid(),buffer);
%A exit(1);
%A }
%A }
%A 为了实现重定向操作,我们需要调用另外一个函数dup2.
%A ＃i nclude <unistd.h>
%A
%A int dup2(int oldfd,int newfd);
%A dup2将用oldfd文件描述符来代替newfd文件描述符,同时关闭newfd文件描述符.也就是说
%A ,
%A 所有向newfd操作都转到oldfd上面.下面我们学习一个例子,这个例子将标准输出重定向
%A 到一个文件.
%A ＃i nclude <unistd.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <fcntl.h>
%A ＃i nclude <string.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A #define BUFFER_SIZE 1024
%A int main(int argc,char **argv)
%A {
%A int fd;
%A char buffer[BUFFER_SIZE];
%A if(argc!=2)
%A {
%A fprintf(stderr,"Usage:%s outfilename\n\a",argv[0]);
%A exit(1);
%A }
%A if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1)
%A {
%A fprintf(stderr,"Open %s Error:%s\n\a",argv[1],strerror(errno));
%A exit(1);
%A }
%A if(dup2(fd,STDOUT_FILENO)==-1)
%A {
%A fprintf(stderr,"Redirect Standard Out Error:%s\n\a",strerror(errno));
%A exit(1);
%A }
%A fprintf(stderr,"Now,please input string");
%A fprintf(stderr,"(To quit use CTRL+D)\n");
%A while(1)
%A {
%A fgets(buffer,BUFFER_SIZE,stdin);
%A if(feof(stdin))break;
%A write(STDOUT_FILENO,buffer,strlen(buffer));
%A }
%A exit(0);
%A }
%A 好了,文件一章我们就暂时先讨论到这里,学习好了文件的操作我们其实已经可以写出一
%A 些比较有用的程序了.我们可以编写一个实现例如dir,mkdir,cp,mv等等常用的文件操作
%A 命令了.
%A 想不想自己写几个试一试呢?
%A
%A 4)程序设计入门--时间概念
%A 前言:Linux下的时间概念
%A 这一章我们学习Linux的时间表示和计算函数
%A 时间的表示
%A 时间的测量
%A 计时器的使用
%A 1。时间表示 在程序当中,我们经常要输出系统当前的时间,比如我们使用date命令
%A 的输出结果.这个时候我们可以使用下面两个函数
%A ＃i nclude <time.h>
%A
%A time_t time(time_t *tloc);
%A char *ctime(const time_t *clock);
%A time函数返回从1970年1月1日0点以来的秒数.存储在time_t结构之中.不过这个函数的返
%A 回值对于我们来说没有什么实际意义.这个时候我们使用第二个函数将秒数转化为字符串
%A .. 这个函数的返回类型是固定的:一个可能值为. Thu Dec 7 14:58:59 2000 这个字符串
%A 的长度是固定的为26
%A 2。时间的测量 有时候我们要计算程序执行的时间.比如我们要对算法进行时间分析
%A ..这个时候可以使用下面这个函数.
%A ＃i nclude <sys/time.h>
%A
%A int gettimeofday(struct timeval *tv,struct timezone *tz);
%A strut timeval {
%A long tv_sec; /* 秒数 */
%A long tv_usec; /* 微秒数 */
%A };
%A gettimeofday将时间保存在结构tv之中.tz一般我们使用NULL来代替.
%A ＃i nclude <sys/time.h<
%A ＃i nclude <stdio.h<
%A ＃i nclude <math.h<
%A void function()
%A {
%A unsigned int i,j;
%A double y;
%A for(i=0;i<1000;i++)
%A for(j=0;j<1000;j++)
%A y=sin((double)i);
%A }
%A main()
%A {
%A struct timeval tpstart,tpend;
%A float timeuse;
%A gettimeofday(&tpstart,NULL);
%A function();
%A gettimeofday(&tpend,NULL);
%A timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+
%A tpend.tv_usec-tpstart.tv_usec;
%A timeuse/=1000000;
%A printf("Used Time:%f\n",timeuse);
%A exit(0);
%A }
%A 这个程序输出函数的执行时间,我们可以使用这个来进行系统性能的测试,或者是函数算
%A 法的效率分析.在我机器上的一个输出结果是: Used Time:0.556070
%A 3。计时器的使用 Linux操作系统为每一个进程提供了3个内部间隔计时器.
%A ITIMER_REAL:减少实际时间.到时的时候发出SIGALRM信号.
%A ITIMER_VIRTUAL:减少有效时间(进程执行的时间).产生SIGVTALRM信号.
%A ITIMER_PROF:减少进程的有效时间和系统时间(为进程调度用的时间).这个经常和上面一
%A 个使用用来计算系统内核时间和用户时间.产生SIGPROF信号.
%A 具体的操作函数是:
%A ＃i nclude <sys/time.h>
%A int getitimer(int which,struct itimerval *value);
%A int setitimer(int which,struct itimerval *newval,
%A struct itimerval *oldval);
%A struct itimerval {
%A struct timeval it_interval;
%A struct timeval it_value;
%A }
%A getitimer函数得到间隔计时器的时间值.保存在value中 setitimer函数设置间隔计时器
%A 的时间值为newval.并将旧值保存在oldval中. which表示使用三个计时器中的哪一个.
%A itimerval结构中的it_value是减少的时间,当这个值为0的时候就发出相应的信号了. 然
%A 后设置为it_interval值.
%A ＃i nclude <sys/time.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <unistd.h>
%A ＃i nclude <signal.h>
%A ＃i nclude <string.h>
%A #define PROMPT "时间已经过去了两秒钟\n\a"
%A char *prompt=PROMPT;
%A unsigned int len;
%A void prompt_info(int signo)
%A {
%A write(STDERR_FILENO,prompt,len);
%A }
%A void init_sigaction(void)
%A {
%A struct sigaction act;
%A act.sa_handler=prompt_info;
%A act.sa_flags=0;
%A sigemptyset(&act.sa_mask);
%A sigaction(SIGPROF,&act,NULL);
%A }
%A void init_time()
%A {
%A struct itimerval value;
%A value.it_value.tv_sec=2;
%A value.it_value.tv_usec=0;
%A value.it_interval=value.it_value;
%A setitimer(ITIMER_PROF,&value,NULL);
%A }
%A int main()
%A {
%A len=strlen(prompt);
%A init_sigaction();
%A init_time();
%A while(1);
%A exit(0);
%A }
%A 这个程序每执行两秒中之后会输出一个提示.
%A
%A 5)Linux程序设计入门--信号处理
%A Linux下的信号事件
%A 前言:这一章我们讨论一下Linux下的信号处理函数.
%A Linux下的信号处理函数:
%A 信号的产生
%A 信号的处理
%A 其它信号函数
%A 一个实例
%A 1。信号的产生
%A Linux下的信号可以类比于DOS下的INT或者是Windows下的事件.在有一个信号发生时
%A 候相信的信号就会发送给相应的进程.在Linux下的信号有以下几个. 我们使用 kill -l
%A 命令可以得到以下的输出结果:
%A 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
%A 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
%A 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
%A 13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD
%A 18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
%A 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
%A 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO
%A 30) SIGPWR
%A 关于这些信号的详细解释请查看man 7 signal的输出结果. 信号事件的发生有两个来源
%A :一个是硬件的原因(比如我们按下了键盘),一个是软件的原因(比如我们使用系统函数或
%A 者是命令发出信号). 最常用的四个发出信号的系统函数是kill, raise, alarm和setit
%A imer函数. setitimer函数我们在计时器的使用 那一章再学习.
%A ＃i nclude <sys/types.h>
%A ＃i nclude <signal.h>
%A ＃i nclude <unistd.h>
%A int kill(pid_t pid,int sig);
%A int raise(int sig);
%A unisigned int alarm(unsigned int seconds);
%A kill系统调用负责向进程发送信号sig.
%A 如果pid是正数,那么向信号sig被发送到进程pid.
%A 如果pid等于0,那么信号sig被发送到所以和pid进程在同一个进程组的进程
%A 如果pid等于-1,那么信号发给所有的进程表中的进程,除了最大的哪个进程号.
%A 如果pid由于-1,和0一样,只是发送进程组是-pid.
%A 我们用最多的是第一个情况.还记得我们在守护进程那一节的例子吗?我们那个时候用这
%A 个函数杀死了父进程守护进程的创建
%A raise系统调用向自己发送一个sig信号.我们可以用上面那个函数来实现这个功能的.
%A alarm函数和时间有点关系了,这个函数可以在seconds秒后向自己发送一个SIGALRM信号
%A .. 下面这个函数会有什么结果呢?
%A ＃i nclude <unistd.h>
%A main()
%A {
%A unsigned int i;
%A alarm(1);
%A for(i=0;1;i++)
%A printf("I=%d",i);
%A }
%A SIGALRM的缺省操作是结束进程,所以程序在1秒之后结束,你可以看看你的最后I值为多少
%A ,来比较一下大家的系统性能差异(我的是2232).
%A 2。信号操作 有时候我们希望进程正确的执行,而不想进程受到信号的影响,比如我
%A 们希望上面那个程序在1秒钟之后不结束.这个时候我们就要进行信号的操作了.
%A 信号操作最常用的方法是信号屏蔽.信号屏蔽要用到下面的几个函数.
%A ＃i nclude <signal.h>
%A int sigemptyset(sigset_t *set);
%A int sigfillset(sigset_t *set);
%A int sigaddset(sigset_t *set,int signo);
%A int sigdelset(sigset_t *set,int signo);
%A int sigismember(sigset_t *set,int signo);
%A int sigprocmask(int how,const sigset_t *set,sigset_t *oset);
%A sigemptyset函数初始化信号集合set,将set设置为空.sigfillset也初始化信号集合,只
%A 是将信号集合设置为所有信号的集合.sigaddset将信号signo加入到信号集合之中,sigd
%A elset将信号从信号集合中删除.sigismember查询信号是否在信号集合之中.
%A sigprocmask是最为关键的一个函数.在使用之前要先设置好信号集合set.这个函数的作
%A 用是将指定的信号集合set加入到进程的信号阻塞集合之中去,如果提供了oset那么当前
%A 的进程信号阻塞集合将会保存在oset里面.参数how决定函数的操作方式.
%A SIG_BLOCK:增加一个信号集合到当前进程的阻塞集合之中.
%A SIG_UNBLOCK:从当前的阻塞集合之中删除一个信号集合.
%A SIG_SETMASK:将当前的信号集合设置为信号阻塞集合.
%A 以一个实例来解释使用这几个函数.
%A ＃i nclude <signal.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <math.h>
%A ＃i nclude <stdlib.h>
%A int main(int argc,char **argv)
%A {
%A double y;
%A sigset_t intmask;
%A int i,repeat_factor;
%A if(argc!=2)
%A {
%A fprintf(stderr,"Usage:%s repeat_factor\n\a",argv[0]);
%A exit(1);
%A }
%A if((repeat_factor=atoi(argv[1]))<1)repeat_factor=10;
%A sigemptyset(&intmask); /* 将信号集合设置为空 */
%A sigaddset(&intmask,SIGINT); /* 加入中断 Ctrl+C 信号*/
%A while(1)
%A {
%A /*阻塞信号,我们不希望保存原来的集合所以参数为NULL*/
%A sigprocmask(SIG_BLOCK,&intmask,NULL);
%A fprintf(stderr,"SIGINT signal blocked\n");
%A for(i=0;i<repeat_factor;i++)y=sin((double)i);
%A fprintf(stderr,"Blocked calculation is finished\n");
%A /* 取消阻塞 */
%A sigprocmask(SIG_UNBLOCK,&intmask,NULL);
%A fprintf(stderr,"SIGINT signal unblocked\n");
%A for(i=0;i<repeat_factor;i++)y=sin((double)i);
%A fprintf(stderr,"Unblocked calculation is finished\n");
%A }
%A exit(0);
%A }
%A 程序在运行的时候我们要使用Ctrl+C来结束.如果我们在第一计算的时候发出SIGINT信号
%A ,由于信号已经屏蔽了,所以程序没有反映.只有到信号被取消阻塞的时候程序才会结束.
%A 注意我们只要发出一次SIGINT信号就可以了,因为信号屏蔽只是将信号加入到信号阻塞
%A 集合之中,并没有丢弃这个信号.一旦信号屏蔽取消了,这个信号就会发生作用.
%A 有时候我们希望对信号作出及时的反映的,比如当拥护按下Ctrl+C时,我们不想什么事情
%A 也不做,我们想告诉用户你的这个操作不好,请不要重试,而不是什么反映也没有的. 这个
%A 时候我们要用到sigaction函数.
%A ＃i nclude <signal.h>
%A
%A int sigaction(int signo,const struct sigaction *act,
%A struct sigaction *oact);
%A struct sigaction {
%A void (*sa_handler)(int signo);
%A void (*sa_sigaction)(int siginfo_t *info,void *act);
%A sigset_t sa_mask;
%A int sa_flags;
%A void (*sa_restore)(void);
%A }
%A 这个函数和结构看起来是不是有点恐怖呢.不要被这个吓着了,其实这个函数的使用相当
%A 简单的.我们先解释一下各个参数的含义. signo很简单就是我们要处理的信号了,可以是
%A 任何的合法的信号.有两个信号不能够使用(SIGKILL和SIGSTOP). act包含我们要对这个
%A 信号进行如何处理的信息.oact更简单了就是以前对这个函数的处理信息了,主要用来保
%A 存信息的,一般用NULL就OK了.
%A 信号结构有点复杂.不要紧我们慢慢的学习.
%A sa_handler是一个函数型指针,这个指针指向一个函数,这个函数有一个参数.这个函数就
%A 是我们要进行的信号操作的函数. sa_sigaction,sa_restore和sa_handler差不多的,只
%A 是参数不同罢了.这两个元素我们很少使用,就不管了.
%A sa_flags用来设置信号操作的各个情况.一般设置为0好了.sa_mask我们已经学习过了
%A 在使用的时候我们用sa_handler指向我们的一个信号操作函数,就可以了.sa_handler有
%A 两个特殊的值:SIG_DEL和SIG_IGN.SIG_DEL是使用缺省的信号操作函数,而SIG_IGN是使用
%A 忽略该信号的操作函数.
%A 这个函数复杂,我们使用一个实例来说明.下面这个函数可以捕捉用户的CTRL+C信号.并输
%A 出一个提示语句.
%A ＃i nclude <signal.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <string.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <unistd.h>
%A #define PROMPT "你想终止程序吗?"
%A char *prompt=PROMPT;
%A void ctrl_c_op(int signo)
%A {
%A write(STDERR_FILENO,prompt,strlen(prompt));
%A }
%A int main()
%A {
%A struct sigaction act;
%A act.sa_handler=ctrl_c_op;
%A sigemptyset(&act.sa_mask);
%A act.sa_flags=0;
%A if(sigaction(SIGINT,&act,NULL)<0)
%A {
%A fprintf(stderr,"Install Signal Action Error:%s\n\a",strerror(errno));
%A exit(1);
%A }
%A while(1);
%A }
%A 在上面程序的信号操作函数之中,我们使用了write函数而没有使用fprintf函数.是因为
%A 我们要考虑到下面这种情况.如果我们在信号操作的时候又有一个信号发生,那么程序该
%A 如何运行呢? 为了处理在信号处理函数运行的时候信号的发生,我们需要设置sa_mask成
%A 员. 我们将我们要屏蔽的信号添加到sa_mask结构当中去,这样这些函数在信号处理的时
%A 候就会被屏蔽掉的.
%A 3。其它信号函数 由于信号的操作和处理比较复杂,我们再介绍几个信号操作函数.
%A
%A ＃i nclude <unistd.h>
%A ＃i nclude <signal.h>
%A int pause(void);
%A int sigsuspend(const sigset_t *sigmask);
%A pause函数很简单,就是挂起进程直到一个信号发生了.而sigsuspend也是挂起进程只是在
%A 调用的时候用sigmask取代当前的信号阻塞集合.
%A ＃i nclude <sigsetjmp>
%A int sigsetjmp(sigjmp_buf env,int val);
%A void siglongjmp(sigjmp_buf env,int val);
%A 还记得goto函数或者是setjmp和longjmp函数吗.这两个信号跳转函数也可以实现程序的
%A 跳转让我们可以从函数之中跳转到我们需要的地方.
%A 由于上面几个函数,我们很少遇到,所以只是说明了一下,详细情况请查看联机帮助.
%A 4。一个实例 还记得我们在守护进程创建的哪个程序吗?守护进程在这里我们把那个
%A 程序加强一下. 下面这个程序会在也可以检查用户的邮件.不过提供了一个开关,如果用
%A 户不想程序提示有新的邮件到来,可以向程序发送SIGUSR2信号,如果想程序提供提示可以
%A 发送SIGUSR1信号.
%A ＃i nclude <unistd.h>
%A ＃i nclude <stdio.h>
%A ＃i nclude <errno.h>
%A ＃i nclude <fcntl.h>
%A ＃i nclude <signal.h>
%A ＃i nclude <string.h>
%A ＃i nclude <pwd.h>
%A ＃i nclude <sys/types.h>
%A ＃i nclude <sys/stat.h>
%A /* Linux 的默任个人的邮箱地址是 /var/spool/mail/ */
%A #define MAIL_DIR "/var/spool/mail/"
%A /* 睡眠10秒钟 */
%A #define SLEEP_TIME 10
%A #define MAX_FILENAME 255
%A unsigned char notifyflag=1;
%A long get_file_size(const char *filename)
%A {
%A struct stat buf;
%A if(stat(filename,&;buf)==-1)
%A {
%A if(errno==ENOENT)return 0;
%A else return -1;
%A }
%A return (long)buf.st_size;
%A }
%A void send_mail_notify(void)
%A {
%A fprintf(stderr,"New mail has arrived7\n");
%A }
%A void turn_on_notify(int signo)
%A {
%A notifyflag=1;
%A }
%A void turn_off_notify(int signo)
%A {
%A notifyflag=0;
%A }
%A int check_mail(const char *filename)
%A {
%A long old_mail_size,new_mail_size;
%A sigset_t blockset,emptyset;
%A sigemptyset(&;blockset);
%A sigemptyset(&;emptyset);
%A sigaddset(&;blockset,SIGUSR1);
%A sigaddset(&;blockset,SIGUSR2);
%A old_mail_size=get_file_size(filename);
%A if(old_mail_size<0)return 1;
%A if(old_mail_size>0) send_mail_notify();
%A sleep(SLEEP_TIME);
%A while(1)
%A {
%A if(sigprocmask(SIG_BLOCK,&;blockset,NULL)<0) return 1;
%A while(notifyflag==0)sigsuspend(&;emptyset);
%A if(sigprocmask(SIG_SETMASK,&;emptyset,NULL)<0) return 1;
%A new_mail_size=get_file_size(filename);
%A if(new_mail_size>old_mail_size)send_mail_notify;
%A old_mail_size=new_mail_size;
%A sleep(SLEEP_TIME);
%A }
%A }
%A int main(void)
%A {
%A char mailfile[MAX_FILENAME];
%A struct sigaction newact;
%A struct passwd *pw;
%A if((pw=getpwuid(getuid()))==NULL)
%A {
%A fprintf(stderr,"Get Login Name Error:%s\n\a",strerror(errno));
%A exit(1);
%A }
%A strcpy(mailfile,MAIL_DIR);
%A strcat(mailfile,pw->pw_name);
%A newact.sa_handler=turn_on_notify;
%A newact.sa_flags=0;
%A sigemptyset(&;newact.sa_mask);
%A sigaddset(&;newact.sa_mask,SIGUSR1);
%A sigaddset(&;newact.sa_mask,SIGUSR2);
%A if(sigaction(SIGUSR1,&;newact,NULL)<0)
%A fprintf(stderr,"Turn On Error:%s\n\a",strerror(errno));
%A newact.sa_handler=turn_off_notify;
%A if(sigaction(SIGUSR1,&;newact,NULL)<0)
%A fprintf(stderr,"Turn Off Error:%s\n\a",strerror(errno));
%A check_mail(mailfile);
%A exit(0);
%A }
%A 信号操作是一件非常复杂的事情,比我们想象之中的复杂程度还要复杂,如果你想彻底的
%A 弄清楚信号操作的各个问题,那么除了大量的练习以外还要多看联机手册.不过如果我们
%A 只是一般的使用的话,有了上面的几个函数也就差不多了. 我们就介绍到这里了.
%A
%A