Unix下C语言----低级文件编程

1.文件的打开与创建

#include<fcntl.h>

int open(const char * filename,int oflag,.../*mode_t mode*/);

--filename指定了打开或创建文件的路径名；

--oflag制定了打开或创建文件的方式

--mode是可选参数，决定新文件的模式，仅当创建文件时有效。

当函数调用成功时，将为文件filename创建一个文件描述符并返回之，否则返回-1；

参数oflag控制打开文件的读写方式{1.O_RDONLY、O_WRONLY、O_RDWR}、常规方式和同步方式；

2.文件的关闭与删除

函数close关闭一个已经打开的文件，函数unlink删除文件，它们的原型为：

#include<unistd.h>

int close(int fildes);

int unlink(char *path);

注：只是用一次的临时文件，可以先删除再是用，这样子不必担心忘记删除文件而造成磁盘垃圾文件了。

/*-----临时文件使用模板unlink.c-----*/
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
void main()
{
int fno;
if((fno=open("./tmpfile",O_RDWR|O_CREAT|O_EXCL,0755))<0)
{
fprintf(stderr,"open file error!/n");
return ;
}
unlink("./tmpfile");
sleep(60);
printf("end./n");
}

3.文件读写

#include<unistd.h>
ssize_t read(int fildes,void *buff,size_t nbytes);
ssize_t write(int fildes,const void *buff,size_t nbytes);
/*read函数从文件描述符fildes所指向的文件中读取nbytes个字节的数据到buff所指向的内存中去。如果read成功，函数返回实际读取的字节数；如果文件结束或参数nbytes值为0，函数返回为0；若调用出错，函数返回-1，并将错误码写入errno中。*/
/*write把buff所指向的内存数据向文件描述符fildes所指向的文件中写入nbytes个字节。如write成功，函数返回实际写入的字节数。否则返回-1，并将错误写入errno中*/
/*--------read.c------*/
#include<unistd.h>
void main()/
{
char buff[11];
printf("%d",read(0,buf,sizeof(buf)));
}

/*---------write.c-----*/
#include<unistd.h>
void main()
{
char buf[10]="abcchina";
printf("%d",write(1,buf,sizeof(buf)));
}

4.文件定位

#include<unistd.h>

off_t lseek(int fildes,off_t offset,int whence);

实例：函数lseek允许定位到当前文件最大位置之后，倘若定位成功并且写入数据，则文件将自动延长到写入位置，中间部分以0填充。但是若定位位置大大超过了当前文件长度，则UNIX操作系统只虚增文件长度，实际并不分配磁盘块。以下设计虚增文件的实例:

#include<unistd.h>
#include<fcntl.h>
void main()
{
int fno;
if((fno=open("hole.dat",O_WRONLY|O_CREAT,0755))<0)
{
printf("open file hole.dat failed./n");
return ;
}
lseek(fno,1000000000,SEEK_SET);
write(fno,"eee",3);
close(fno);
}

5.文件缓冲

函数fsync将缓冲信息写入文件中，它的原型为：

#include<unistd.h>

int fsync(int fildes);

系统调用fsync将所有已写入文件描述符fildes的数据真正写到磁盘或其它设备中，类似于标准文件变成库fflush，当系统调用成功时返回0，否则返回-1。

6.复制文件描述符

低级文件编程库中复制文件描述符的函数如下：

#include<unistd.h>

int dup(int fildes);

int dup2(int fildes,int fildes2);

函数dup复制文件描述符fildes到当前未使用的最小可用描述符中。函数dup2复制文件描述符fildes到描述符fildes2中，如果fildes2已经打开，则关闭；如果fildes2与fildes值相等，则直接返回。这两个函数在调用成功时都返回新的文件描述符，否则返回-1。

7.文件控制

1)文件锁

多用户多任务操作系统中非常重要的一个内容就是文件锁。用户在更新文件时，期望可以使用某种机制，防止两种进程同时更新文件同一区域而造成丢失，或者防止文件内容在未更新完毕时被读取等并发引起的问题，这种机制就是文件锁。

进程在操作文件期间，可以使用文件锁，锁定文件中的敏感部分，防止其他进程越权操作该部分数据。函数fcntl提供了对文件任意区域置锁的能力，既可以锁住全部文件，又可以锁住文件的部分记录，故文件锁又成为"记录锁".

根据文件锁的访问方式，可以区分读锁和写锁两种。读锁又名共享锁，它用来防止进程读取的文件记录被更改。文件记录可以同时设置多个读锁，但当有一个读锁存在时，就不能在该记录出设置写锁。

写锁又名互斥锁，它用来保证文件更改记录时不被干扰，确保文件一致性和完整性，防止写丢失或读"脏"数据。文件记录一旦设置了写锁，就不能再设置任意锁，除非写锁接触。

文件记录在同一时刻，可以设置多个读锁，单仅能设置一个写锁，并且读、写不能不能同时存在。

当函数fntl专用于锁操作时，其原型为：

int fcntl(int fildes,int cmd,struct flock *arg);

其中，结构flock用于描述文件锁的信息，定义于"fcntl.h"中，如下表示：

struct flock
{
short l_type;/*锁类型，取值为F_RDLCK、F_WRLCK、或F_UNLCK之一，分别代表申请读锁、申请写锁和释放锁*/
short l_whence;/*锁区域开始地址的相对位置，类似于lseek中whence参数，取值是SEEK_SET SEEK_CUR SEEK_END之一，分别表示相对文件起始位置、文件当前位置、文件结束位置*/
long l_start;/*锁区域开始地址偏移量，同l_whence共同确定锁区域*/
long l_len;/*锁的长度，0表示锁至文件末*/
long l_pid;/*拥有锁的进程ID号*/
};

当函数fcntl专用于锁时，参数cmd的三种取值：

F_GETLK

F_SETLK

F_SETLKW

{文件锁最典型的应用于两个方面：一个锁定文件中的临界数据，比如并发投票时文件记录的投票数;二是利用具有互斥性质的写锁，实现进程的并发控制}

2)文件锁操作

在锁机制的使用中，最常见的操作有锁的请求、释放和测试等，这些操作代买基本类似

(1)测试锁

设计函数SeeLock，它查询文件描述符fd对应文件的锁信息，其原型为：

void SeeLock(int fd,int start,int len);

函数查询描述符fd对应文件从偏移start出开始的len字节中的锁信息

/*----测试所源码----lock1.c----*/
void SeekLock(int fd,int start,int len)
{
struct flock arg;
arg.l_type=F_WRLCK;
arg.l_whence=SEEK_SET;
arg.l_start=start;
arg.l_len=len;
if(fcntl(fd,F_GETLK,&arg)==-1)
fprintf(stderr,"See Lock failed./n");
else if(arg.l_type==F_UNLCK)
fprintf(stderr,"NO LOCK FROM %d TO %d,n",start, len);
else if(arg.l_type==F_WRLCK)
fprintf(stderr,"WRITE LOCK FROM %d TO %d ,id=%d/n",start,len,arg.l_pid);
else if(arg.l_type==F_RDLCK)
fprintf(stderr,"READ LOCK FROM %d To %d,id=%d/n",start,len,arg.l_pid);
}

(2)申请读锁

共享锁申请函数GetReadLock，原型为：

void GetReadLock(int fd,int start,int len);

以阻塞模式在文件描述符fd相应的文件中申请共享读锁，锁定的区域从偏移start处开始的len字节

/*---阻塞申请共享读锁源码---lockl.c*/
void GetReadLock(int fd,int start,int len)
{
struct flock arg;
arg.l_type=F_RDLCK;
arg.l_whence=SEEK_SET;
arg.l_start=start;
arg.l_len=len;
if(fcntl(fd,F_SETLKW,&arg)==-1)
fprintf(stderr,"[%d] Set Read Lock failed./n",getpid());
else
fprintf(stderr,"[%d] Set Read Lock From %d To %d",getpid(),start,len);
}

(3)申请写锁

void GetWriteLock(int fd,int start,int len);

/*---阻塞申请共享写锁源码---lockl.c*/
void GetReadLock(int fd,int start,int len)
{
struct flock arg;
arg.l_type=F_WRLCK;
arg.l_whence=SEEK_SET;
arg.l_start=start;
arg.l_len=len;
if(fcntl(fd,F_SETLKW,&arg)==-1)
fprintf(stderr,"[%d] Set Write Lock failed./n",getpid());
else
fprintf(stderr,"[%d] Set Write Lock From %d To %d",getpid(),start,len);
}

(4)释放锁

设计文件锁释放函数ReleaseLock，原型为：

void ReleaseLock(int fd,int start,int len);

/*---释放锁源码---lockl.c*/
void GetReadLock(int fd,int start,int len)
{
struct flock arg;
arg.l_type=F_UNLCK;
arg.l_whence=SEEK_SET;
arg.l_start=start;
arg.l_len=len;
if(fcntl(fd,F_SETLKW,&arg)==-1)
fprintf(stderr,"[%d] UnLock failed./n",getpid());
else
fprintf(stderr,"[%d] UnLock From %d To %d",getpid(),start,len);
}

以下是一个文件锁控制进程的实例，如下：

#include<stdio.h>
#include<fcntl.h>
void main()
{
int fd;
struct flock arg;
if((fd=open("/tmp/tlockl",O_RDWR|O_CREAT,0755))<0)
{
fprintf(stderr,"open file failed./n");
retrun;
}
SeeLock(fd,0,10);
GetReadLock(fd,0,10);/*申请读锁*/
SeeLock(fd,11,20);
GetWriteLock(fd,11,20);/*申请写锁*/
sleep(30);
ReleaseLock(fd,0,10);
ReleaseLock(fd,11,20);
}

8.通过函数库之读写功能库封装

本类函数包括阻塞读写和定时读写两种

1)阻塞读写函数库

(1)ReadFile

控制read的读取文件字节数函数，其原型为：

int ReadFile(int nFile,void *pData,int *pSize);

函数从文件描述符nFile所指向的文件中读取nSize个字节的数据到内存pData中，仅当错误发生，或者全部数据读取完毕时，函数返回。

(2)WriteFile

控制write的写入文件字节数函数，原型为：

int WriteFile(int nFile,void *pData,int nSize);

/*-----------file.c----------*/
int ReadFile(int nFile,void *pData,int *pSize)
{
int nLeft,nRead;
char *pcData=pData;
ASSERT(pData !=NULL && pSize !=NULL);
nLeft= *pSize;
while(nLeft>0)
{
if((nRead=read(nFile,pcData,nLeft))<0)
{
if(errno !=EINTR) ASSERT(0);
nRead=0;
}
else if(nRead==0) break;
nLeft -=nRead;
pcData +=nRead;
}
*pSize=*pSIze-nLeft;
return 0;
}
/*程序中错误代码EINTR表示在读取数据之前，系统调用read被一个信号singal中断，可以继续执行读取操作*/

2)阻塞读写函数库应用实例

程序读取键盘输入，当且仅当读入了一定量的字符数后函数才返回，如下：

#include<comlib.h>
void main()
{
char buf[11];
int size=sizeof(buf);
ReadFile(0,buf,&size);
printf("%d",size);
}