信息安全系统设计基础第九周学习总结
系统级I/O
前言：输入/输出是在主存和外部设备（如磁盘驱动器、终端和网络）之间拷贝数据的过程。输入操作时从I/O设备拷贝数据到主存，而输出操作时从主存拷贝数据到I/O设备。
10.1 Unix I/O
一个Unix文件就是一个m个字节的序列：B0，B1，B2，B3...Bk...Bm-1。
所有的I/O设备，如网络、磁盘盒终端，都被模型化为文件，而所有的输入和输出都被当做对相应的文件的读和写来执行。这是一种应用接口，成为Unix I/O。
①打开文件：一个应用程序通过要求内核打开相应地文件，来宣告它想要访问一个I/O设备。内核返回一个小的非负整数，叫做描述符。它在后续对此文件的所有操作中标识这个文件。内核记录有关这个打开文件的所有信息。应用程序只需要记住这个标识符。 Unix外壳穿件的每个进程开始时都有三个打开的文件：标准输入（描述符为0）、标准输出（描述符为1）、标准错误（描述符为2）。头文件<unistd.h>定义了常量STDIN_FILENO、STDOUT_FILENO、STDERR_FILENO，它们而已用来代替显式的描述符值。 ②改变当前的文件位置。对于每个打开的文件，内核保持着一个文件位置k，初始为0。这个文件位置是从文件开头起始的字节偏移量。应用程序能够通过执行seek操作，显式地设置文件的当前位置为k。 ③读写文件。一个读操作就是从文件拷贝n>0个字节到存储器，从当前文件位置k开始，然后将k增加到k+n。给定一个大小为m字节的文件，当k>=m时执行读操作会触发一个称为end-of -file(EOF)的条件，应用程序能检测到这个条件。在文件结尾处并没有明确的“EOF”符号。 类似的，写操作就是从存储器拷贝n>0个字节到一个文件，从当前文件位置k开始，然后更新k。 ④关闭文件。当应用完成了对文件的访问之后，它就通知内核关闭这个文件。作为响应，内核释放文件打开时创建的数据结构，并将这个描述符恢复到可用的描述符池中。无论一个进程因为何种原因终止时，内核都会关闭所有打开的文件并释放他们的存储器资源。
10.2 打开和关闭文件
open函数将filename转换为一个文件描述符，并且返回描述符数字。返回的描述符总是在进程中当前没有打开的最小描述符。flags参数指明了进程打算如何访问这个文件。
O_RDONLY:只读。
O_WRONLY:只写。
O_RDWR：可读可写。
flags参数也可以是一个或者更多位掩码的或，为写提供给一些额外的指示：
O_CREAT：如果文件不存在，就创建它的一个截断的（空的）文件。
O_TRUNC:如果文件已经存在，就截断它。
O_APPEND：在每次写操作前，设置文件位置到文件的结尾处。
mode参数指定了新文件的访问权限位。这些位的符号名字所示。作为上下文的一部分，每个进程都是一个umask，它是通过调用umask函数来设置的。当进程通过带某个mode参数的open函数调用来创建一个新文件时，文件的访问权限位被设置我mode&~umask。
进程是通过调用open函数来打开一个已存在的文件或者创建一个新文件的。
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
//给定mode和umask的默认值
#define DEF_MODE S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
#define DEF_UMASK S_IWGRP|S_IWOTH
int open(char *filename,int fliags,mod_it mode)；//返回值成功为新文件描述符，出错为-1
fd=Open("foo.txt",O_RDONLY,0);//如何以读的方式打开一个已存在的文件
fd=Open("foo.txt",O_WRONLY|O_APPEND,0);//如何打开一个已存在文件，并在后面添加一些数据
//创建一个新文件，文件的拥有者有读写权限，而所有其他的用户都有读权限
umask(DEF_UMASK);
fg=Open("foo.txt",O_CREAT|O_TRUNC|O_WEONLY,DEF_MODE);
//通过调用close函数关闭一个打开的文件
int close(int fd);//返回值成功为0，出错为-1
以下为访问权限位在sys/stat.h中的定义：
10.3 读和写文件
1、应用程序是通过分别调用read和write函数来执行输入和输出的。
#include <unistd.h> ssize_t read(int fd,void *buf,size_t n);//返回值：成功为读的字节数，若EOF为0，出错为-1 ssize_t write(int fd,const void *buf,size_t n);//返回值成功为写的字节数，出错为-1
2、read函数从描述符为fd的当前文件位置拷贝最多n个字节到存储器位置buf，返回值-1表示一个错误。而返回值0表示EOF。否则，返回值表示的是实际传送的字节数量。
3、write函数从存储器位置buf拷贝至多n个字节到描述符fd的当前文件位置。
以下是一个例子，展示了一个程序使用read和write调用一次一个字节地从标准输入拷贝到标准输出。
#include "csapp.h"
int main(void)
{
char c;
while(Read(STDIN_FILENO,&c,1)!=0)
Write(STDOUT_FILENO,&c,1);
exit(0);
}
通过调用lseek函数，应用程序能够显示地修改当前文件的位置。
4、在某些情况下，read和write传送的字节比应用程序要求的要少，这些不足值不表示有错误。原因如下：
①读时遇到EOF。假设我们猪呢比读一个文件，该文件从当前文件位置开始只含有20多个字节，而我们以50个字节的片进行读取。这样一来，下一个read返回的不足值为20，此后的read将通过返回不足值0来发出EOF信号。 ②从终端读文本行。如果打开文件是与终端相关联的（如键盘和显示器），那么每个read函数将以此传送一个文本行，返回的不足值等于文本行的大小。 ③读和写网络套接字。如果打开的文件对应于网络套接字，那么内部缓冲约束和较长的网络延迟会引起read和write返回不足值。对Unix管道调用read和write时，也有可能出现不足值，这种进程间的通信机制不在我们讨论的范围之内。 实际上，除了EOF，在读磁盘文件时，将不会遇到不足值，而且在写磁盘文件时，也不会遇到不足值。如果想创建简装的诸如web服务器这样的网络应用，就必须通过反复调用read和write处理不足值，直到所有需要的字节都传送完毕。
10.4 用RIO包健壮地读写
1、RIO包会自动处理不足值。RIO提供了两类不同的函数：
①无缓冲的输入输出函数。这些函数直接在存储器和文件之间传送数据，没有应用级缓冲，他们对将二进制数据读写到网络和从网络读写二进制数据尤其有用。 ②带缓冲的输入函数。这些函数允许你高效地从文件中读取文本行和二进制数据，这些文件的内容缓存在应用级缓冲区内，类似于像printf这样的标准I/O函数提供的缓冲区。是线程安全的，它在同一个描述符上可以被交错地调用。例如，可以从一个描述符中读一些文本行，然后读取一些二进制数据，接着再多读取一些文本行。
2、RIO的无缓冲的输入输出函数
通过调用rio_readn和rio_writen函数，应用程序可以在存储器和文件之间直接传送数据。
#include "csapp.h" //返回值：若成功为传送的字节数，若EOF则为0，出错为-1 ssize_t rio_readn(int fd,void *usrbuf,size_t n); ssize_t rio_writen(int fd,void *usrbuf,size_t n);
rio_readn函数从描述符fd的当前文件位置最多传送n和字节到存储器位置usrbuf。类似地，rio_writen函数从位置usrbuf传送n个字节到描述符fd。rio_readn函数唉遇到EOF时只能返回一个不足值。rio_writen函数绝不会返回不足值。对于同一个描述符，可以任意交错地调用rio_readn和rio_writen。
如果rio_readn和rio_writen函数被一个从应用信号处理程序的发放你会中断，那么每个函数都会手动地重启read或write。为了尽可能有较好地可移植性，允许被中断的系统调用，并在必要时重启他们。
3、RIO的带缓冲的输入函数
一个文本行就是一个由换行符结尾的ASCII码字符序列。在Unix系统中，换行符（‘\n'）与ASCII码换行符（LF）相同，数字值为0x0a。
用一个程序来计算文本文件中文本行的数量：用read函数来一次一个字节地从文件传送到用户存储器，检查每个字节来查找换行符。这个方法的缺点是效率低，每读取文件中的一个字节都要求陷入内核。
另一种方法是调用一个包装函数（rio_readlineb），它从一个内部读缓冲区拷贝一个文本行，当缓冲区变空时，会自动地调用read重新填满缓冲区。对于既包含文本行也包含二进制数据的文件，我们也提供了一个rio_readn带缓冲区的版本，叫做rio_readnb，它从和rio_readlineb一样的读缓冲区中传送原始字节。
#include "csapp.h" void rio_readinitb(rio_t *rp,int fd);//无返回 ssize_t rio_readlineb(rio_t *rp,void *usrbuf,size_t maxlen); ssize_t rio_readnb(rio_t *rp,void *usrbuf,size_t n);//返回值：若成功为读得字节数，若EOF则为0，若出错为-1
ssize_t rio_readn(int fd,void *usrbuf,size_t n)
{
size_t nleft=n;
ssize_t nread;
char *bufp=usrbuf;
while(nleft>0){
if((nread=read(fd,bufp,nleft))<0){
if(errno==EINTR)
nread=0;
else
return -1;
}
else if (nread==0)
break;
nleft-=nread;
bufp+=nread;
}
return(n-nleft);
}
ssize_t rio_writen(int fd,void *usrbuf,size_t n)
{
size_t nleft=n;
ssize_t nwritten;
char *bufp=usrbuf;
while(nleft>0){
if((nwritten=write(fd,bufp,nleft))<=0){
if(errno==EINTR)
nwritten=0;
else
return -1;
}
nleft -=nwritten;
bufp+=nwritten;
}
return n;
}
每打开一个描述符都会调用一次rio_readinitb函数。它将描述符fd和地址rp的一个类型为rio_t的读缓冲区联系起来。
4、RIO读程序核心：rio-read函数
static ssize_t rio_read(rio_t *rp,char *usrbuf,size_t n)
{
int cnt;
while(rp->rio_cnt<=0)//如果缓冲区为空，先调用函数填满缓冲区再读数据
{
rp->rio_cnt=read(rp->rio_fd,rp->rio_buf,sizeof(rp->rio_buf));//调用read函数填满缓冲区
if(rp->rio_cnt<0)//排除文件读不出数据的情况
{
if（error != EINTR）
{
return -1;
}
}
else if(rp->rio_cnt=0)
return 0;
else
rp->rio_bufptr = rp->rio_buf;//更新现在读到的位置
}
cnt=n;
if(rp->rio_cnt<n)
cnt=rp->rio_cnt;//以上三步，将n与rp->rio_cnt中较小的值赋给cnt
memcpy(usrbuf,rp->rio_bufptr,cnt);把读缓冲区的内容拷贝到用户缓冲区
rp->rio_bufptr+=cnt;
rp->rio_cnt-=cnt;
return cnt;
}
当调用rio_read要求读n个字节时，读缓冲区内有rp->rio_cnt个未读字节。如果缓冲区为孔，那么会通过调用read再填满它。这个read调用收到一个不足值并不是错误，只不过读缓冲区是填充了一部分。一旦缓冲区非空，rio_read就从读缓冲区拷贝n和rp->rio_cnt中较小值个字节到用户缓冲区，并返回拷贝的字节数。
10.5 读取文件元数据
1、应用程序能够通过调用stat和fstat函数，检索到关于文件的信息（元数据）。
#include <unistd.h> #include <sys/stat.h> int stat(cost char *filename,struc sta *buf); int fstat(int fd,struct stat *buf);
stat函数以文件名作为输入 fstat函数以文件描述符作为输入 stat数据结构中的重要成员：st_mode,st_size st_size成员包含了文件的字节数大小 st_mode成员编码了文件访问许可位和文件类型
2、文件类型：
- 普通文件：二进制或文本数据，宏指令：S_ISREG()
- 目录文件：包含其他文件的信息，宏指令:S_ISDIR()
- 套接字：通过网络和其他进程通信的文件，宏指令:S_ISSOCK()
3、Unix提供的宏指令根据st_mode成员来确定文件的类型
10.6 共享文件
1、内核用三个相关的数据结构来表示打开的文件：
描述符表：每个打开的描述符表项指向文件表中的一个表项 文件表：所有进程共享这张表，每个表项包括文件位置，引用计数，以及一个指向v-node表对应表项的指针 v-node表：所有进程共享这张表，包含stat结构中的大多数信息
2、三种打开文件的类型：
- 典型：描述符各自引用不同的文件，没有共享
- 共享：多个描述符通过不同的文件表表项引用同一个文件。（关键思想：每个描述符都有自己的文件位置，对不同描述符的读操作可以从文件的不同位置获取数据）
- 继承：子进程继承父进程打开文件。调用fork后，子进程有一个父进程描述符表的副本，父子进程共享相同的打开文件表集合，因此共享相同的文件位置
10.7 I/0重定向
1、Unix外壳提供了I/O重定向操作符，允许用户将磁盘文件和标准输入输出联系起来
2、重定向使用dup2函数
int dup2(int oldfd,int newfd);
3、dup2函数拷贝描述符表表项oldfd到描述符表表项newfd，覆盖描述表表项newfd以前的内容。
4、如果newfd已经打开，dup2会在拷贝oldfd之前关闭newfd
10.8 标准I/O
1、ANSI C定义了一组高级输入输出函数，称为标准I/O库。提供了打开和关闭文件的函数（fopen和fclose），读和写字节的函数（fread和fwrite），读和写字符串的函数（fgets和fputs），格式化I/O函数（scanf和printf）
2、标准I/O库将一个打开的文件模型化为一个流。一个流就是一个指向FILE类型的结构的指针
3、每个ANSI C程序开始时都有三个打开的流stdin、stdout、stderr，分别对应标准输入、标准输出、标准错误
4、类型为FILE的流是对文件描述符和流缓存区的抽象
======================================================
遇到的问题和解决方法
本章的学习内容看似少，对思路要求也挺高。代码也很多。我在学习时遇到了不少记忆上的问题，很多参数、掩码长得很相似，英文大写有时也会让我不知道它是哪个单词的缩写，尽管是生活中很常见的单词。还有就是代码很长，变量名字也很长，敲起来工作量很大也很容易出错。我试着运行代码。一开始提示头文件找不到。我上网百度才知道是因为“csapp.h”这个是这本教材编写的一系列头文件，不是计算机自带的。但可以从网上下载下来。我尝试了，但还没有成功，我还在继续努力解决中。
这个问题不解决就无法测试一些问题。如习题一“下面程序的输出是什么？”
#include "csapp.h"
int main()
{
int fd1,fd2;
fd1=Open("foo.txt",O_RDONLY,0);
Close(fd1);
fd2=Open("baz.txt",O_RDONLY,0);
printf("fd2=%d\n",fd2);
exit(0);
}
我想运行代码验证：将：
Close(fd1);
这个语句删除的话，此处输出是多少？因为文件没有关闭，那么此时输出会是3还是4？
因此我还在尝试解决代码运行的问题。待续...
11.9解决问题
根据问题小组中韩玉琪同学的解答，我又尝试着去做，结果发现问题解决了。此处附上解决方案链接：
http://group.cnblogs.com/topic/73278.html
======================================================
实践代码
<<cp
功能：复制一个文件
cp1
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#define BUFFERSIZE 4096
#define COPYMODE 0644
void oops(char *, char *);
int main(int argc, char *argv[])
{
int in_fd, out_fd, n_chars;
char buf[BUFFERSIZE];
if (argc != 3) {
fprintf(stderr, "usage: %s source destination\n", *argv);
exit(1);
}
if ((in_fd = open(argv[1], O_RDONLY)) == -1)
oops("Cannot open ", argv[1]);
if ((out_fd = creat(argv[2], COPYMODE)) == -1)
oops("Cannot creat", argv[2]);
while ((n_chars = read(in_fd, buf, BUFFERSIZE)) > 0)
if (write(out_fd, buf, n_chars) != n_chars)
oops("Write error to ", argv[2]);
if (n_chars == -1)
oops("Read error from ", argv[1]);
if (close(in_fd) == -1 || close(out_fd) == -1)
oops("Error closing files", "");
}
void oops(char *s1, char *s2)
{
fprintf(stderr, "Error: %s ", s1);
perror(s2);
exit(1);
}
<<ls
功能：打印出该目录下的文件列表
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
void do_ls(char []);
int main(int argc, char *argv[])
{
if ( argc == 1 )
do_ls( "." );
else
while ( --argc ){
printf("%s:\n", *++argv );
do_ls( *argv );
}
return 0;
}
void do_ls( char dirname[] )
{
DIR *dir_ptr;
struct dirent *direntp;
if ( ( dir_ptr = opendir( dirname ) ) == NULL )
fprintf(stderr,"ls1: cannot open %s\n", dirname);
else
{
while ( ( direntp = readdir( dir_ptr ) ) != NULL )
printf("%s\n", direntp->d_name );
closedir(dir_ptr);
}
}
<<ls2
功能：显示文件的详细信息，比如用户名，群组名，大小，创建时间，读写权限等
#include <stdio.h>
#include<string.h>
#include <sys/types.h>
#include <dirent.h>
#include <sys/stat.h>
void do_ls(char[]);
void dostat(char *);
void show_file_info( char *, struct stat *);
void mode_to_letters( int , char [] );
char *uid_to_name( uid_t );
char *gid_to_name( gid_t );
int main(int argc, char *argv[])
{
if ( argc == 1 )
do_ls( "." );
else
while ( --argc ){
printf("%s:\n", *++argv );
do_ls( *argv );
}
return 0;
}
void do_ls( char dirname[] )
{
DIR *dir_ptr;
struct dirent *direntp;
if ( ( dir_ptr = opendir( dirname ) ) == NULL )
fprintf(stderr,"ls1: cannot open %s\n", dirname);
else
{
while ( ( direntp = readdir( dir_ptr ) ) != NULL )
dostat( direntp->d_name );
closedir(dir_ptr);
}
}
void dostat( char *filename )
{
struct stat info;
if ( stat(filename, &info) == -1 )
perror( filename );
else
show_file_info( filename, &info );
}
void show_file_info( char *filename, struct stat *info_p )
{
char *uid_to_name(), *ctime(), *gid_to_name(), *filemode();
void mode_to_letters();
charmodestr[11];
mode_to_letters( info_p->st_mode, modestr );
printf( "%s", modestr );
printf( "%4d " , (int) info_p->st_nlink);
printf( "%-8s " , uid_to_name(info_p->st_uid) );
printf( "%-8s " , gid_to_name(info_p->st_gid) );
printf( "%8ld " , (long)info_p->st_size);
printf( "%.12s ", 4+ctime(&info_p->st_mtime));
printf( "%s\n" , filename );
}
void mode_to_letters( int mode, char str[] )
{
strcpy( str, "----------" );
if ( S_ISDIR(mode) ) str[0] = 'd';
if ( S_ISCHR(mode) ) str[0] = 'c';
if ( S_ISBLK(mode) ) str[0] = 'b';
if ( mode & S_IRUSR ) str[1] = 'r';
if ( mode & S_IWUSR ) str[2] = 'w';
if ( mode & S_IXUSR ) str[3] = 'x';
if ( mode & S_IRGRP ) str[4] = 'r';
if ( mode & S_IWGRP ) str[5] = 'w';
if ( mode & S_IXGRP ) str[6] = 'x';
if ( mode & S_IROTH ) str[7] = 'r';
if ( mode & S_IWOTH ) str[8] = 'w';
if ( mode & S_IXOTH ) str[9] = 'x';
}
#include <pwd.h>
char *uid_to_name( uid_t uid )
{
struct passwd *getpwuid(), *pw_ptr;
static char numstr[10];
if ( ( pw_ptr = getpwuid( uid ) ) == NULL ){
sprintf(numstr,"%d", uid);
return numstr;
}
else
return pw_ptr->pw_name ;
}
#include <grp.h>
char *gid_to_name( gid_t gid )
{
struct group *getgrgid(), *grp_ptr;
static char numstr[10];
if ( ( grp_ptr = getgrgid(gid) ) == NULL ){
sprintf(numstr,"%d", gid);
return numstr;
}
else
return grp_ptr->gr_name;
}
<<who
功能：查看用户
#include <stdio.h>
#include<stdlib.h>
#include <utmp.h>
#include <fcntl.h>
#include <unistd.h>
#define SHOWHOST
int show_info( struct utmp *utbufp )
{
printf("%-8.8s", utbufp->ut_name);
printf(" ");
printf("%-8.8s", utbufp->ut_line);
printf(" ");
printf("%10ld", utbufp->ut_time);
printf(" ");
#ifdef SHOWHOST
printf("(%s)", utbufp->ut_host);
#endif
printf("\n");
return 0;
}
int main()
{
struct utmp current_record;
int utmpfd;
int reclen = sizeof(current_record);
if ( (utmpfd = open(UTMP_FILE, O_RDONLY)) == -1 ){
perror( UTMP_FILE );
exit(1);
}
while ( read(utmpfd, ¤t_record, reclen) == reclen )
show_info(¤t_record);
close(utmpfd);
return 0;
}
<<fileinfo
功能：这个功能用来实现显示文件信息，建立了一个stat数据结构。先判断命令是否有操作数，有的话才能继续进行下去，如果没有报错就打印出来相关文件信息，报错就用perror将报错信息打印出来。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
void show_stat_info(char *, struct stat *);
int main(int argc, char *argv[])
{
struct stat info;
if (argc>1)
{
if( stat(argv[1], &info) != -1 ){
show_stat_info( argv[1], &info );
return 0;
}
else
perror(argv[1]);
}
return 1;
}
void show_stat_info(char *fname, struct stat *buf)
{
printf(" mode: %o\n", buf->st_mode);
printf(" links: %d\n", buf->st_nlink);
printf(" user: %d\n", buf->st_uid);
printf(" group: %d\n", buf->st_gid);
printf(" size: %d\n", (int)buf->st_size);
printf("modtime: %d\n", (int)buf->st_mtime);
printf(" name: %s\n", fname );
}
<<setecho
功能：改变echo的状态
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
#define oops(s,x) { perror(s); exit(x); }
int main(int argc, char *argv[])
{
struct termios info;
if ( argc == 1 )
exit(0);
if ( tcgetattr(0,&info) == -1 )
oops("tcgettattr", 1);
if ( argv[1][0] == 'y' )
info.c_lflag |= ECHO ;
else
info.c_lflag &= ~ECHO ;
if ( tcsetattr(0,TCSANOW,&info) == -1 )
oops("tcsetattr",2);
return 0;
}
<<filesize
功能：用st_size计算文件的字节数大小
#include <stdio.h>
#include <sys/stat.h>
int main()
{
struct stat infobuf;
if ( stat( "/etc/passwd", &infobuf) == -1 )
perror("/etc/passwd");
else
printf(" The size of /etc/passwd is %d\n", infobuf.st_size );
}
<<echostate
功能：用来检查命令行中的提示符是否显示的，如果显示，输入的命令都可见，不显示则表示输入的命令不可见
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
int main()
{
struct termios info;
int rv;
rv = tcgetattr( 0, &info ); /* read values from driver */
if ( rv == -1 ){
perror( "tcgetattr");
exit(1);
}
if ( info.c_lflag & ECHO )
printf(" echo is on , since its bit is 1\n");
else
printf(" echo is OFF, since its bit is 0\n");
return 0;
}
<<testioctl
功能：获得终端设备的窗口大小
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
int main()
{
struct winsize size;
if( isatty(STDOUT_FILENO) == 0)
exit(1);
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &size) < 0) {
perror("ioctl TIOCGWINSZ error");
exit(1);
}
printf("%d rows %d columns\n", size.ws_row, size.ws_col);
return 0;
}
<<spwd
功能：显示当前所在目录
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
ino_t get_inode(char *);
void printpathto(ino_t);
void inum_to_name(ino_t , char *, int );
int main()
{
printpathto( get_inode( "." ) );
putchar('\n');
return 0;
}
void printpathto( ino_t this_inode )
{
ino_t my_inode ;
char its_name[BUFSIZ];
if ( get_inode("..") != this_inode )
{
chdir( ".." );
inum_to_name(this_inode,its_name,BUFSIZ);
my_inode = get_inode( "." );
printpathto( my_inode );
printf("/%s", its_name );
}
}
void inum_to_name(ino_t inode_to_find , char *namebuf, int buflen)
{
DIR *dir_ptr;
struct dirent *direntp;
dir_ptr = opendir( "." );
if ( dir_ptr == NULL ){
perror( "." );
exit(1);
}
while ( ( direntp = readdir( dir_ptr ) ) != NULL )
if ( direntp->d_ino == inode_to_find )
{
strncpy( namebuf, direntp->d_name, buflen);
namebuf[buflen-1] = '\0';
closedir( dir_ptr );
return;
}
fprintf(stderr, "error looking for inum %d\n", (int) inode_to_find);
exit(1);
}
ino_t get_inode( char *fname )
{
struct stat info;
if ( stat( fname , &info ) == -1 ){
fprintf(stderr, "Cannot stat ");
perror(fname);
exit(1);
}
return info.st_ino;
}
==================================================================================
参考文献：
《深入理解计算机系统》