文件和目录

#include <sys/types.h>
#include <fcntl.h>
#include "apue.h"

int main(int argc, char *argv[]) 
{
        if(argc != 2) 
                err_quit("usage: a.out <pathname>"); 

        if(access(argv[1], R_OK) < 0) 
                err_ret("access error for %s", argv[1]); 
        else 
                printf("read access OK\n");

        if(open(argv[1], O_RDONLY) < 0) 
                err_ret("open error for %s", argv[1]); 
        else 
                printf("open for reading OK\n");

        exit(0);
}

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "apue.h"

int main(void)
{
        umask(0); //foo的权限是666
        if(creat("foo", S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) < 0)
                err_sys("creat error for foo");

        umask(S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        //bar的权限是600
        if(creat("bar", S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH) < 0)
                err_sys("creat error for bar");

        exit(0);

}

#include <sys/types.h>
#include <sys/stat.h>
#include "apue.h"

int main(void)
{
        struct stat statbuf;

        if(stat("foo", &statbuf) < 0)
                err_sys("stat error for foo");

        /* turn on set-group-ID and turn off group-execute */
        if(chmod("foo", (statbuf.st_mode & ~S_IXGRP) | S_ISGID) < 0)
                err_sys("chmod error for foo");

        /*set absolute mode to "rw-r--r--"*/
        if(chmod("bar", S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0)
                err_sys("chmod error for bar");

        exit(0);

}

$ mkdir testdir

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "apue.h"

int main(void)
{
        if(open("tempfile", O_RDWR) < 0)
                err_sys("open error");

        if(unlink("tempfile") < 0)
                err_sys("unlink error");
        printf("file unlinked\n");

        sleep(15);
        printf("done\n");

        exit(0);

}

$ echo "hello world " > tempfile

$ ls -l tempfile
# 1表示有1个目录项目指向tempfile
-rw-r--r-- 1 klose klose 13 Jan 30 22:53 tempfile

$ ./unlinkExample

file unlinked
done

$ ls -l tempfile

ls: cannot access 'tempfile': No such file or directory

$mkdir foo #创建一个新目录

$touch foo/a #创建0长文件

$ln - s ../foo foo/testdir #创建一符号连接

$ls -1 foo

total 1
-rw-rw-r-- 1 stevens 0 Dec6 06:06 a
lrwxrwxrwx 1 stevens 6 Dec6 06:06 testdir -> ../foo

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <utime.h>
#include "apue.h"

int main(int argc, char *argv[])
{
        int i;
        struct stat statbuf;
        struct utimbuf timebuf;

        for(i = 1; i < argc ; ++i) {
                if(stat(argv[i], &statbuf) < 0) {
                        err_ret("%s: stat error", argv[i]);
                        continue;
                }

                if(open(argv[i], O_RDWR | O_TRUNC) < 0) {
                        err_ret("%s: open error", argv[i]);
                        continue;
                }

                timebuf.actime = statbuf.st_atime;
                timebuf.modtime = statbuf.st_mtime;
                if(utime(argv[i], &timebuf)< 0) {
                        err_ret("%s: utime error", argv[i]);
                        continue;
                }
        }

        exit(0);    
}

$ls -l helloworld
-rw-r--r-- 1 klose klose 12 Jan 31 22:42 helloworld

$ls -lu helloworld
-rw-r--r-- 1 klose klose 12 Jan 31 22:42 helloworld

$./utimeExample helloworld

$ls -l helloworld
-rw-r--r-- 1 klose klose 0 Jan 31 22:42 helloworld

$ls -lu helloworld
-rw-r--r-- 1 klose klose 0 Jan 31 22:42 helloworld

#include "apue.h"
#include <dirent.h>
#include <limits.h>

/* function type that is called for each filename */
typedef int Myfunc(const char *, const struct stat *, int);

static Myfunc   myfunc;
static int      myftw(char *, Myfunc *);
static int      dopath(Myfunc *);

static long nreg, ndir, nblk, nchr, nfifo, nslink, nsock, ntot;

/*
 * Descend through the hierarchy, starting at "pathname".
 * The caller's func() is called for every file.
 */
#define FTW_F   1       /* file other than directory */
#define FTW_D   2       /* directory */
#define FTW_DNR 3       /* directory that can't be read */
#define FTW_NS  4       /* file that we can't stat */

static char *fullpath;      /* contains full pathname for every file */

/*
 * Descend through the hierarchy, starting at "fullpath".
 * If "fullpath" is anything other than a directory, we lstat() it,
 * call func(), and return.  For a directory, we call ourself
 * recursively for each name in the directory.
 */
static int dopath(Myfunc* func)  /* we return whatever func() returns */
{
        struct stat     statbuf;
        struct dirent   *dirp;
        DIR             *dp;
        int             ret;
        char            *ptr;

        if (lstat(fullpath, &statbuf) < 0)  /* stat error */
                return(func(fullpath, &statbuf, FTW_NS));
        if (S_ISDIR(statbuf.st_mode) == 0)  /* not a directory */
                return(func(fullpath, &statbuf, FTW_F));

        /*
         * It's a directory.  First call func() for the directory,
         * then process each filename in the directory.
         */
        if ((ret = func(fullpath, &statbuf, FTW_D)) != 0)
                return(ret);

        ptr = fullpath + strlen(fullpath);  /* point to end of fullpath */
        *ptr++ = '/';
        *ptr = 0;

        if ((dp = opendir(fullpath)) == NULL)   /* can't read directory */
                return(func(fullpath, &statbuf, FTW_DNR));

        while ((dirp = readdir(dp)) != NULL) {
                if (strcmp(dirp->d_name, ".") == 0  ||
                    strcmp(dirp->d_name, "..") == 0)
                        continue;       /* ignore dot and dot-dot */

                strcpy(ptr, dirp->d_name);  /* append name after slash */

                if ((ret = dopath(func)) != 0)      /* recursive */
                        break;  /* time to leave */
        }
        ptr[-1] = 0;    /* erase everything from slash onwards */

        if (closedir(dp) < 0)
                err_ret("can't close directory %s", fullpath);

        return(ret);
}

static int myfunc(const char *pathname, const struct stat *statptr, int type)
{
        switch (type) {
        case FTW_F:
                switch (statptr->st_mode & S_IFMT) {
                case S_IFREG:   nreg++;     break;
                case S_IFBLK:   nblk++;     break;
                case S_IFCHR:   nchr++;     break;
                case S_IFIFO:   nfifo++;    break;
                case S_IFLNK:   nslink++;   break;
                case S_IFSOCK:  nsock++;    break;
                case S_IFDIR:
                        err_dump("for S_IFDIR for %s", pathname);
                        /* directories should have type = FTW_D */
                }
                break;

        case FTW_D:
                ndir++;
                break;

        case FTW_DNR:
                err_ret("can't read directory %s", pathname);
                break;

        case FTW_NS:
                err_ret("stat error for %s", pathname);
                break;

        default:
                err_dump("unknown type %d for pathname %s", type, pathname);
        }

        return(0);
}

/* we return whatever func() returns */
static int myftw(char *pathname, Myfunc *func)
{
        int len;
        fullpath = path_alloc(&len);    /* malloc's for PATH_MAX+1 bytes */
        strncpy(fullpath, pathname, len);   /* protect against */
        fullpath[len-1] = 0;                /* buffer overrun */

        return(dopath(func));
}

int main(int argc, char *argv[])
{
        int     ret;

        if (argc != 2)
                err_quit("usage:  ftw  <starting-pathname>");

        ret = myftw(argv[1], myfunc);       /* does it all */

        ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock;
        if (ntot == 0)
                ntot = 1;       /* avoid divide by 0; print 0 for all counts */
        printf("regular files  = %7ld, %5.2f %%\n", nreg,
               nreg*100.0/ntot);
        printf("directories    = %7ld, %5.2f %%\n", ndir,
               ndir*100.0/ntot);
        printf("block special  = %7ld, %5.2f %%\n", nblk,
               nblk*100.0/ntot);
        printf("char special   = %7ld, %5.2f %%\n", nchr,
               nchr*100.0/ntot);
        printf("FIFOs          = %7ld, %5.2f %%\n", nfifo,
               nfifo*100.0/ntot);
        printf("symbolic links = %7ld, %5.2f %%\n", nslink,
               nslink*100.0/ntot);
        printf("sockets        = %7ld, %5.2f %%\n", nsock,
               nsock*100.0/ntot);

        exit(ret);
}

#include "apue.h"

int main(void)
{
        if (chdir("/tmp") < 0)
                err_sys("chdir failed");
        printf("chdir to /tmp succeeded\n");
        exit(0);
}

$ pwd
/home/klose/Documents/programming/c/apue

$ ./src/file_directory/chdirExample
chdir to /tmp succeeded

$ pwd
/home/klose/Documents/programming/c/apue

#include "apue.h"

int main(void)
{
        char    *ptr;
        int     size;

        if (chdir("/home/klose/Applications/maven/") < 0)
                err_sys("chdir failed");

        ptr = path_alloc(&size);    /* our own function */
        if (getcwd(ptr, size) == NULL)
                err_sys("getcwd failed");

        printf("cwd = %s\n", ptr);
        exit(0);
}

$ pwd
/home/klose/Documents/programming/c/apue

$ ./src/file_directory/getpwdExample 
cwd = /home/klose/Applications/apache-maven-3.3.9