1.Linux 使用三种流:
0:stdin 标准输入
1:stdout 标准输出
2:stderr 标准错误输出
2.默认的连接是tty
如果输入sort,按回车键，终端将会连接到sort工具上。随便输入几行文字，当按下Ctrl-D来结束文字输入的时候，sort程序对输入进行排序并将结果写到stdout.
3.重要概念
(1).shell并不将重定向标记和文件名传递给程序。
(2).重定向可以出现在命令行中的任何地方，且不需要空格来区分。
(3).shell提供对重定向向其他文件描述符的支持。例如,2>filename即将重定向描述符2，也就是将标准错误输出到给定的文件中。
(4).是shell,而非程序将输入和输出重定向的。
// io1.c
//
#include<stdio.h>
int main(int ac,char *av[]){
int i;
printf("number of args:%d\n",ac);
printf("args are:\n");
for(i=0;i<ac;i++)
printf("args[%d]=%s\n",i,av[i]);
fprintf(stderr,"This message is sent to stderr.\n");
return 0;
}[war@war io1]$ ./io1 a b es sad ddd
Number of args:6
args are:
args[0]=./io1
args[1]=a
args[2]=b
args[3]=es
args[4]=sad
args[5]=ddd
This Message is sent to stderr.
[war@war io1]$ ./io1 a b c d ef g > test
This Message is sent to stderr.
[war@war io1]$ cat test
Number of args:7
args are:
args[0]=./io1
args[1]=a
args[2]=b
args[3]=c
args[4]=d
args[5]=ef
args[6]=g
[war@war io1]$ ./io1 a b c d e f g >xyz one two 2>opps
[war@war io1]$ ls
io1 io1.c io1.o makefile opps test xyz
[war@war io1]$ cat xyz
Number of args:10
args are:
args[0]=./io1
args[1]=a
args[2]=b
args[3]=c
args[4]=d
args[5]=e
args[6]=f
args[7]=g
args[8]=one
args[9]=two
[war@war io1]$ cat opps
This Message is sent to stderr.
一.将stdin定向到文件
1.close-then-open
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
int main(){
int fd;
char line[100];
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
close(0); // 关闭标准输入流
fd = open("/etc/passwd",O_RDONLY); // 打开文件，重定向
if(fd != 0){
fprintf(stderr,"Cound not open data as fd 0\n");
exit(1);
}
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
return 0;
}
[war@war io2]$ make
gcc -o io2 io2.o
[war@war io2]$ ./io2
line1
line1
line2
line2
line3
line3
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
2.open .. close .. dup ..close
(1)open(file) 打开stdin将要重定向的文件。这个调用返回一个文件描述符，这个文件描述符不是0，因为0在当前已经被打开了。
(2)close(0) 将文件描述符0关闭。文件描述符0现在已经空闲来。
(3)dup(fd) 系统将文件描述符fd做来一个复制。此次复制使用了最低可用文件描述符号，即0.这样就将磁盘文件与文件描述符0链接在了一起。
(4)close(fd) 最后使用close(fd)来关闭文件的原始连接，只留下文件描述符0的连接。
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
int main(){
int fd;
char line[128];
fd = open("/etc/passwd",O_RDONLY); // 首先打开文件fd,得到3
close(0); // 关闭文件标志符0，即stdin
dup(fd); // 复制,fd',得到最低文件描述符0
close(fd); // 关闭fd
fgets(line,100,stdin); // 从stdin=0获取字符串,此时0标记的是
// fd'
printf(line); // 输出line
return 0;
}
cc -c -o pipe4.o pipe4.c
gcc -o pipe4 pipe4.o
[war@war pipe4]$ ./pipe4
root:x:0:0:root:/root:/bin/bash
3.open..dup2..close
与2相似，只是dup2(fd,0)将close(0),dup(fd)合在一起
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
int main(){
int fd;
int newfd;
char line[100];
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
fd = open("/etc/passwd",O_RDONLY);
newfd = dup2(fd,0);
if(newfd != 0){
fprintf(stderr,"Cound not duplicated fd to 0\n");
exit(1);
}
close(fd);
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
fgets(line,100,stdin); printf("%s\n",line);
return 0;
}
cc -c -o io3.o io3.c
gcc -o io3 io3.o
[war@war io3]$ ./io3
line1
line1
line2
line2
line3
line3
root:x:0:0:root:/root:/bin/bash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
[war@war io3]$
二.为其他程序重定向i/o
who>userlist
close(1);
creat("f");
exec();
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(){
int pid;
int fd;
printf("About to run who into a file\n");
if((pid = fork()) == -1){
perror("fork");
exit(1);
}
if(pid == 0){
close(1);
fd = creat("userlist",0644);
execlp("who","who",NULL);
perror("execlp");
exit(1);
}
if(pid!=0){
wait(0);
printf("Done runing who. result in userlist.\n");
}
return 0;
}
gcc -o io4 io4.o
[war@war io4]$ ./io4
About to run who into a file
Done runing who. result in userlist.
[war@war io4]$ cat userlist
war tty1 2015-10-04 14:08 (:0)
war pts/0 2015-10-04 14:22 (:0.0)
重定向到文件的小结:
(1)标准输入,输出以及错误输出分别对应文件描述符0,1,2;
(2)内核总是使用最低可用文件描述符;
(3)文件描述符集合通过exec调用传递，且不会被改变
shell 使用进程通过fork()产生子进程与子进程调用exec之间的时间间隔来重定向标准输入，输出到文件
三，管道编程
管道是内核中一个单向的数据通道。管道有一个读取端和写入端。
pipe调用由使用来最低可用文件描述符。
pipe 创建管道
头文件: #include<unistd.h>
原型:result = pipe(int array[2]);
参数：array 包含两个int类型的数组
返回值：-1错误，0成功
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main(){
int apipe[2],i,len;
char buf[BUFSIZ];
if(pipe(apipe) == -1){ // 创建一个管道:apipe[0]读，apipe[1]写
// 数据流向:读 <--- 写, 即apipe[1]流向apipe[0]
perror("pipe"); // 如果创建失败，输出错误原因，退出
exit(0);
}
fgets(buf,BUFSIZ,stdin); // 从输入端读取数据
len = strlen(buf); // 获取读入的字符串长度
write(apipe[1],buf,len); // 将数据写入到apipe[1],写-->读
for(i=0;i<len;i++)
buf[i]='-'; // 将buf里面的数据全部变为'-'
read(apipe[0],buf,len); // 从apipe[0]中读取数据,apipe[1]和apipe[0]
// 是连接在一起的apipe[1] ---> apipe[0]
// 而前面已经在apipe[1]中写入了数据buf,buf的
// 数据来自stdin.
write(1,buf,len); // 1即代表stdout,向stdout写数据，则输出到屏幕
// 所以整个一圈下来，输入的数据将会输出到屏幕
return 0;
}
[war@war pipe2]$ make
gcc -o pipe2 pipe2.o
[war@war pipe2]$ ./pipe2
abc
abc
使用管道向自己发送数据：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define CHILD_MESS "I want a cookie\n"
#define PAR_MESS "Testing...\n"
#define oops(m,x) {perror(m);exit(x);}
int main(){
int pipefd[2];
int len;
char buf[BUFSIZ];
int read_len;
if(pipe(pipefd) == -1){
oops("can not get a pipe",1);
}
else{
printf("pipefd[0]=%d,pipefd[1]=%d\n",pipefd[0],pipefd[1]);
}
switch(fork()){
case -1:oops("cannot fork",2);
case 0:
len = strlen(CHILD_MESS);
while(1){
if(write(pipefd[1],CHILD_MESS,len) == -1){
oops("Write",3);
}
sleep(5);
}
break;
default:
len = strlen(PAR_MESS);
while(1){
if(write(pipefd[1],PAR_MESS,len)!=len)
oops("write",4);
sleep(4);
read_len=read(pipefd[0],buf,BUFSIZ);
if(read_len<=0)
break;
write(1,buf,read_len);
}
break;
}
return 0;
}
[war@war pipedemo]$ make
cc -c -o pipedemo.o pipedemo.c
gcc -o pipedemo pipedemo.o
[war@war pipedemo]$ ./pipedemo
pipefd[0]=3,pipefd[1]=4
Testing...
I want a cookie
Testing...
I want a cookie
Testing...
I want a cookie
Testing...
I want a cookie
Testing...
Testing...
I want a cookie
Testing...
I want a cookie
^C
在程序中。显示来从键盘到进程，从进程到管道，再从管道到进程以及从进程回到终端的数据传输流。
使用fork来共享管道
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define SON_STR "sub process string...\n" // 子进程字符串
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define SON_STR "sub process string...\n" // 子进程字符串
int main(){
int pid;
int apipe[2];
char buf[128];
// 首先创建一个管道
if(pipe(apipe) == -1){ // 如果创建失败，则输出错误原因，并退出
perror("pipe");
exit(1);
}
pid = fork(); // 创建一个子进程
switch(pid){
case -1: // 如果创建失败
perror("fork");// 输出错误原因
exit(1); // 并退出
break;
case 0: // 创建成功，0说明是子进程
write(apipe[1],SON_STR,strlen(SON_STR)); // 向子进程的写入管道
// 写入数据
break;
default: // 非0则是父进程
read(apipe[0],buf,128); // 从父进程的读管道接口读取数据
write(1,buf,strlen(buf)); // 将读取的数据输出到屏幕
break;
}
return 0;
}
[war@war pipe3]$ ./pipe3
sub process string...
在这个程序中，shell首先创建管道，然后调用fork创建两个新进程，再将标准输入和输出重定向到创建的管道，最后通过exec来执行两个程序。当父进程调用fork的时候，管道的两端都被复制到子进程当中。只有由共同父进程的进程之间才可以用管道连接。
四，管道并非文件
管道在很多方面都类似于普通文件。进程使用write将数据写入到管道，又通过read把数据读出来。像文件一样，管道是不带由任何结构的字节序列。另一方面，管道又与文件不同，例如文件的结尾也是否适用于管道呢？
1.从管道中读取数据
（1）管道读取阻塞
当进程试图从管道中读取数据时，进程被挂起直到数据被写进进程。那么如何避免进程无止境地等待下去呢？
（2）管道的读取结束标志
当所有的写者关闭来管道的写数据端时，试图从管道读取数据的调用返回0，这意味著文件的结束。
（3）多个读者可能引起麻烦
管道是一个队列。当进程从管道中读取数据之后，数据已经不存在了。如果两个进程都试图对同一个管道进行读操作，在一个进程读取一些之后，另一个进程读到的将是后面的内容。他们读到的数据必然是不完整的，除非两个进程使用某种放法来协调他们对管道的访问。
2.向管道中西数据
（1）写入数据阻塞直到管道有空间去容纳新的数据
管道的容纳数据的能力要比磁盘文件差得多。当进程试图对管道进行写操作时，此调用将挂起直到管道中有足够的空间去容纳新的数据。如果进程想写入1000个字节，而管道中现在只能容纳500个字节，那么这个写入调用就只好等待直到管道中再有500个字节空出来。如果某进程试图写100万字节，那结果会怎么样呢？调用会不会永远等待下去呢？
（2）写入必需保证一个最小的块大小
POSIX标准规定内核不会拆分小于512字节的块。而Linux则保证管道中可以存在4096字节的连续内存。如果两个进程向管道写数据，并且每一个进程都限制其消息不大于512字节，那么这些消息都不会被内核拆分。
（3）若无读者存在读取数据，则写操作执行失败
如果所有的读者都已将管道的读取端关闭，那么对管道的写入调用将会执行失败。如果在这种情况下，数据还可以被接受的话，他们会到哪里去呢？为了避免数据丢失，内核采用了两种方法来通知进程：“此时的写操作是无意义的”。首先，内核发送SIGPIPE消息给进程。若进程被终止，则无任何事情发生。否则write调用返回-1，并且将errno置为EPIPE。(这一节摘自《Unix/Linux编程实践教程》)
扫一扫
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
