Linux stat函数讲解

表头文件:    #include
                     #include
定义函数:    int stat(const char *file_name, struct stat *buf);

函数说明:    通过文件名filename获取文件信息，并保存在buf所指的结构体stat中
返回值:     执行成功则返回0，失败返回-1，错误代码存于errno
错误代码:
    ENOENT         参数file_name指定的文件不存在
    ENOTDIR        路径中的目录存在但却非真正的目录
    ELOOP          欲打开的文件有过多符号连接问题，上限为16符号连接
    EFAULT         参数buf为无效指针，指向无法存在的内存空间
    EACCESS        存取文件时被拒绝
    ENOMEM         核心内存不足
    ENAMETOOLONG   参数file_name的路径名称太长
#include
#include
#include
int main() {
    struct stat buf;
    stat("/etc/hosts", &buf);
    printf("/etc/hosts file size = %d\n", buf.st_size);
}
-----------------------------------------------------
struct stat {
    dev_t         st_dev;       //文件的设备编号
    ino_t         st_ino;       //节点
    mode_t        st_mode;      //文件的类型和存取的权限
    nlink_t       st_nlink;     //连到该文件的硬连接数目，刚建立的文件值为1
    uid_t         st_uid;       //用户ID
    gid_t         st_gid;       //组ID
    dev_t         st_rdev;      //(设备类型)若此文件为设备文件，则为其设备编号
    off_t         st_size;      //文件字节数(文件大小)
    unsigned long st_blksize;   //块大小(文件系统的I/O 缓冲区大小)
    unsigned long st_blocks;    //块数
    time_t        st_atime;     //最后一次访问时间
    time_t        st_mtime;     //最后一次修改时间
    time_t        st_ctime;     //最后一次改变时间(指属性)
};
先前所描述的st_mode 则定义了下列数种情况：
    S_IFMT   0170000    文件类型的位遮罩
    S_IFSOCK 0140000    scoket
    S_IFLNK 0120000     符号连接
    S_IFREG 0100000     一般文件
    S_IFBLK 0060000     区块装置
    S_IFDIR 0040000     目录
    S_IFCHR 0020000     字符装置
    S_IFIFO 0010000     先进先出
    S_ISUID 04000     文件的(set user-id on execution)位
    S_ISGID 02000     文件的(set group-id on execution)位
    S_ISVTX 01000     文件的sticky位
    S_IRUSR(S_IREAD) 00400     文件所有者具可读取权限
    S_IWUSR(S_IWRITE)00200     文件所有者具可写入权限
    S_IXUSR(S_IEXEC) 00100     文件所有者具可执行权限
    S_IRGRP 00040             用户组具可读取权限
    S_IWGRP 00020             用户组具可写入权限
    S_IXGRP 00010             用户组具可执行权限
    S_IROTH 00004             其他用户具可读取权限
    S_IWOTH 00002             其他用户具可写入权限
    S_IXOTH 00001             其他用户具可执行权限
    上述的文件类型在POSIX中定义了检查这些类型的宏定义：
    S_ISLNK (st_mode)    判断是否为符号连接
    S_ISREG (st_mode)    是否为一般文件
    S_ISDIR (st_mode)    是否为目录
    S_ISCHR (st_mode)    是否为字符装置文件
    S_ISBLK (s3e)        是否为先进先出
    S_ISSOCK (st_mode)   是否为socket
    若一目录具有sticky位(S_ISVTX)，则表示在此目录下的文件只能被该文件所有者、此目录所有者或root来删除或改名。
-----------------------------------------------------
struct statfs {
    long    f_type;          //文件系统类型
    long    f_bsize;         //块大小
    long    f_blocks;        //块多少
    long    f_bfree;         //空闲的块
    long    f_bavail;        //可用块
    long    f_files;         //总文件节点
    long    f_ffree;         //空闲文件节点
    fsid_t f_fsid;           //文件系统id
    long    f_namelen;       //文件名的最大长度
    long    f_spare[6];      //spare for later
};

使用stat函数最多的可能是ls-l命令，用其可以获得有关一个文件的所有信息。
1 函数都是获取文件（普通文件，目录，管道，socket，字符，块（）的属性。
函数原型
#include
int stat(const char *restrict pathname, struct stat *restrict buf);
提供文件名字，获取文件对应属性。
int fstat(int filedes, struct stat *buf);
通过文件描述符获取文件对应的属性。
int lstat(const char *restrict pathname, struct stat *restrict buf);
连接文件描述命，获取文件属性。
2 文件对应的属性
struct stat {
        mode_t     st_mode;       //文件对应的模式，文件，目录等
        ino_t      st_ino;       //inode节点号
        dev_t      st_dev;        //设备号码
        dev_t      st_rdev;       //特殊设备号码
        nlink_t    st_nlink;      //文件的连接数
        uid_t      st_uid;        //文件所有者
        gid_t      st_gid;        //文件所有者对应的组
        off_t      st_size;       //普通文件，对应的文件字节数
        time_t     st_atime;      //文件最后被访问的时间
        time_t     st_mtime;      //文件内容最后被修改的时间
        time_t     st_ctime;      //文件状态改变时间
        blksize_t st_blksize;    //文件内容对应的块大小
        blkcnt_t   st_blocks;     //伟建内容对应的块数量
      };
可以通过上面提供的函数，返回一个结构体，保存着文件的信息。

struct path_info {
    char *root;
    char *phys;
    char *name;
    char *info;
    char *query;
    int redirected;
    struct stat stat;
};

struct path_info * uh_path_lookup(struct client *cl, const char *url)
{
    static char path_phys[PATH_MAX];
    static char path_info[PATH_MAX];
    static struct path_info p;

    char buffer[UH_LIMIT_MSGHEAD];
    char *docroot = cl->server->conf->docroot;
    char *pathptr = NULL;

    int slash = 0;
    int no_sym = cl->server->conf->no_symlinks;
    int i = 0;
    struct stat s;

    /* back out early if url is undefined */
    if ( url == NULL )
        return NULL;

    memset(path_phys, 0, sizeof(path_phys));
    memset(path_info, 0, sizeof(path_info));
    memset(buffer, 0, sizeof(buffer));
    memset(&p, 0, sizeof(p));

    /* copy docroot */
    memcpy(buffer, docroot,
        min(strlen(docroot), sizeof(buffer) - 1));

    DEBUGP("uh_path_lookup: buffer = %s, docroot = %s, url = %s\n", &buffer[0], docroot, url);
    /* separate query string from url */
    if( (pathptr = strchr(url, '?')) != NULL )
    {
        p.query = pathptr[1] ? pathptr + 1 : NULL;

        /* urldecode component w/o query, pathptr > url ???? */
        if( pathptr > url )
            DEBUGP("Have Get CGI: pathptr > url, pathptr = %s, p.query = %s\n", pathptr, p.query);
            uh_urldecode(
                &buffer[strlen(docroot)],
                sizeof(buffer) - strlen(docroot) - 1,
                url, (int)(pathptr - url) - 1
            );
    }

    /* no query string, decode all of url */
    else
    {
        uh_urldecode(
            &buffer[strlen(docroot)],
            sizeof(buffer) - strlen(docroot) - 1,
            url, strlen(url)
        );
    }
    DEBUGP("buffer = %s, len = %d\n", &buffer[0], strlen(buffer));

    /* create canon path */
    for( i = strlen(buffer), slash = (buffer[max(0, i-1)] == '/'); i >= 0; i-- )
    {
        if( (buffer[i] == 0) || (buffer[i] == '/') )
        {
            memset(path_info, 0, sizeof(path_info));
            memcpy(path_info, buffer, min(i + 1, sizeof(path_info) - 1));

            if( no_sym ? realpath(path_info, path_phys)
             : canonpath(path_info, path_phys)
            ) {
                memset(path_info, 0, sizeof(path_info));
                memcpy(path_info, &buffer[i],
                    min(strlen(buffer) - i, sizeof(path_info) - 1));

                break;
            }
        }
    }

    /* check whether found path is within docroot */
    if( strncmp(path_phys, docroot, strlen(docroot)) ||
     ((path_phys[strlen(docroot)] != 0) &&
         (path_phys[strlen(docroot)] != '/'))
    ) {
        return NULL;
    }

    /* test current path */
    if( ! stat(path_phys, &p.stat) )
    {
        /* is a regular file */
        if( p.stat.st_mode & S_IFREG )
        {
            p.root = docroot;
            p.phys = path_phys;
            p.name = &path_phys[strlen(docroot)];
            p.info = path_info[0] ? path_info : NULL;
        }

        /* is a directory */
        else if( (p.stat.st_mode & S_IFDIR) && !strlen(path_info) )
        {
            /* ensure trailing slash */
            if( path_phys[strlen(path_phys)-1] != '/' )
                path_phys[strlen(path_phys)] = '/';

            /* try to locate index file */
            memset(buffer, 0, sizeof(buffer));
            memcpy(buffer, path_phys, sizeof(buffer));
            pathptr = &buffer[strlen(buffer)];

            /* if requested url resolves to a directory and a trailing slash
             is missing in the request url, redirect the client to the same
               url with trailing slash appended */
            if( !slash )
            {
                uh_http_sendf(cl, NULL,
                    "HTTP/1.1 302 Found\r\n"
                    "Location: %s%s%s\r\n"
                    "Connection: close\r\n\r\n",
                        &path_phys[strlen(docroot)],
                        p.query ? "?" : "",
                        p.query ? p.query : ""
                );

                p.redirected = 1;
            }
            else if( cl->server->conf->index_file )
            {
                strncat(buffer, cl->server->conf->index_file, sizeof(buffer));

                if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
                {
                    memcpy(path_phys, buffer, sizeof(path_phys));
                    memcpy(&p.stat, &s, sizeof(p.stat));
                }
            }
            else
            {
                for( i = 0; i < array_size(uh_index_files); i++ )
                {
                    strncat(buffer, uh_index_files[i], sizeof(buffer));

                    if( !stat(buffer, &s) && (s.st_mode & S_IFREG) )
                    {
                        memcpy(path_phys, buffer, sizeof(path_phys));
                        memcpy(&p.stat, &s, sizeof(p.stat));
                        break;
                    }

                    *pathptr = 0;
                }
            }

            p.root = docroot;
            p.phys = path_phys;
            p.name = &path_phys[strlen(docroot)];
        }
    }

    return p.phys ? &p : NULL;
}

---

http://blog.csdn.net/xiaoweibeibei/article/details/6556951

文件类型：普通文件（文本文件，二进制文件）、目录文件、链接文件、设备文件、管道文件。

    文件的权限：读、写、执行

    文件的相关信息：目录结构、索引节点、文件数据

索引节点的stat结构

struct stat{

dev_t st_dev;//文件使用的设备号

ino_t st_inl;//索引节点号

mode_t st_mode;//文件访问权限

nlink_t st_nlink;//文件的硬链接数

uid_t st_uid;//所用者用户识别号

gid_t st_gid;//组识别号

dev_t st_rdev;//设备文件的设备号

off_t st_size;//以字节为单位的文件容量

unsigned long st_blksize;//包含该文件的磁盘块的大小

unsigned long st_blocks;//文件所占的磁盘块

time_t st_atime;//最后一次访问该文件的时间

time_t st_mtime;//最后一次修改该文件的时间

time_t st_ctime;//最后一次改变该文件状态的时间

} ;

    在该结构体中，st_dev对应于每一个文件名，代表包含这个文件名和相应的索引节点的文件系统的设备号，st_rdev则只有字符设备和快设备具有，表示的是实际设备的设备号

文件操作相关函数

文件创建

函数：int creat(const char *pathname,mode_t mode);

头文件：sys/types.h     sys/stat.h   fcntl.h

说明：

    mode取值如下：

mode取值	含义
S_IRUSR	文件所有者的读权限
S_IWUSR	文件安所有者的写权限
S_IXUSR	文件所有者的执行权限
S_IRGRP	文件所有者同组用户的读权限
S_IWGRP	文件所有者同组用户的写权限
S_IXGRP	文件所有者同组用户的执行权限
S_IROTH	其他用户的读权限
S_IWOTH	其他用户的写权限
S_IXOTH	其他用户的执行权限

Linux系统中还定义了几个权限组合：

S_IRWXU =(S_IRUSR|S_IWUSR|S_IXUSR)

S_IRWXG =(S_IWGRP|S_IWGRP|S_IXGRP)

S_IRWXO=(S_IROTH|S_IWOTH|S_IXOTH)

当调用成功时，返回该文件的描述符，失败返回-1，此时文件以只读方式打开。

文件打开

函数：（1） int open( const char *pathname,int flags);

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

头文件：sys/types.h     sys/stat.h   fcntl.h

说明：flags用于描述文件打开参数，通过按位逻辑加得到，其中O_RDONLY,O_WRONLY和O_RDWR，3个值必需包含其中一种。flags取值如下：

flags取值	含义
O_RDONLY	以只读方式打开
O_WRONLY	以只写方式打开
O_RDWR	以读写方式打开
O_CREAT	若所打开文件不存在，则创建此文件
O_EXCL	若打开文件时设置了O_CREAT位且该文件存在，则导致失败
O_NOCTTY	若在打开tty时进程没有控制tty则不控制终端
O_TRUNC	若以只写或读写方式打开一个已存在文件时，将该文件截至0
O_APPEND	以追加的方式打开，将文件添加内容时将指针置于文件末尾
O_NONBLOCK	用于非阻塞接口I/O，若操作不能无延迟的完成，则在操作前返回
O_NODELAY	同O_NONBLACK
O_SYNC	只在数据被写入外存或其他设备之后才返回

    当调用成功时，返回要打开文件的描述符，调用失败返回-1，并置errno为相应错误号。

文件关闭

函数：int close（int fd）;

头文件：unistd.h

说明：

    成功时返回0，失败时返回-1，并置errno为EBADF.当打开一个文件是，该文件描述中的引用计数加1，关闭一个文件时，该文件的引用计数减1，当引用计数为0时，close调用不仅释放该文件的描述符，还将释放该文件所占的描述表项。

文件写操作

函数：ssize_t write(int fd,void *buf,size_t count);

头文件：unistd.h

说明： 调用成功返回所写入段字节数，失败返回-1 ，并设置相应的errno。

 

文件读操作

函数：ssize_t read(int fd ,void *buf,size_t count);

头文件：unistd.h

说明：调用成功返回所读取的字节数，失败返回-1，并设置相应的errno。

文件定位操作

函数：off_t lseek(int fildes.off_t offset,int whence);

头文件：unistd.h

说明：调用成功返回相对于文件开头的实际偏移量，失败返回-1，并设置相应errno。whence取值如下：

Whence取值	含义
SEEK_SET	从文件开头计算偏移量；
SEEK_CUR	从当前位置计算偏移量；
SEEK_END	从文件的末尾计算偏移量

 

文件属性修改

函数：(1) int chown(const char *pathname,uid_t owner,gid_t group);

      (2) int fchown(int fd,uid_t owner,gid_t group);

头文件：sys/types.h    unistd.h

说明：改变文件的所有者，由于涉及权限问题，只有root用户可以调用chown和fchown来任意改变一个文件的所有者及所属的组，普通用户没有这个权限，普通用户只能修改自己所有的文件的组识别号，切只能在其所属的组中进行选择。

 

函数：(1)int chmod(char *pathname,mode_t mode)；

      (2)int fchmod(int fd,mode_t mode;

头文件：sys/types.h    unistd.h

说明： 改变文件的访问权限，关于权限的设置和chmod命令类似，调用成功返回0，失败返回-1，并设置errno。

文件重命名

函数：int rename( const char *oldname,const char *newname);

头文件：stdio.h

说明：当newname和oldname指向相同，则rename调用不做任何操作成功返回。

oldname指向	newname指向文件不存在	newname指向普通文件	newname指向目录文件
oldname指向普通文件	文件被重命名	文件重命名	错误返回
oldname指向目录文件	文件重命名	错误	newname所指向的目录文件为空目录则该目录被删除，oldname被重新命名，否则出错返回

dup和dup2调用

函数：(1)int dup(int fd); (2) int dup2( int fd,int fd2);

头文件：unistd.h

说明：该调用都将复制文件描述符，两个调用成功执行时都将返回新得到的文件描述符，其区别在于（2）可以预先制定文件描述符fd2，如果fd2正在被使用，则先关闭fd2，如果fd2和fd相同，则不关闭该文件正常返回；

stat、fstat和lstat调用

函数：(1) int stat(const char *pathname,struct stat *sbuf);

       (2) int fstat(int fd,struct stat *sbuf);

       (3) int lstat(const char *pathname,struct stat*buf);

头文件：sys/types.h     sys/stat.h   unistd.h

说明：对于lstat而言，当访问一个符号链接时，lstat只返回链接本身的信息，而stat和fstat将追踪到链接的末端文件，也就是所连接的文件。

 

fsync调用

函数：int fsync(int fd);

头文件：unistd.h

说明：将保存在缓冲区内的要写入文件描述符fd的所有数据刷新到要写入的文件中，当调用成功返回0，调用失败返回-1，并设置errno。

 

flock调用

函数：int flock(int fd,int operation);

头文件：sys/types.h

说明：将文件描述符所对应的文件加锁或解锁，operation用于表示不同的上锁或解锁方式，取值如下：

LOCK_SH:共享锁    LOCK_EX:独占锁   LOCK_UN:解锁

    一个进程对一个文件只能有一个独占锁，但可以有多个共享锁，如果一个进程不试图去锁一个已经被上锁的文件，就不可以对其访问。当调用成功时返回0，失败时返回-1。

fcntl调用

函数：(1) int fcntl(int fd,int cmd);

       (2) int fcntl(int fd,int cmd,long arg);

头文件：unistd.h   fcntl.h

说明：参数arg为可选参数，对应于cmd的某些可取值，对应于执行某些特殊操作；调用成功时返回0，失败是返回-1，并设置errno，此外，fcntl调用能完成的大部分操作都可以用其他调用来完成。cmd的取值如下：

cmd取值	相应操作
F_DUPFD	复制文件描述符
F_GETFD	获取文件描述符
F_SETFD	设置close-on-exec标志
F_GETFL	获取open调用设置的标志
F_SETFL	设置open调用设置的标志
F_GETLK	获取离散的文件锁
F_SETLK	设置获得离散的文件锁，不等待
F_SETLKW	设置获得离散的文件锁，必要时等待
F_GETOWN	检索将收到SIGIO和SIGURG信号灯进程id或进程组号
F_SETOWN	设置进程id或进程组号

 

特殊文件操作

创建目录

函数：int mkdir(const char *pathname,mde_t mode);

头文件：sys/types.h   sys/stat.h

说明：mode的值与表示其权限，mode的值由当前的umask的值得反值与设置的mode相与确定，该目录的所有者为调用mkdir创建它的进程的有效用户标识号。调用成功返回0，失败返回-1，并设置errno。

删除目录

函数：int rmdir(const char *pathname);

头文件：unistd.h

说明：当目录为空时，调用此函数可以将其删除，否则将删除失败。调用成功返回0，失败返回-1，并设置errno。

打开目录

函数：DIR * opendir(const char *pathname);

头文件： sys/types.h    dirent.h

说明：调用返回值为DIR类型，用于指向目录文件的结构指针。调用成功返回目录指针，调用失败返回NULL。

关闭目录

函数：int closedir( DIR *dp);

头文件：sys/types.h    dirent.h

说明：参数为要关闭的目录文件指针，该指针有opendir返回，调用成功返回0，失败返回-1，并设置errno。

读取目录

函数：struct dirent * readdir(DIP *dp);

头文件：sys/types.h    dirent.h

说明：用于访问目录指针dp的目录文件，其返回值为dirent结构体指针，dirent结构如下：

struct drent{

ino_t  d_ino;//目录节点号

off_t d_off;//节点偏移量

unsigned short d_reclen;//记录长度

unsigned char d_type;//文件类型

char d_name[256];//目录链接的文件名

}

当目录中没有更多链接时，返回0。

创建硬链接

函数：int  link(char *pathname1,char *pathname2);

头文件：unistd.h

说明：pathname1为已经存在的文件，pathname2为要建立的链接，pathname1和pathname2之西那个的路径必须在同一个文件系统中，只用超级用户才能创建一个指向目录文件的新的连接文件。调用成功返回0，失败返回-1。

 

移除硬链接

函数：int unlink(char *pathname);

头文件：unistd.h

说明：要移除一个文件的链接，必须要有对该目录的写权限和执行权限，当调用unlink时，目录的索引节点计数将减1，当链接计算器为0时，索引节点和文件数据块将被释放。

创建符号链接

函数：int symlink(const char *actualpath,const char *sympath);

头文件：unistd.h

说明：acturalpath为真实存在的文件，sympath为新创建的指向acturalpath的符号链接，调用成功返回0，失败返回-1，并设置errno。

打开链接

函数：int readlink(const char *pathname, char *buf,int bufsize);

头文件：unistd.h

说明：调用成功时，返回值为写入缓冲区的字节数，调用失败时，返回值为0，并设置errno。