信息安全系统设计基础第九周学习总结

时间 2020-06-14

原文原文链接

信息安全系统设计基础第九周学习总结

估算学习时间：共9小时
读书：5
代码：1
做业：1
博客：2
实际学习时间：共10.7小时
读书：4.2
代码：1.5
做业：2
博客：3
耗时估计的公式：Y=X+X/N ，Y=X-X/Nhtml

第十章系统级I/O

输入输出I/O是在主存和外部设备（如磁盘，网络和终端）之间拷贝数据的过程。
输入就是从I/O设备拷贝数据到主存，而输出就是从主存拷贝数据到I/O设备。
全部语言的运行时系统都提供执行I/O的较高级别的工具。例如，ANSI C提供标准I/O库，包含像printf和scanf这样执行带缓冲区的I/O函数。C++语言用它的重载操做符<<（输出）和>>（输入）提供了相似的功能。在UNIX系统中，是经过使用由内核提供的系统级Unix I/O函数来实现这些比较高级的I/O函数的。
学习Unix I/O缘由：了解Unix I/O将帮助你理解其余的系统概念；有时你除了使用Unix I/O外别无选择。

10.1　unix i/o 596

全部的I/O设备，如网络、磁盘和终端，都被模型化为文件，而全部的输入和输出都被当作对相应的文件的读和写来执行。这种将设备优雅地映射为文件的方式，容许Unix内核引出一个简单、低级的的应用接口，称为Unⅸ I/O，这使得全部的输入和输出都能以一种统一且一致的方式来执行：node

打开文件。一个应用程序经过要求内核打开相应的文件，来宣告它想要访问一个I/O设备。内核返回一个小的非负整数，叫作描述符，它在后续对此文件的全部操做中标识这个文件。内核记录有关这个打开文件的全部信息。应用程序只需记住这个描述符。Unⅸ外壳建立的每一个进程开始时都有三个打开的文件：标准输入（描述符为0）、标准输出（描述符为1）和标准错误（描述符为2)。头文件可用来代替显式的描述符值。
改变当前的文件位置。对于每一个打开的文件，内核保持着一个文件位置k，初始为0。这个文件位置是从文件开头起始的字节偏移量。应用程序可以经过执行seek操做，显式地设置文件的当前位置为k。
读写文件。一个读操做就是从文件拷贝n>0个字节到存储器，从当前文件位置k开始,而后将k增长到k＋n。给定一个大小为m字节的文件，当k>=m时执行读操做会触发―个称为end-of-file（EOF）的条件，应用程序能检测到这个条件。在文件结尾到处并无明确的“EOF”符号。
关闭文件。当应用完成了对文件的访问以后，它就通知内核关闭这个文件。做为响应，内核释放文件打开时建立的数据结构，并将这个描述符恢复到可用的描述符池中。不管一个进程由于何种缘由终止时，内核都会关闭全部打开的文件并释放它们的存储器资源。

10.2　打开和关闭文件 597

进程是经过调用open函数来打开一个已存在的文件或者建立一个新文件：
ios
flags参数表示进程打算如何访问这个文件，它的值包括：程序员

O_RDONLY
O_WRONLY
O_RDWR安全

flags参数也能够是一个或者更多位掩码的或，提供一些额外的指示：

O_CREAT
O_TRUNC：若是文件已经存在，就截断它。
O_APPEND网络

mode参数指定了新文件的访问权限位。符号名字以下图。做为上下文的一部分，每一个进程都有一个umask它是经过调用umask函数来设置的。当进程经过带某个mode参数的open函数调用来建立一个新文件时，文件的访问权限位被设置为mode&umask。

10.3　读和写文件 598

应用程序是经过分别调用系统函数 read和write函数来执行输入和输出的。
数据结构

旁注：size_t是做为usigned int，而ssize_t是做为int。socket

在某些状况下，read和write传送的字节比应用程序要求的要少。出现这种状况的可能的缘由有：函数

读时遇到EOF。假设该文件从当前文件位置开始只含有20个字节，而应用程序要求咱们以50个字节的片进行读取，这样一来，这个read的返回的值是20，在此以后的read则返回0。
从终端读文本行。若是打开的文件是与终端相关联的，那么每一个read函数将一次传送一个文本行，返回的不足值等于文本行的大小。
读和写socket。若是打开的文件对应于网络套接字，那么内部缓冲约束和较长的网络延迟会致使read和write返回不足值。工具

10.4　用rio包健壮地读写 599

RIO提供了两类不一样的函数：

无缓冲的输入输出函数
带缓冲的输入函数

10.4.1　rio的无缓冲的输入输出函数 600

rio_readn函数从描述符fd的当前文件位置最多传送n个字节到存储器位置usrbuf。相似的rio_writen函数从位置usrbuf传送n个字节到描述符fd。rio_readn函数在遇到EOF时只能返回一个不足值。rio_writen函数毫不会返回不足值。
注意:若是rio_readn和rio_writen函数被一个从应用信号处理程序的返回中断，那么每一个函数都会手动地重启read或write。

10.4.2　rio的带缓冲的输入函数 600

一个文本行就是一个由换行符结尾的ASCII码字符序列。在Unix系统中，换行符是‘\n’，与ASCII码换行符LF相同，数值为0x0a。假设咱们要编写一个程序来计算文本文件中文本行的数量应该如何来实现呢？

一种方法是用read函数来一次一个字节地从文件传送到用户存储器，检查每一个字节来查找换行符。这种方法的问题就是效率不高，每次取文件中的一个字节都要求陷入内核。
一种更好的方法是调用一个包装函数（rio_readlineb），它从一个内部缓冲区拷贝一个文本行，当缓冲区变空时，会自动的调用read系统调用来从新填满缓冲区。

在带缓冲区的版本中，每打开一个描述符都会调用一次rio_readinitb函数，它将描述符fd和地址rp处的一个类型为rio_t的读缓冲区联系起来。
rio_readinitb函数从文件rp读取一个文本行（包括结尾的换行符），将它拷贝到存储器位置usrbuf，而且用空字符来结束这个文本行。
RIO读程序的核心是rio_read函数，rio_read函数能够当作是Unix read函数的带缓冲区的版本。当调用rio_read要求读取n个字节的时候，读缓冲区内有rp->rio_cnt个未读的字节。若是缓冲区为空的时候，就会调用read系统函数去填满缓冲区。这个read调用收到一个不足值的话并非一个错误，只不过读缓冲区的是填充了一部分。
一旦缓冲区非空，rio_read就从读缓冲区拷贝n和rp->rio_cnt中较小值个字节到用户缓冲区，并返回拷贝字节的数目。
对于应用程序来讲，rio_read和系统调用read有着相同的语义。出错时返回-1；在EOF时，返回0；若是要求的字节超过了读缓冲区内未读的字节的数目，它会返回一个不足值。rio_readlineb函数屡次调用rio_read函数。每次调用都从读缓冲区返回一个字节，而后检查这个字节是不是结尾的换行符。
rio_readlineb函数最多读取（maxlen-1)个字节,余下的一个字节留给结尾的空字符。超过maxlen-1字节的文本行被截断，并用一个空字符结束。

10.5　读取文件元数据 604

应用程序可以经过调用stat和fstat函数，检索到关于文件的信息。
stat函数结构
st_size成员包含了文件的字节数大小。st_mode成员则编码了文件访问许可位和文件类型。Unix识别大量不一样的文件类型。普通文件包括某种类型的二进制或文本数据。对于内核而言，文本文件和二进制文件毫无区别。
目录文件包含关于其余文件的信息。套接字是一种用来经过网络与其余进程通讯的文件。Unix提供的宏指令根据st_mode成员来肯定文件的类型。这些宏的一个子集以下：

10.6　共享文件 606

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

描述符表
文件表
v-node表

10.7　i/o重定向 608

Unix外壳提供了I/O重定向操做符，容许用户将磁盘文件和标准输入输出联系起来。
I/O重定向的工做方式：一种是使用dup2函数。
dup2函数拷贝描述符表表项oldfd到描述符表表项newfd，覆盖描述符表表项newfd之前的内容。若是newfd已经打开了，dup2会在拷贝oldfd以前关闭newfd。

10.8　标准i/o 609

ANSI C定义了一组高级输入输出函数，成为标准I/O库，为程序员提供了Unix I/O的较高级别的替代。这个库（libc）提供了打开和关闭文件的函数（fopen和fclose）、读和写字节的函数（fread和fwrite）、读和写字符串的函数（fgets和fputs）、以及复杂的格式化I/O函数（printf和scanf）。
标准I/O库将一个打开的文件模型化为一个流。对于程序员而言，一个流就是一个指向FILE类型的结构的指针。每一个ANSI C程序开始时都有三个打开的流stdin、stdout和stderr，分别对应于标准输入、标准输出和标准错误：

10.9　综合：我该使用哪些i/o函数 610

这一章讨论过的各类I/O包
标准I/O流，从某种意义上来讲是全双工的，由于程序可以在同一个流上执行输入和输出。
建议在网络套接字上不要使用标准I/O函数来进行输入和输出。而要使用健壮的RIO函数。

10.10　小结 611

Unix提供了少许的系统级函数，它们容许应用程序打开、关闭、读和写文件，提取文件的元数据，以及执行I/O重定向。Unix的读和写操做会出现不足值，应用程序必须能正确地预计和处理这种状况。应用程序不该直接调用unⅸ I/O函数，而应该使用RIO包，RIO包经过反复执行读写操做，直到传送完全部的请求数据，自动处理不足值。
Unix内核使用三个相关的数据结构来表示打开的文件。描述符表中的表项指向打开文件中的表项，而打开文件表中的表项又指向v-node表中的表项，每一个进程都有它本身单独的描述符表，而全部的进程共享同一个打开文件表和v-node表，理解这些结构的通常组成就能使咱们清楚地理解文件共享和I/O重定向。
标准I/O库是基于Unix I/O实现的，并提供了一组强大的高级I/O例程，对于大多数应用程序而言，标准I/O更简单，是优于Unix I/O的选择。然而，由于对标准I/O和网络文件的一些相互不兼容的限制，Unix I/O比标准I/O更适用于网络应用程序。

重点

阅读教材，注意每一个系统调用的参数、返回值，会查帮助文档
完成课后练习（书中有参考答案）重点：10.一、10.二、10.三、10.四、10.5
重要命令：
man -k key1 | grep key2| grep 2 : 根据关键字检索系统调用
grep -nr XXX /usr/include ：查找宏定义，类型定义

实践代码

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

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

ls1

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

fileinfo

#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

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

setecho

#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 )  /* get attribs   */
			oops("tcgettattr", 1);

if ( argv[1][0] == 'y' )
info.c_lflag |= ECHO ;  /* turn on bit*/
else
info.c_lflag &= ~ECHO ; /* turn off bit   */

if ( tcsetattr(0,TCSANOW,&info) == -1 ) /* set attribs*/
   oops("tcsetattr",2);
	
		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 *);
voidprintpathto(ino_t);
voidinum_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;
}

who1

#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, &current_record, reclen) == reclen )
		show_info(&current_record);
	close(utmpfd);
	return 0;			
}

who2

#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, &current_record, reclen) == reclen )
		show_info(&current_record);
	close(utmpfd);
	return 0;			
}

遇到的问题

没法运行第十章代码怎么办？
解决方法：增长头文件库。
参考资料：http://group.cnblogs.com/topic/73278.html
虚拟机打开速度很是缓慢，已经打不开了？
增大内存

参考资料

教材：第十章，详细学习指导：http://group.cnblogs.com/topic/73069.html
课程资料：https://www.shiyanlou.com/courses/413 实验十，课程邀请码：W7FQKW4Y
教材中代码运行、思考一下，读代码的学习方法：http://www.cnblogs.com/rocedu/p/4837092.html。
CSAPP第10章系统级I/O问题：http://www.zhihu.com/question/31499851

信息安全系统设计基础第九周学习总结

信息安全系统设计基础第九周学习总结

第十章 系统级I/O

10.1 unix i/o 596

10.2 打开和关闭文件 597

10.3 读和写文件 598

10.4 用rio包健壮地读写 599

10.4.1 rio的无缓冲的输入输出函数 600

10.4.2 rio的带缓冲的输入函数 600

10.5 读取文件元数据 604

10.6 共享文件 606

10.7 i/o重定向 608

10.8 标准i/o 609

10.9 综合：我该使用哪些i/o函数 610

10.10 小结 611

重点

实践代码

cp1

echostate

ls1

ls2

fileinfo

filesize

setecho

spwd

testioctl

who1

who2

遇到的问题

参考资料

第十章系统级I/O

10.1　unix i/o 596

10.2　打开和关闭文件 597

10.3　读和写文件 598

10.4　用rio包健壮地读写 599

10.4.1　rio的无缓冲的输入输出函数 600

10.4.2　rio的带缓冲的输入函数 600

10.5　读取文件元数据 604

10.6　共享文件 606

10.7　i/o重定向 608

10.8　标准i/o 609

10.9　综合：我该使用哪些i/o函数 610

10.10　小结 611