20135202闫佳歆——信息安全系统设计基础第九周学习总结

第十章系统级I/O

输入/输出（I/O）是在主存和外部设备之间拷贝数据的过程。

第一节 Unix I/O

这一节涉及到操作系统的基本抽象之一——文件。也就是说，所有的I/O设备都被模型化为文件，而所有的输入输出都被当做对相应文件的读/写。相关的执行动作如下：

1.打开文件：

应用程序向内核发出请求→要求内核打开相应的文件→内核返回文件描述符

文件描述符：一个小的非负整数，用来在后续对此文件的所有操作中标识这个文件。有三个已经被指定了的如下：
```
  标准输入——0（STDIN_FILENO）
  标准输出——1（STDOUT_FILENO）
  标准错误——2（STDERR_FILENO）
```

括号中是常量表示形式，使用时需要加头文件<unistd.h>

也就是说，在Unix生命周期一开始，0、1、2就被占用，以后的open只能从3开始——习题10.1.

在UNIX下还有stdin，stdout，stderr表示同样的含义。

二者的主要区别为：

1.数据类型不同，前者为int类型，后者为FILE*；

2.STDIN_FILENO主要用在read（），write（）等中，后者主要用在fread（），fwrite（）以f开头。

2.改变当前的文件位置

通常，读，写操作都从当前文件偏移量处开始（也就是文件位置），并使偏移量增加所读写的字节数，可以理解为光标所在的位置。

当打开一个文件的最初时候文件的偏移量为0.

通过seek操作，可以显示的设置文件的当前位置为k。

3.读写文件

（1）读

读操作就是从文件拷贝n>0个字节到存储器，并且改变文件当前位置。（如果当前位置是k，则改变为k+n）

※EOF的来源：

这里有一个一直以来的理解上的误区：文件结尾处没有明确的EOF信号，是当文件当前位置的数值超过了文件大小时，会处罚一个称为end-of-file的条件，能够被应用程序检测到，这就是所谓的EOF信号。

（2）写

写操作是从存储器拷贝n>0个字节到一个文件，然后更新当前文件位置。

4.关闭文件

应用通知内核关闭文件→内核释放文件打开时的数据结构→恢复描述符→释放存储器资源。

第二节打开和关闭文件

1.open函数

（1）函数定义：

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

int open(char *filename, int flags, mode_t mode);

（2）参数解析：

返回值：类型为int型，返回的是描述符数字，总是在进程中当前没有打开的最小描述符。如果出错，返回值为-1.
filename：文件名

flags：指明进程打算如何访问这个文件，可以取的值见下：

  O_RDONLY：只读
  O_WRONLY：只写
  O_RDWR：可读可写

  O_CREAT：文件不存在，就创建新文件
  O_TRUNC：如果文件存在，就截断它
  O_APPEND：写操作前设置文件位置到结尾处

这些值可以用或连接起来。

mode：指定了新文件的访问权限位，符号名称如下：

2.close函数

(1)函数定义：

#include <unistd.h>

int close(int fd);

(2)参数解析：

返回值：成功返回0，出错返回-1

关闭一个已经关闭的描述符会出错

fd：即文件的描述符。

第三节读和写文件

1.读 read

（1）函数原型：

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t n);

（2）参数解析：

返回值：成功则返回读的字节数，EOF返回0，出错返回-1。返回值为有符号数。
fd：文件描述符
buf：存储器位置
n：最多从当前文件位置拷贝n个字节到存储器位置buf

2.写 write

（1）函数原型：

#include <unistd.h>

ssize_t write(int fd, void *buf, size_t n);

（2）参数解析：

返回值：成功则返回写的字节数，出错返回-1。返回值为有符号数。
fd：文件描述符
buf：存储器位置
n：最多从存储器位置buf拷贝n个字节到当前文件位置

需要注意的是，read和write在正常情况下返回值是实际传送的字节数量。

3.通过lseek函数可以显式的修改当前文件的位置

4.不足值

不足值指在某些情况下，read和write传送的字节比应用程序要求的要少，原因如下：

读的时候遇到EOF
从终端读文本行
读和写socket

第四节用RIO包健壮的读写

RIO，Robust I/O，针对的出现不足值的问题。

1.RIO的无缓冲的输入输出函数。

这些函数的作用是直接在存储器和文件之间传送数据，常适用于网络和二进制数据之间。

rio_readn函数和rio_writen定义：

#include "csapp.h"

ssize_t rio_readn(int fd, void *usrbuf, size_t n);
ssize_t rio_writen(int fd, void *usrbuf, size_t n);

参数：

fd：文件描述符
usrbuf：存储器位置
n:传送的字节数

返回值：

  rio_readn成功则返回传送的字节数，EOF为0（一个不足值），出错为-1
  rio_writen成功则返回传送的字节数，出错为-1，没有不足值。

2.RIO的带缓冲的输入函数

可以高效的从文件中读取文本行和二进制数据。

一个概念：一个文本行就是一个由换行符结尾的ASCII码字符序列。

范例：如何统计文本文件中文本行的数量——通过计算换行符。需要用到的函数：

#include "csapp.h"

void rio_readinitb(rio_t *rp, int fd);//将描述符fd和地址rp处的一个类型为rio_t的读缓存区联系起来。

ssize_t rio_readlineb(rio_t *rp,void *usrbuf, size_t maxlen);//从文件rp中读出一个文本行，包括换行符，拷贝到存储器位置usrbuf，并用空字符结束这个文本行。最多赌到maxlen-1个字节，最后一个给结尾的空字符。
ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n);//从文件rp中读取最多n个字符到存储器位置usrbuf中。

成功则返回传送的字节数，EOF为0，出错为-1。

【课本代码】

图10-4：

#include "csapp.h"

int main(int argc, char **argv) 
{
    int n;
    rio_t rio;
    char buf[MAXLINE];

    Rio_readinitb(&rio, STDIN_FILENO);//连接标准输入和rio地址
    while((n = Rio_readlineb(&rio, buf, MAXLINE)) != 0) //当成功返回时，将rio中的内容拷贝到存储器位置buf中，最多读maxline-1
	Rio_writen(STDOUT_FILENO, buf, n);//把存储器位置中的数据拷贝到标注输出中。
    exit(0);
}

先连接标准输入和地址rio，再根据返回值判断是否成功将rio中的一行内容拷贝到了buf中，如果是再把这一行拷贝到标准输出中，即可实现一次一行的从标准输入拷贝一个文本文件到标准输出。

图10-5：

#define RIO_BUFSIZE 8192
typedef struct {
    int rio_fd;                /* descriptor for this internal buf */
    int rio_cnt;               /* unread bytes in internal buf */
    char *rio_bufptr;          /* next unread byte in internal buf */
    char rio_buf[RIO_BUFSIZE]; /* internal buffer */
} rio_t;

void rio_readinitb(rio_t *rp, int fd) 
{
    rp->rio_fd = fd;  
    rp->rio_cnt = 0;  
    rp->rio_bufptr = rp->rio_buf;
}

由代码可以看出，rio_t数据结构的组成部分有文件描述符，缓存区中还没有读过的数值，下一个需要读的字节，文本行。在rio_readinitb函数中，创建了一个读缓存区，把文件描述符赋值，还没有读过的数值是0，下一个要读的字节就是文本行的起始，这代表这个读缓存区是空的。

图10-6：

RIO读程序的核心是rio_read函数

static ssize_t rio_read(rio_t *rp, char *usrbuf, size_t n)
{
    int cnt;

    while (rp->rio_cnt <= 0) {  /* 如果缓存区为空，调用read填满它 */
	rp->rio_cnt = read(rp->rio_fd, rp->rio_buf, 
			   sizeof(rp->rio_buf));
	if (rp->rio_cnt < 0) {
	    if (errno != EINTR) /* 出错返回-1*/
		return -1;
	}
	else if (rp->rio_cnt == 0)  /* EOF返回0 */
	    return 0;
	else 
	    rp->rio_bufptr = rp->rio_buf; /* reset buffer ptr */
    }

    /* 一旦缓存区非空，就从读缓存区拷贝n和rp->rio_cnt中较小值个字节到用户缓存区，并且返回拷贝的字节数 */
    cnt = n;          
    if (rp->rio_cnt < n)   
	cnt = rp->rio_cnt;
    memcpy(usrbuf, rp->rio_bufptr, cnt);
    rp->rio_bufptr += cnt;
    rp->rio_cnt -= cnt;
    return cnt;
}

rio_readnb函数

ssize_t rio_readnb(rio_t *rp, void *usrbuf, size_t n) 
{
    size_t nleft = n;
    ssize_t nread;
    char *bufp = usrbuf;
    
    while (nleft > 0) {
	if ((nread = rio_read(rp, bufp, nleft)) < 0) {
	    if (errno == EINTR) 
		nread = 0;      /* 调用read填充 */
	    else
		return -1;      /* 错误，返回-1 */ 
	} 
	else if (nread == 0)
	    break;              /* EOF */
	nleft -= nread;
	bufp += nread;
    }
    return (n - nleft);         /* 返回成功传送的字节数*/
}

rio_readlineb函数

ssize_t rio_readlineb(rio_t *rp, void *usrbuf, size_t maxlen) 
{
    int n, rc;
    char c, *bufp = usrbuf;

    for (n = 1; n < maxlen; n++) { //最多是maxlen-1个
	if ((rc = rio_read(rp, &c, 1)) == 1) {
	    *bufp++ = c;
	    if (c == '\n')//找到换行符，就退出
		break;
	} else if (rc == 0) {
	    if (n == 1)
		return 0; /* EOF,并且没有读到数据 */
	    else
		break;    /* EOF,有数据，出现不足值 */
	} else
	    return -1;	  /* 错误，返回-1 */
    }
    *bufp = 0;
    return n;//返回成功传送的字节数
}

第五节读取文件元数据

元数据即文件信息，需要用到的函数是stat和fstat。定义如下：

#include <unistd.h>
#include <sys/stat.h>

int stat(const char *filename, struct stat *buf);
int fstat(int fd,struct stat *buf);

返回值：成功为0，错误为-1

参数：

stat需要输入文件名，而fstat需要输入的是文件描述符。

关于stat数据结构如下图：

需要注意的有两个，st_mode和st_size。

st_size：包含文件的字节数大小
st_mode：包编码文件访问许可位和文件类型。许可位在第一节提到了，Unix文件类型如下，并有对应的宏指令，含义均为“是xx吗”，这些宏在sys/stat.h中定义：
```
  普通文件	二进制或文本文件（对内核没差）	S_ISREG()
  目录文件	关于其他文件的信息	S_ISDIR()
  套接字	通过网络与其他进程通信的文件	S_ISSOCK()
```

查询和处理一个文件的st_mode位：

#include "csapp.h"

int main (int argc, char **argv) 
{
    struct stat stat;
    char *type, *readok;

    Stat(argv[1], &stat);//文件选择argv[1]，写入一个stat数据结构
    if (S_ISREG(stat.st_mode))     /* 如果是一个文本文件 */
	type = "regular";
    else if (S_ISDIR(stat.st_mode))//如果是一个目录文件
	type = "directory";
    else 
	type = "other";
    if ((stat.st_mode & S_IRUSR)) /* 检查阅读权限 */
	readok = "yes";
    else
	readok = "no";

    printf("type: %s, read: %s\n", type, readok);
    exit(0);
}

第六节共享文件

内核用三个相关的数据结构来表示打开的文件：

描述符表
文件表：打开文件的集合是由一张文件表来表示的。
v-node表

示例：

典型的无共享的：

描述符1和4指向文件表中不同的表现，进而引用了两个不同的文件。

文件共享：

这里可以看到，描述符1和4指向了文件表中的不同表项，但是引用了同一个文件，关于这种情况书上给了一个实例：同一个filename调用open函数两次，这时描述符是不一样的，文件位置也不一样，但是都是同一个文件。这体现的关键思想是：

每个描述符都有它自己的文件位置，所以对不同描述符的读操作可以从文件的不同位置获取数据。

子进程继承父进程的打开文件：

初始状态如图6，只有父进程进行了打开文件，然后子进程会有一个父进程描述符表的副本，因而能够共享相同的打开文件表集合，同时也就共享相同的文件位置。

而由于文件表的性质，关闭一个描述符的时候只会减少相应的文件表表项中的引用计数，内核不会删除这个文件表表项直至引用计数清零，所以要想内核删除相应文件表表项，父子进程都必须关闭它们的描述符。

这几种状况的应用，在10.2和10.3题。

练习10.2中，因为fd1和fd2有独立的文件描述符，它们各自有各自的描述符表、文件表、v-code表，所以它们的读取是各自独立的，最后得值是f；

练习10.3中，Fork是子程序，和父程序共享同一个描述符表、文件表、v-code表，指向相同的文件，所以在子程序执行过后，父程序在其基础上进行，读取下一个字符，是o。

第七节 I/O重定向

I/O重定向操作符： >

ls > foo.txt

这句代码的含义就是使外壳加载和执行ls程序，并且将标准输出重定向到磁盘文件foo.txt。

I/O重定向函数： dup2

函数定义为：

#include <unistd.h>

int dup2(int oldfd, int newfd);

返回值：成功返回描述符，错误返回-1

这个函数执行的操作是，拷贝描述符表表项oldfd，覆盖描述表表项newfd，如果后者被打开，则在拷贝前关闭它。

例题10.5中，初始情况下fd1和fd2的描述符分别是3和4，所以是两个不同描述符表，指向两个不同的文件，但是由于在读了fd2一个字节之后，将fd1重定向到了fd2，所以此时再读fd1相当于在读fd2，也就是结果是o。

第八节标准I/O

1.标准I/O库：

ANSI C定义了一组高级输入输出函数，称为标准I/O库，包含:

fopen、fclose，打开和关闭文件
fread、fwrite，读和写字节
fgets、fputs，读和写字符串
scanf、printf，复杂的格式化的I/O函数

2.流——类型为FILE的流是对文件描述符和流缓冲区的抽象

标准I/O库将一个打开的文件模型化为一个流。

每个ANSI C程序开始的时候都有三个打开的流：stdin、stdout、stderr，对应于标准输入、标准输出和标准错误（参见第一节笔记），定义如下：

#include <stdio.h>

extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;

第九节套接字

网络套接字上最好不要使用标准I/O函数，而是使用RIO函数，原因：

如果没有清楚缓存区，输入函数后面不能接输出函数，输出函数后面也不能接输入函数，而对套接字使用lseek是非法的，打开两个流有很麻烦，所以！在网络套接字上不要使用标准I/O函数来进行输入和输出！

错误处理

附录A中主要讲了这本书中的错误处理方式，有一个方法——错误处理包装函数，这个思想很有意思，相当于给基本函数再套上一层皮，然后run这个皮，发现了错误就终止，完全正确的话就跟没有这层皮一样。

1.错误处理风格

（1）Unix风格

遇到错误后返回-1，并且将全局变量errno设置为指明错误原因的错误代码；

如果成功完成，就返回有用的结果。

（2）Posix风格

返回0表示成功，返回非0表示失败；

有用的结果在传进来的函数参数中。

（3）DNS风格

有两个函数，gethostbyname和gethostbyaddr，失败时返回NULL指针，并设置全局变量h_errno。

（4）错误报告函数

void unix_error(char *msg) /* unix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(errno));
    exit(0);
}
/* $end unixerror */

void posix_error(int code, char *msg) /* posix-style error */
{
    fprintf(stderr, "%s: %s\n", msg, strerror(code));
    exit(0);
}

void dns_error(char *msg) /* dns-style error */
{
    fprintf(stderr, "%s: DNS error %d\n", msg, h_errno);
    exit(0);
}

void app_error(char *msg) /* application error */
{
    fprintf(stderr, "%s\n", msg);
    exit(0);
}

2.错误处理包装函数

Unix风格

成功时返回void，返回错误时包装函数打印一条信息，然后退出。

void Kill(pid_t pid, int signum) 
{
    int rc;

    if ((rc = kill(pid, signum)) < 0)
	unix_error("Kill error");
}

Posix风格

成功时返回void，错误返回码中不会包含有用的结果。

void Pthread_detach(pthread_t tid) {
    int rc;

    if ((rc = pthread_detach(tid)) != 0)
	posix_error(rc, "Pthread_detach error");
}

DNS风格

struct hostent *Gethostbyname(const char *name) 
{
    struct hostent *p;

    if ((p = gethostbyname(name)) == NULL)
	dns_error("Gethostbyname error");
    return p;
}

参考资料

1.mjay1234的专栏→http://blog.csdn.net/mjay1234/article/details/7357261

2.《深入理解计算机系统》

学习总结

预计学习时间：4h

实际学习时间：6h

这一章内容从页码上看起来不算多，但是牵扯到一些不熟悉却又至关重要的内容，我花了比想象中更多的时间来通读书上的代码，试图解释每一句的含义，这样做给我对代码的理解有一定的帮助，但对于学以致用来说还是有些吃力。而实践代码一开始忘记了，后来才想起来，导致最后花了很多时间去看，理解的还是有些不够到位。

实践代码

看代码的时候我最先不理解的就是main函数的定义：

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

经查阅得知，argc是用来表示在命令行下输入命令时的参数个数，包括指令本身；argv[]是用来取得你输入的参数。针对具体指令分析如下（每一步解释由注释形式给出）。

首先先先看一下涉及到的头文件的用处：

stdio.h	标准输入输出
stdlib.h	C标准函数库
unistd.h	Unix类系统定义符号常量
fcntl.h	定义了很多宏和open，fcntl函数原型
sys/types.h	基本系统数据类型
dirent.h	unix类目录操作的头文件，包含了许多UNIX系统服务的函数原型，例如opendir函数、readdir函数。
termios.h	在Posix规范中定义的标准接口

cp

#include        <stdio.h>//标准输入输出
#include        <stdlib.h>//C标准函数库
#include        <unistd.h>//Unix类系统定义符号常量
#include        <fcntl.h>//定义了很多宏和open，fcntl函数原型

#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];//存储器位置

	/*cp的参数有两个，分别是要复制的文件，和目的目录，这样一共应该是有三个操作数
	所以要先检查argc的值是否为三，如果不是，返回标准错误*/
	if (argc != 3) {
		fprintf(stderr, "usage: %s source destination\n", *argv);
		exit(1);
	}
    /*检查cp的第一个参数，要复制的文件，用open打开，in_fd为open返回的描述符
    如果返回-1，代表打开失败，提示错误*/
	if ((in_fd = open(argv[1], O_RDONLY)) == -1)
		oops("Cannot open ", argv[1]);

    /*检查cp的第二个参数，复制的目的地址，用create在目的地址创建新文件，out_fd为open返回的描述符
    如果返回-1，代表创建失败，提示错误*/
	if ((out_fd = creat(argv[2], COPYMODE)) == -1)
		oops("Cannot creat", argv[2]);

    /*cp指令的动作就是读取一个文件的内容到存储器，在新的地址创建空白文件，再从存储器将内容写入新文件。
    这里判断复制是否成功：
    如果能读取顺利，而读取的位数和写的位数不同，是写错误；
    如果读取失败，是读错误。*/
	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]);

    /*这里执行的是关闭文件的动作，in_fd和out_fd两个文件描述符
    所指向的文件只要有一个关闭错误，就提示关闭错误。*/
	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);//用来将上一个函数发生错误的原因输出到标准设备(stderr)
	exit(1);
}

ls（1）

#include	<stdio.h>
#include	<sys/types.h>
#include	<dirent.h>

void do_ls(char []);

int main(int argc, char *argv[])
{
    /*如果操作数只有1个，表明ls后面没有带参数，默认为当前目录，.表示当前目录。*/
	if ( argc == 1 )
		do_ls( "." );
    /*如果ls后面有参数，就把参数读入argv中。*/
	else
		while ( --argc ){
			printf("%s:\n", *++argv );
			do_ls( *argv );
		}

	return 0;
}

/*因为ls和dir功能相近，用dir来实现ls*/
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

ls2前半部分和ls1一样，所不同的只是多出来了一部分，用来显示文件的详细信息，比如用户名，群组名，大小，创建时间，读写权限等。

who

这个代码的思想是，从UTMP_FILE文件中读取想要的信息到存储器中，然后再用标准输出函数打印到屏幕上，最后关闭文件。

#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);

/*打开UTMP_FILE读取信息，如果打开失败则输出失败信息。*/
	if ( (utmpfd = open(UTMP_FILE, O_RDONLY)) == -1 ){
		perror( UTMP_FILE );	
		exit(1);
	}
	/*读取信息到存储器中，reclen就是是读的字节数，然后再调用函数打印出来。*/
	while ( read(utmpfd, &current_record, reclen) == reclen )
		show_info(&current_record);
	close(utmpfd);
	return 0;			
}

echostate

这个代码是用来检查命令行中的提示符是否显示的，如果显示，输入的命令都可见，不显示则表示输入的命令不可见，具体例子结合setecho代码一起

#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;
}

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;
}

可以看出来，当echo is on的时候，输入的指令是可见的，当设置为off的时候，输入指令不可见

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 );               
}

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 );
}

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;
}

这个代码的功能是列出当前目录：

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;
}

posted @ 2015-11-08 19:01 20135202闫佳歆阅读(644) 评论(1) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

青衫洗旧

无情人与多情客 皆是我

20135202闫佳歆——信息安全系统设计基础第九周学习总结

第十章 系统级I/O

第一节 Unix I/O

1.打开文件：

2.改变当前的文件位置

3.读写文件

（1）读

※EOF的来源：

（2）写

4.关闭文件

第二节 打开和关闭文件

1.open函数

2.close函数

第三节 读和写文件

1.读 read

2.写 write

3.通过lseek函数可以显式的修改当前文件的位置

4.不足值

第四节 用RIO包健壮的读写

1.RIO的无缓冲的输入输出函数。

rio_readn函数和rio_writen定义：

2.RIO的带缓冲的输入函数

图10-4：

图10-5：

图10-6：

rio_readnb函数

rio_readlineb函数

第五节 读取文件元数据

第六节 共享文件

示例：

典型的无共享的：

文件共享：

子进程继承父进程的打开文件：

第七节 I/O重定向

I/O重定向操作符： >

I/O重定向函数： dup2

第八节 标准I/O

1.标准I/O库：

2.流——类型为FILE的流是对文件描述符和流缓冲区的抽象

第九节 套接字

错误处理

1.错误处理风格

（1）Unix风格

（2）Posix风格

（3）DNS风格

（4）错误报告函数

2.错误处理包装函数

Unix风格

Posix风格

DNS风格

参考资料

学习总结

预计学习时间：4h

实际学习时间：6h

实践代码

cp

ls（1）

ls2

who

echostate

setecho

fileinfo

filesize

spwd

testioctl

公告

无情人与多情客皆是我

第十章系统级I/O

第二节打开和关闭文件

第三节读和写文件

第四节用RIO包健壮的读写

第五节读取文件元数据

第六节共享文件

第八节标准I/O

第九节套接字