Linux C Function()参考のファイル権限制御編
19632 ワード
access（ ）
stat，open，chmod，chown，setuid，setgid
#include<unistd.h>
int access(const char * pathname,int mode);
access() / 。 mode ，R_OK，W_OK，X_OK F_OK。R_OK，W_OK X_OK 、 。F_OK 。 access() ， ， ， “ ”， ， 。 ， DOS “ ” ， execve() 。
0 ， ， -1。
EACCESS pathname 。
EROFS 。
EFAULT pathname 。
EINVAL mode 。
ENAMETOOLONG pathname 。
ENOTDIR pathname 。
ENOMEM
ELOOP pathname 。
EIO I/O 。
access() ， access() open() 。
/* /etc/passwd */
#include<unistd.h>
int main()
{
if (access(“/etc/passwd”,R_OK) = =0)
printf(“/etc/passwd can be read
”);
}
/etc/passwd can be read
alphasort（ ）
scandir，qsort
#include<dirent.h>
int alphasort(const struct dirent **a,const struct dirent **b);
alphasort() scandir() qsort() qsort() ， scandir() qsort()。
qsort()。
/* / ， */
main()
{
struct dirent **namelist;
int i,total;
total = scandir(“/”,&namelist ,0,alphasort);
if(total <0)
perror(“scandir”);
else{
for(i=0;i<total;i++)
printf(“%s
”,namelist[i]->d_name);
printf(“total = %d
”,total);
}
}
..
.gnome
.gnome_private
ErrorLog
Weblog
bin
boot
dev
dosc
dosd
etc
home
lib
lost+found
misc
mnt
opt
proc
root
sbin
tmp
usr
var
total = 24
chdir（ （ ）
getcwd，chroot
#include<unistd.h>
int chdir(const char * path);
chdir() path 。
0， -1，errno 。
#include<unistd.h>
main()
{
chdir(“/tmp”);
printf(“current working directory: %s
”,getcwd(NULL,NULL));
}
current working directory :/tmp
chmod（ ）
fchmod，stat，open，chown
#include<sys/types.h>
#include<sys/stat.h>
int chmod(const char * path,mode_t mode);
chmod() mode path 。
mode
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
0， 。 ， ， S_ISUID S_ISGID ， 。 S_ISUID ， root 。
0， -1， errno。
EPERM ， root 。
EACCESS path 。
EROFS 。
EFAULT path 。
EINVAL mode
ENAMETOOLONG path
ENOENT
ENOTDIR path
ENOMEM
ELOOP path 。
EIO I/O
/* /etc/passwd S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH */
#include<sys/types.h>
#include<sys/stat.h>
main()
{
chmod(“/etc/passwd”,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
}
chown（ ）
fchown，lchown，chmod
#include<sys/types.h>
#include<unistd.h>
int chown(const char * path, uid_t owner,gid_t group);
chown() path owner ， group 。 owner group -1， 。root ， group 。 root chown() ， S_ISUID S_ISGID ， ， S_ISGID S_IXGRP ， ， 。
0， -1， errno。
chmod（）。
/* /etc/passwd root */
#include<sys/types.h>
#include<unistd.h>
main()
{
chown(“/etc/passwd”,0,0);
}
chroot（ ）
chdir
#include<unistd.h>
int chroot(const char * path);
chroot() path 。 ， 。
0， -1， errno。
EPERM ， 。
EFAULT path 。
ENAMETOOLONG path 。
ENOTDIR 。
EACCESS
ENOMEM 。
ELOOP path 。
EIO I/O 。
/* /tmp , /tmp */
#include<unistd.h>
main()
{
chroot(“/tmp”);
chdir(“/”);
}
closedir（ ）
opendir
#include<sys/types.h>
#include<dirent.h>
int closedir(DIR *dir);
closedir() dir 。
0， -1， errno 。
EBADF dir
readir()。
fchdir（ ）
getcwd，chroot
#include<unistd.h>
int fchdir(int fd);
fchdir() fd 。
0， -1，errno 。
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
main()
{
int fd;
fd = open(“/tmp”,O_RDONLY);
fchdir(fd);
printf(“current working directory : %s
”,getcwd(NULL,NULL));
close(fd);
}
current working directory : /tmp
fchmod（ ）
chmod，stat，open，chown
#include<sys/types.h>
#include<sys/stat.h>
int fchmod(int fildes,mode_t mode);
fchmod() mode fildes 。 fildes 。 mode chmod（）。
0， -1， errno。
EBADF fildes 。
EPERM ， root 。
EROFS 。
EIO I/O 。
#include<sys/stat.h>
#include<fcntl.h>
main()
{
int fd;
fd = open (“/etc/passwd”,O_RDONLY);
fchmod(fd,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
close(fd);
}
fchown（ ）
chown，lchown，chmod
#include<sys/types.h>
#include<unistd.h>
int fchown(int fd,uid_t owner,gid_t group);
fchown() fd owner ， group 。 owner group -1， 。 fd 。 root fchown() ， S_ISUID S_ISGID ， 。
0， -1， errno。
EBADF fd 。
EPERM ， root ， owner、group 。
EROFS 。
ENOENT
EIO I/O
#include<sys/types.h>
#include<unistd.h>
#include<fcntl.h>
main()
{
int fd;
fd = open (“/etc/passwd”,O_RDONLY);
chown(fd,0,0);
close(fd);
}
fstat（ ）
stat，lstat，chmod，chown，readlink，utime
#include<sys/stat.h>
#include<unistd.h>
int fstat(int fildes,struct stat *buf);
fstat() fildes ， buf (struct stat)。Fstat() stat() ， 。 stat()。
0， -1， errno。
#include<sys/stat.h>
#include<unistd.h>
#include<fcntk.h>
main()
{
struct stat buf;
int fd;
fd = open (“/etc/passwd”,O_RDONLY);
fstat(fd,&buf);
printf(“/etc/passwd file size +%d
“,buf.st_size);
}
/etc/passwd file size = 705
ftruncate（ ）
open，truncate
#include<unistd.h>
int ftruncate(int fd,off_t length);
ftruncate() fd length 。 fd ， 。 length ， 。
0， -1， errno。
EBADF fd 。
EINVAL fd socket ， 。
getcwd（ ）
get_current_dir_name，getwd，chdir
#include<unistd.h>
char * getcwd(char * buf,size_t size);
getcwd() buf ， size buf 。 ，buf ， size ， NULL，errno ERANGE。 buf NULL，getcwd() size ( malloc())， size 0， getcwd() ， free() 。
buf ， 。 NULL， errno。
#include<unistd.h>
main()
{
char buf[80];
getcwd(buf,sizeof(buf));
printf(“current working directory : %s
”,buf);
}
current working directory :/tmp
link（ ）
symlink，unlink
#include<unistd.h>
int link (const char * oldpath,const char * newpath);
link() newpath ( ) oldpath 。 newpath 。
0， -1， errno。
link() ， symlink()。
EXDEV oldpath newpath 。
EPERM oldpath newpath
EROFS
EFAULT oldpath newpath 。
ENAMETOLLONG oldpath newpath
ENOMEM
EEXIST newpath 。
EMLINK oldpath 。
ELOOP pathname
ENOSPC 。
EIO I/O 。
/* /etc/passwd pass */
#include<unistd.h>
main()
{
link(“/etc/passwd”,”pass”);
}
lstat（ ）
stat，fstat，chmod，chown，readlink，utime
#include<sys/stat.h>
#include<unistd.h>
int lstat (const char * file_name.struct stat * buf);
lstat() stat() ， file_name ， ， ，lstat() link 。 stat()。
0， -1， errno。
stat()。
opendir（ ）
open，readdir，closedir，rewinddir，seekdir，telldir，scandir
#include<sys/types.h>
#include<dirent.h>
DIR * opendir(const char * name);
opendir() name ， DIR* ， open() ， 。
DIR* ， NULL。
EACCESS
EMFILE 。
ENFILE 。
ENOTDIR name
ENOENT name ， name 。
ENOMEM 。
readdir（ ）
open，opendir，closedir，rewinddir，seekdir，telldir，scandir
#include<sys/types.h>
#include<dirent.h>
struct dirent * readdir(DIR * dir);
readdir() dir 。
dirent
struct dirent
{
ino_t d_ino;
ff_t d_off;
signed short int d_reclen;
unsigned char d_type;
har d_name[256;
};
d_ino inode
d_off
d_reclen _name ， NULL
d_type d_name
d_name
。 NULL。
EBADF dir 。
#include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR * dir;
struct dirent * ptr;
int i;
dir =opendir(“/etc/rc.d”);
while((ptr = readdir(dir))!=NULL)
{
printf(“d_name: %s
”,ptr->d_name);
}
closedir(dir);
}
d_name:.
d_name:..
d_name:init.d
d_name:rc0.d
d_name:rc1.d
d_name:rc2.d
d_name:rc3.d
d_name:rc4.d
d_name:rc5.d
d_name:rc6.d
d_name:rc
d_name:rc.local
d_name:rc.sysinit
readlink（ ）
stat，lstat，symlink
#include<unistd.h>
int readlink(const char * path ,char * buf,size_t bufsiz);
readlink() path buf ， NULL ， 。 bufsiz ， 。
， -1， errno。
EACCESS ，
EINVAL bufsiz
EIO I/O 。
ELOOP 。
ENAMETOOLONG path
ENOENT path
ENOMEM
ENOTDIR path 。
remove（ ）
link，rename，unlink
#include<stdio.h>
int remove(const char * pathname);
remove() pathname 。 pathname ， unlink() ， pathname ， rmdir() 。 unlink() rmdir()。
0， -1， errno。
EROFS
EFAULT pathname
ENAMETOOLONG pathname
ENOMEM
ELOOP pathname
EIO I/O 。
rename（ ）
link，unlink，symlink
#include<stdio.h>
int rename(const char * oldpath,const char * newpath);
rename() oldpath newpath 。 newpath ， 。
0， -1， errno
/* DOS rename rename */
#include <stdio.h>
void main(int argc,char **argv)
{
if(argc<3){
printf(“Usage: %s old_name new_name
”,argv[0]);
return;
}
printf(“%s=>%s”,argc[1],argv[2]);
if(rename(argv[1],argv[2]<0)
printf(“error!
”);
else
printf(“ok!
”);
}
rewinddir（ ）
open，opendir，closedir，telldir，seekdir，readdir，scandir
#include<sys/types.h>
#include<dirent.h>
void rewinddir(DIR *dir);
rewinddir() dir 。
EBADF dir
#include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR * dir;
struct dirent *ptr;
dir = opendir(“/etc/rc.d”);
while((ptr = readdir(dir))!=NULL)
{
printf(“d_name :%s
”,ptr->d_name);
}
rewinddir(dir);
printf(“readdir again!
”);
while((ptr = readdir(dir))!=NULL)
{
printf(“d_name: %s
”,ptr->d_name);
}
closedir(dir);
}
d_name:.
d_name:..
d_name:init.d
d_name:rc0.d
d_name:rc1.d
d_name:rc2.d
d_name:rc3.d
d_name:rc4.d
d_name:rc5.d
d_name:rc6.d
d_name:rc
d_name:rc.local
d_name:rc.sysinit
readdir again!
d_name:.
d_name:..
d_name:init.d
d_name:rc0.d
d_name:rc1.d
d_name:rc2.d
d_name:rc3.d
d_name:rc4.d
d_name:rc5.d
d_name:rc6.d
d_name:rc
d_name:rc.local
d_name:rc.sysinit
seekdir（ ）
open，opendir，closedir，rewinddir，telldir，readdir，scandir
#include<dirent.h>
void seekdir(DIR * dir,off_t offset);
seekdir() dir ， readdir() 。 offset 。
EBADF dir
#include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR * dir;
struct dirent * ptr;
int offset,offset_5,i=0;
dir=opendir(“/etc/rc.d”);
while((ptr = readdir(dir))!=NULL)
{
offset = telldir(dir);
if(++i = =5) offset_5 =offset;
printf(“d_name :%s offset :%d
”,ptr->d_name,offset);
}
seekdir(dir offset_5);
printf(“Readdir again!
”);
while((ptr = readdir(dir))!=NULL)
{
offset = telldir(dir);
printf(“d_name :%s offset :%d
”,ptr->d_name.offset);
}
closedir(dir);
}
d_name : . offset :12
d_name : .. offset:24
d_name : init.d offset 40
d_name : rc0.d offset :56
d_name :rc1.d offset :72
d_name:rc2.d offset :88
d_name:rc3.d offset 104
d_name:rc4.d offset:120
d_name:rc5.d offset:136
d_name:rc6.d offset:152
d_name:rc offset 164
d_name:rc.local offset :180
d_name:rc.sysinit offset :4096
readdir again!
d_name:rc2.d offset :88
d_name:rc3.d offset 104
d_name:rc4.d offset:120
d_name:rc5.d offset:136
d_name:rc6.d offset:152
d_name:rc offset 164
d_name:rc.local offset :180
d_name:rc.sysinit offset :4096
stat（ ）
fstat，lstat，chmod，chown，readlink，utime
#include<sys/stat.h>
#include<unistd.h>
int stat(const char * file_name,struct stat *buf);
stat() file_name ， buf 。
struct stat
struct stat
{
dev_t st_dev; /*device*/
ino_t st_ino; /*inode*/
mode_t st_mode; /*protection*/
nlink_t st_nlink; /*number of hard links */
uid_t st_uid; /*user ID of owner*/
gid_t st_gid; /*group ID of owner*/
dev_t st_rdev; /*device type */
off_t st_size; /*total size, in bytes*/
unsigned long st_blksize; /*blocksize for filesystem I/O */
unsigned long st_blocks; /*number of blocks allocated*/
time_t st_atime; /* time of lastaccess*/
time_t st_mtime; /* time of last modification */
time_t st_ctime; /* time of last change */
};
st_dev
st_ino i-node
st_mode
st_nlink ， 1。
st_uid
st_gid
st_rdev ，
st_size ，
st_blksize I/O 。
st_blcoks ， 512 。
st_atime ， mknod、utime、read、write tructate 。
st_mtime ， mknod、utime write
st_ctime i-node ， 、 、 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 。
0， -1， errno
ENOENT file_name
ENOTDIR
ELOOP ， 16
EFAULT buf ，
EACCESS
ENOMEM
ENAMETOOLONG file_name
#include<sys/stat.h>
#include<unistd.h>
mian()
{
struct stat buf;
stat (“/etc/passwd”,&buf);
printf(“/etc/passwd file size = %d
”,buf.st_size);
}
/etc/passwd file size = 705
symlink（ ）
link，unlink
#include<unistd.h>
int symlink( const char * oldpath,const char * newpath);
symlink() newpath ( ) oldpath 。 oldpath ， newpath 。
0， -1， errno。
EPERM oldpath newpath
EROFS
EFAULT oldpath newpath 。
ENAMETOOLONG oldpath newpath
ENOMEM
EEXIST newpath 。
EMLINK oldpath
ELOOP pathname
ENOSPC
EIO I/O
#include<unistd.h>
main()
{
symlink(“/etc/passwd”,”pass”);
}
telldir（ ）
open，opendir，closedir，rewinddir，seekdir，readdir，scandir
#include<dirent.h>
off_t telldir(DIR *dir);
telldir() dir 。 ， -1。
EBADF dir 。
#include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
main()
{
DIR *dir;
struct dirent *ptr;
int offset;
dir = opendir(“/etc/rc.d”);
while((ptr = readdir(dir))!=NULL)
{
offset = telldir (dir);
printf(“d_name : %s offset :%d
”, ptr->d_name,offset);
}
closedir(dir);
}
d_name : . offset :12
d_name : .. offset:24
d_name : init.d offset 40
d_name : rc0.d offset :56
d_name :rc1.d offset :72
d_name:rc2.d offset :88
d_name:rc3.d offset 104
d_name:rc4.d offset:120
d_name:rc5.d offset:136
d_name:rc6.d offset:152
d_name:rc offset 164
d_name:rc.local offset :180
d_name:rc.sysinit offset :4096
truncate（ ）
open，ftruncate
#include<unistd.h>
int truncate(const char * path,off_t length);
truncate() path length 。 length ， 。
0， -1， errno。
EACCESS path 。
EROFS
EFAULT path
EINVAL path
ENAMETOOLONG path
ENOTDIR path
EISDIR path
ETXTBUSY path ，
ELOOP path’
EIO I/O 。
umask（ ）
creat，open
#include<sys/types.h>
#include<sys/stat.h>
mode_t umask(mode_t mask);
umask() umask mask&0777 ， umask 。 open() ， mode ， (mode&~umask) 。 ， 0666， umask 022， 0666&～022＝0644， rw-r--r-- 。 umask 。
unlink（ ）
link，rename，remove
#include<unistd.h>
int unlink(const char * pathname);
unlink() pathname 。 ， ， 。 pathname ， 。
0， -1， errno
EROFS
EFAULT pathname
ENAMETOOLONG pathname
ENOMEM
ELOOP pathname
EIO I/O
utime（ ）
utimes，stat
#include<sys/types.h>
#include<utime.h>
int utime(const char * filename,struct utimbuf * buf);
utime() filename inode 。
utimbuf
struct utimbuf{
time_t actime;
time_t modtime;
};
buf (NULL)， 。
0， -1， errno。
EACCESS ，
ENOENT 。
utimes（ ）
utime，stat
#include<sys/types.h>
#include<utime.h>
int utimes(char * filename.struct timeval *tvp);
utimes() filename inode 。
timeval
struct timeval {
long tv_sec;
long tv_usec; /* */
};
tvp timeval ， utime（） utimebuf ，tvp[0].tc_sec utimbuf.actime，tvp]1].tv_sec utimbuf.modtime。
0。 -1， errno。
EACCESS ，
ENOENT