linux文件操作

一、linux几个目录

1. /bin 用于储存普通用户可执行的命令，如ls，cp

2. /boot linux内核及启动系统是所需要的文件，保证启动文件安全

3. /dev 设备文件的储存目录，如硬盘，光驱（更体现一切皆文件）

4. /etc 用于存放系统的配置文件，比如账户密码

5. /home 普通用户主目录

6. /lib 用于存放各种库文件

7. /proc 该目录是一个虚拟文件系统，只有在系统运行时才存在。可以获取系统的状态信息并且修改某些系统的配置信息。cat/proc/memifo可以获取系统内存的使用状态

8. /sbin是用来存放用于管理系统的命令

9. /tmp 临时文件目录

10. /usr 用于存放系统应用程序及相关文件，如说明文档，帮助文档

11. /var用于存放系统中经常变化的文件，如日志文件，用户邮件

二、文件系统模型

物理磁盘的访问都是通过设备驱动程序进行的。对设备驱动的访问有两种途径：1、通过设备驱动本身提供的接口 2、通过虚拟文件系统提供给上层应用程序的接口（与proc相同，都是只存在与内存而不存在与磁盘之中）

三、文件访问权限

1.r=4，w=2，x=1

2.int chmod（const char *path,mode_t mode)和int fchmod（intflides，mode_t mode)

头文件是#include<sys/types.h>和#include<sys/sta.h>

3.mode的参数

参数	八进制	含义
S_IRUSR（S_IREAD）	0400	文件所有者具可读
S_IWUSR（S_IWRITE）	0200	文件所有者具可写入权限
S_IXUSR（S_IEXEC）	00100	文件所有者具可执行权限
S_IRGRP	00040	用户组具可读取权限
S_IWGRP	00020	用户组具可写入权限
S_IXGRP	00010	用户组具可执行权限
S_IROTH	00004	其他用户具可读取权限
S_IWOTH	00002	其他用户具可写入权限
S_IXOTH	00001	其他用户具可执行权限

my_chmod.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>

int main(int argc,char **argv)
{
    int mode;
    int mode_u;
    int mode_g;
    int mode_o;
    char *path;

    if(argc<3)//保证和命令chmod的参数相同
    {
        printf("%s <mode num> <target file>\n",argv[0]);
        exit(0);
    }
    mode=atoi(argv[1]);//这里默认你现在获得的参数就是8进制
    if(mode>777||mode<0)//保证输入在范围之内
    {
        printf("mode num error\n");
        exit(0);
    }
    mode_u=mode/100;//求出各个位数
    mode_g=(mode-(mode_u*100))/10;
    mode_o=mode-(mode_u*100)-(mode_g*10);
    mode=(mode_u*8*8)+mode_g*8+mode_o;//这里是8进制转换为十进制
    path=argv[2];//实际就是将字符串首地址给了path
    if(chmod(path,mode)==-1)//chmod会认为你输入就是10进制，内部会处理，所以这个chmod程序只能说是一个简化
    {
        perror("chmod errorr");//输出错误信息
       //perror(s) 用来将上一个函数发生错误的原因输出到标准设备(stderr)
        exit(1);
    }
    return 0;

}

四、文件打开和关闭

1、open函数

#include<sys/types.h> 
#include<sys/stat.h> #include<fcntl.h>
int open(const char *pathname,int flags)
int open(const char *pathname,int flags,mode_t mode);
//具体用哪一个，是由参数flags决定

2.creat函数

int creat(const char *pathname,mode_t mode);
creat只能以只写的方式打开创建的文件

3.close函数

int clode(int fd)
- 成功调用返回一个文件描述符号，否则返回-1
my_creat.c

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

int main()
{
    int fd;

    if((fd=open("example_62.c",O_CREAT|O_EXCL,S_IRUSR|S_IWUSR))==-1)
       // if((fd=creat("example_62.c",S_IRWXU))==-1)
        {
            perror("open");
           // printf("open:%s   with errno:%d\n",strerror(errno),errno);/;/strerror会把错误以字符串形式输出，errno是全局变量对应数字是错误
            exit(1);
        }
    else 
    {
        printf("create file success!\n");
    }
    close(fd);
    return 0;
}

mode参数	含义
O_RDONLY	只读打开
O_WRONLY	只写打开
O_RDWR	读写打开
O_SEARCH	(仅对目录有意义)只搜索打开
O_APPEND	每次写文件时都追加到文件的尾部
O_CLOEXEC	将FD_CLOEXEC设置为文件描述符标志
O_CREAT	若该文件不存在则创建
O_EXCL	(指定了O_CREAT)若文件已存在则报错
O_NOFOLLOW	若文件是一个符号链接则报错
O_SYNC	对文件的修改将阻塞直到物理磁盘上同步为止
O_DIRECTORY	若文件不是一个目录则失败
O_NONBLOCK	以非阻塞的方式打开文件
O_NDELAY	以非阻塞方式打开文件
O_TRUNC	当文件存在并以可写方式打开则截断文件至0

errno定义的那些内容可以通过程序输出（这里感谢殷大佬的提示)

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

int main(void) 
{
    int i;
    for(i = 0;i < 140;i++) 
    {
         errno = i;
         printf("%d error:%s\n",errno,strerror(errno));   
    }
        return 0;
}

五、文件的读写

1、read函数

#include<unistd.h>
ssize_t read(int fd,void *buf,size_t count);
//从文件描述符fd所指向的文件中读取count个字节到buf中
//返回值表示世界读取字节数

2、write是从buf中读取count个字节到fd中

返回值相同

3、lseek函数

#include<unistd.h> #include<sys/types.h>
//和fseek类似

注意：
①fseek()不像lseek()会返回读写位置, 因此必须使用ftell()来取得目前读写的位置.
②lseek当调用成功时则返回目前的读写位置, 也就是距离文件开头多少个字节. 若有错误则返回-1, errno 会存放错误代码.

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

void my_err(const char *err_string,int line)//错误处理
{
    fprintf(stderr,"line:%d ",line);
    perror(err_string);
    exit(1);
}

int my_read(int fd)//读数据
{
    int len;
    int ret;
    int i;
    char read_buf[64];
    //SEEK_END表示结束
    //SEEK_SET表示开头
    //SEEK_CUR表示当前位置
    if(lseek(fd,0,SEEK_END)==-1)
        my_err("lseek",__LINE__);
    if((len=lseek(fd,0,SEEK_CUR))==-1)
        my_err("lseek",__LINE__);
    if((lseek(fd,0,SEEK_SET))==-1)
        my_err("lseek",__LINE__);
    if((ret=read(fd,read_buf,len))<0)
         my_err("read",__LINE__);
    printf("len:%d\n",len);
    for(i=0;i<len;i++)
    {
        printf("%c",read_buf[i]);
    }
    putchar('\n');

    return ret;
}
int main()
{
    int fd;
    char write_buf[32]="hello,world!";

    //if((fd=creat("example_63.c",S_IRWXU))==-1)
    if((fd=open("example_63.c",O_RDWR|O_CREAT|O_TRUNC,S_IRWXU))==-1)
    {
        my_err("open",__LINE__);
    }
    else 
        printf("create file success\n");


 //写数据   if(write(fd,write_buf,strlen(write_buf))!=strlen(write_buf))
       my_err("write",__LINE__);
    my_read(fd);

    printf("/*-----------------*/\n");
    if(lseek(fd,10,SEEK_END)==-1)
       my_err("lseek",__LINE__);
    if(write(fd,write_buf,strlen(write_buf))!=strlen(write_buf))
       my_err("write",__LINE__);
    my_read(fd);

    close(fd);
    return 0;
}

六、fcntl系统调用

1、#include<unistd.h> 
#include<fcntl.h>
①int fcntl(int fd,int cmd)
②int fcntl(int fd,int cmd,long arg)
③int fcntl(int fd,int cmd,struct flock *lock)

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

void my_err(const char *err_string,int line)//错误处理函数
{
    fprintf(stderr,"line:%d ",line);
    perror(err_string);
    exit(1);
}

int main()
{
    int ret;
    int access_mode;
    int fd;   if((fd=open("example_64",O_CREAT|O_TRUNC|O_RDWR,S_IRWXU))==-1)
        my_err("open",__LINE__);
    if((ret=fcntl(fd,F_SETFL,O_APPEND))<0)//设置文件打开方式
        my_err("fcntl",__LINE__);

    if((ret=fcntl(fd,F_GETFL,0))<0)//获取文件打开方式
        my_err("fcntl",__LINE__);
    access_mode=ret & O_ACCMODE;//O_ACCMODE为3，&可以获得ret后两位
    if(access_mode==O_RDONLY)
        printf("example_64 access_mode:read only");
    else if(access_mode==O_WRONLY)
        printf("example_64 access_mode:write only");
    else if(access_mode==O_RDWR)
        printf("example_64 access_mode:write+read");

    if(ret&O_APPEND)
        printf(" ,append");
    printf("\n%d\n",O_APPEND);

    printf("\n%d\n",O_NONBLOCK);

    printf("\n%d\n",O_SYNC);
    if(ret&O_NONBLOCK)
        printf(",nonblock");
    if(ret&O_SYNC)
        printf(" ,sync");

    putchar('\n');

    return 0;
}

2、锁
共享锁言简意赅就是说大家可以读这个文件
互斥锁就是只能一个人去写这个文件，防止不同人打开，最后文件混乱
int fcntl(int fd,int cmd,struct flock *lock)

struct flock {
        short l_type;/*锁的类型F_RDLCK, F_WRLCK, or F_UNLCK*/
        off_t l_start;/*相对于l_whence的偏移值，字节为单位*/
        short l_whence;/*从哪里开始：SEEK_SET, SEEK_CUR, or SEEK_END*/
        off_t l_len;/*长度, 字节为单位; 0 意味着缩到文件结尾*/
        pid_t l_pid;/*returned with F_GETLK*/
    };

注意：
①cmd为中有一个F_GETTLK只是修改了结构体中锁的类型为F_UNLCK
②程序只是一个进程的时候可以设置写锁之后，设置读锁，但是多个进程的锁是不兼容的，所以下面的例子是单个进程

#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<string.h>
#include<stdlib.h>

void my_err(const char *err_string,int line)
{
    fprintf(stderr,"line:%d ",line);
    perror(err_string);
    exit(1);    
}
//锁的设置或释放
int lock_set(int fd,struct flock *lock)
{
    if(fcntl(fd,F_SETLK,lock)==0)
    {
        if(lock->l_type==F_RDLCK)
            printf("set read lock,pid:%d\n",getpid());
            //getpid()取得进程识别码
        else if(lock->l_type==F_WRLCK)
            printf("set write lock,pid:%d\n",getpid());
        else if(lock->l_type==F_UNLCK)
            printf("release lock,pid:%d\n",getpid());
    }
    else
    {
        perror("lock operation fail\n");
        return -1;
    }
}
//测试锁
int lock_test(int fd,struct flock *lock)
{
    if(fcntl(fd,F_GETLK,lock)==0)
    {   
        if(lock->l_type==F_UNLCK)
            {
                printf("lock can be set in fd\n");
                return 0;
            }
        else 
        {
            if(lock->l_type==F_RDLCK)
                printf("can't set lock,read lock has been set by:%d\n",lock->l_pid);
            else if(lock->l_type==F_WRLCK)
                printf("can't set lock,write lock has been set by:%d\n",lock->l_pid);
        }
        return -2;
   }
    else
    {
        perror("get incompatible locks fail");
        return -1;
    }
}

int main()
{
    int fd;
    int ret;
    struct flock lock;
    char read_buf[32];
    //打开文件
    if((fd=open("example_65",O_CREAT|O_TRUNC|O_RDWR,S_IRWXU))==-1)
        my_err("open",__LINE__);
    if(write(fd,"test lock",10)!=10)
        my_err("write",__LINE__);
    //初始化
    memset(&lock,0,sizeof(struct flock));
    lock.l_start=SEEK_SET;
    lock.l_whence=0;
    lock.l_len=0;

    //设置读锁
    lock.l_type=F_RDLCK;//就是检测可不可以设置读锁
    if(lock_test(fd,&lock)==0)
    {
        lock.l_type=F_RDLCK;
        lock_set(fd,&lock);
    }
    //读数据
    lseek(fd,0,SEEK_SET);
    if((ret=read(fd,read_buf,10))<0)
        my_err("read",__LINE__);

    read_buf[ret]='\0';
    printf("%s\n",read_buf);

    //任意键
    getchar();
    //设置写锁
   lock.l_type=F_WRLCK;
    if(lock_test(fd,&lock)==0)
       {
           lock.l_type=F_WRLCK;
           lock_set(fd,&lock);
       }
    //释放锁
    lock.l_type=F_UNLCK;
    lock_set(fd,&lock);
    close(fd);
    return 0;
}

七、文件属性操作

1、获取文件属性int lstat(int fileds,char *file_name,struct stat*buf)

执行成功为0.失败为-1

struct stat  {  
    dev_t       st_dev;     /*文件所在设备的ID*/  
    ino_t       st_ino;     /* 节点号*/  
    mode_t      st_mode;    /* 文件的类型和存取的权限*/  
    nlink_t     st_nlink;   /* 链向此文件的连接数(硬连接)*/  
    uid_t       st_uid;     /* user's id*/  
    gid_t       st_gid;     /* group's id*/  
    dev_t       st_rdev;    /* 设备号，针对设备文件*/  
    off_t       st_size;    /* 文件大小，字节为单位*/  
    blksize_t   st_blksize; /* 系统块的大小*/  
    blkcnt_t    st_blocks;  /* 文件所占块数*/  
    time_t      st_atime;   /* 最近存取时间*/  
    time_t      st_mtime;   /* 最近修改时间*/  
    time_t      st_ctime;   /*最后状态修改时间*/  
};  

宏定义好的几个函数

参数	含义
S_ISLNK(st_mode)	是否是一个连接
S_ISREG(st_mode)	是否是一个常规文件
S_ISDIR(st_mode)	是否是一个目录
S_ISCHR(st_mode)	是否是一个字符设备
S_ISBLK(st_mode)	是否是一个块设备
S_ISFIFO(st_mode)	是否 是一个FIFO文件
S_ISSOCK(st_mode)	是否是一个SOCKET文件

2、设置文件属性

mode_t unmask(mode_t mask)屏蔽属性

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
int main()
{
    umask(0);//不屏蔽
    if(creat("example_681.test",S_IRWXU|S_IRWXG|S_IRWXO)<0)
    {
        perror("creat");
        exit(1);
    }
    umask(S_IRWXO);//其他用户没有可读可写可执行
    if(creat("example_682.test",S_IRWXU|S_IRWXG|S_IRWXO)<0)
    {
        perror("creat");
        exit(1);
    }
    return 0;

}

八、目录的创建和删除、切换

1、目录的创建

#include<sys/stat.h> 
#include<sys/typed.h> 
int mkdir(const char *pathname,mode_t mode);

2、目录删除

#include<unistd.h>  
int mkdir(const char *pathanme)

• 注意：只能删除空目录

3、获取当前目录

#include<unistd.h> 
char *getcwd(char *buf,size_t size);
char *get_current_dir_name(void)
char *getwd(char *buf)

①get_current_dir_name获取当前工作目录

#define  _GNU_SOURCE  
/*这是用来让用户配置编译环境的头文件。再看一下_GUN_SOURCE这个宏，这个宏可以让用户打开所有features.h文件的属性，而且其他头文件在获得这个宏定义之后才可以使用get——current_dir_name这个函数*/
#include<stdio.h>
#include <stdio.h>
#include <unistd.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
            char *path;
            path = get_current_dir_name();
            printf("%s>\n",path);
            exit(0);

}

/*用gcc -E将预处理的代码导出来查看，如果宏定义的位置不正确。
导出的代码中不会包含get_current_dir_name()的函数原型，自然编译就认为它的返回值是默认的整数，从而导致一个警告。
把宏定义放在前面之后，gcc -E导出的代码中已经包含了正确的函数原型，警告就不会出现了。*/

②getcwd函数获取绝对路径

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main(void)
{
    char *path = NULL;
    path = getcwd(NULL,0);
    /*或者使用方法getcwd（path，256）,256是给path分配的空间，path就储存了空间*/
    puts(path);
    free(path);
    return 0;
}
/*可以采取令 buf 为 NULL并使 size 为零,来使 getcwd 调用 malloc 动态给 buf 分配,但是这种情况要特别注意使用后释放缓冲以防止内存泄漏。*/

4、切换工作目录

#include<unistd.h>
int chdir(const char *path);//path是目录参数
int fchdir(int fd);//fd是文件描述符号

例子是fchdir的使用

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
      int fd;
      fd = open("../", O_RDONLY);
      fchdir(fd);
      printf("current working directory : %s \n", getcwd(NULL, 0));
      close(fd);

}

九、获取目录信息

1、opendir

#include<sys/types.h>
#include<dirent.h>
DIR *opendir(const char *name)
失败返回NULL

2.readdir

#include<sys/types.h>
#include<dirent.h>
原型DIR *readdir(DIR*dir)

struct dirent{
    long d_ino;//索引节点号
    off_t d_off;//在文件中偏移量
    unsigned short d_reclen;//文件名长
    char d_name[NAME_MAX+1];
}

3.closedir

#include<sys/types.h>
#include<dirent.h>
原型DIR *closedir(DIR*dir)

#include<stdio.h>
#include<dirent.h>
#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int my_readir(const char *path)
{
    DIR *dir;
    struct dirent *ptr;

    if((dir=opendir(path))==NULL)
    {
        perror("opendir");
        return -1;
    }
    while((ptr=readdir(dir))!=NULL)//直到NULL才会停止读取
        printf("File name:%s\n",ptr->d_name);
    closedir(dir);

    return 0;
}
int main(int argc,char *argv[])
{
    if(argc<2)//判断参数
    {
        printf("listfile <target path>\n");
        exit(1);
    }
    if(my_readir(argv[1])<0)
        exit(1);

    return 0;
}

注意:
      这里所说的打开目录，只是获取了目录的信息，没有实际的进入你所打开的目录，你可以获取进入目录的名字，如果想切换目录，必须用chdir或fdir。用opendir打开，如果再想更深层次进入打开目录的目录是不可以的，opendir没有将你的目录切换。
      比如你在linux目录下有一个ls目录，你打开了ls，发现ls目录下有个fun目录，你想进fun看看有什么，你会再次用opendir打开fun这个目录，但是实际上opendir会在linux目录下找fun，因为你的工作目录没有切换，当然linux下没有fun这个目录，就会报错。