一、高級I/O函數：
linux提供了很多高級I/O函數。他們並不像linux基礎的I/O函數那么常用（編寫內核模塊時候一般需要這些I/O函數），但是在特定條件下表現出優秀的性能。
1、用於創建問價描述符的函數，pipe，dup，dup2；
2、用於讀寫數據的函數。
3、用於控制I/O行為和屬性的函數，包括fcntl函數。
1、pipe函數：
#include<unistd.h>
int pipe(int filedes[2]);
pipe（）會建立管道，將文件描述符有參數filedes[]數組返回。
filedes[0]為管道李的讀取端，filededs[1]為管道寫入端。
返回值：若成功，返回0，否則返回-1，錯誤原因存於errno中。
錯誤代碼：
EMFILE：進程已用完文件描述符最大量。
ENFILE：系統已無文件描述符。
EFAULT參數filedes數組地址不合法。
舉例：
#include <unistd.h>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <string.h>
using namespace std;
int main(void){
int filedes[2];
char buf[80];
pid_t pid ;
pipe(filedes);
pid = fork();
if(pid>0){cout<<"this is the father process ,here write a string to the pipe"<<endl;
char s[] = "hello world, this is writen by pipe";
//write(filedes[1],s,sizeof(s));
send(filedes[1],s,sizeof(s),0);
close(filedes[0]);
close(filedes[1]);
}
else if(pid == 0){
cout<<"this is in the child process ,here read a string from the pipe"<<endl;
//read(filedes[0],buf,sizeof(buf));
recv(filedes[1],buf,sizeof(buf),0);
cout<<buf<<endl;
close(filedes[0]);
close(filedes[1]);
}
waitpid(pid,NULL,0);
return 0;
}
管道是一種把倆個進程之間的標准輸入和標准輸出連接起來的機制，從而提供一種讓多個進程間通信的方法，當進程創建管到時候，每次都需要提供倆個文件描述符來操作管道，讀取，寫入。對於管道的讀寫與一般的I/O系統函數一直i，使用write和read。
命名管道：FIFO
管道最大的劣勢就是沒有名字，只能用於有一個共同的祖先的各個進程之間。FIFO代表先進先出，但她似乎是一個單項數據流，也就是半雙工，和管道不同的是:每個FIFO都有一個路徑與之關聯，從而允許無親緣關系的進程訪問。
由於命名管道是以文件形式創建的，所以也具有一些特性，它可以使用fcntl函數改變屬性。
#include<sys/socket.h>
#include <sys/types.h>
#include<sys/stat.h>
int mkfifo(const char*pathname,mode_t mode);
這里的pathname是路徑，mode是sys/stat.h里面定義的創建文件的權限。
實例：
/*
* 有親緣關系的進程間的fifo的使用
* fifo 使用的簡單例子
*/
#include "../all.h"
#define FIFO_PATH "/tmp/hover_fifo"
void
do_sig(int signo)
{
if (signo == SIGCHLD)
while (waitpid(-1, NULL, WNOHANG) > 0)
;
}
int
main(void)
{
int ret;
int fdr, fdw;
pid_t pid;
char words[10] = "123456789";
char buf[10] = {'\0'};
// 創建它,若存在則不算是錯誤,
// 若想修改其屬性需要先打開得到fd,然后用fcntl來獲取屬性,然后設置屬性.
if (((ret = mkfifo(FIFO_PATH, FILE_MODE)) == -1)
&& (errno != EEXIST))
perr_exit("mkfifo()");
fprintf(stderr, "fifo : %s created successfully!\n", FIFO_PATH);
signal(SIGCHLD, do_sig);
pid = fork();
if (pid == 0) { // child
if ((fdr = open(FIFO_PATH, O_WRONLY)) < 0) // 打開fifo用來寫
perr_exit("open()");
sleep(2);
// 寫入數據
if (write(fdr, words, sizeof(words)) != sizeof(words))
perr_exit("write");
fprintf(stderr, "child write : %s\n", words);
close(fdw);
} else if (pid > 0) { // parent
if ((fdr = open(FIFO_PATH, O_RDONLY)) < 0) // 打開fifo用來讀
perr_exit("open()");
fprintf(stderr, "I father read, waiting for child ...\n");
if (read(fdr, buf, 9) != 9) //讀數據
perr_exit("read");
fprintf(stderr, "father get buf : %s\n", buf);
close(fdr);
}
// 到這里fifo管道並沒有被刪除,必須手動調用函數unlink或remove刪除.
return 0;
}
從事列中可以看出使用fifo需要注意：fifo管道是先調用mkfifo創建，然后在調用open打開。得到fd來使用。再打開fifo時候需要注意，它是半雙工的，一般不能使用O_WDWR打開，而只能使用只讀，或是只寫打開。
fifo可以用在非親緣關系的進程之間，而他的真正用途是在客戶端和服務器之間，由於它是半雙工的所以，如果客戶端和服務器雙方的通信的話，每個方向都必須建立倆個管道，一個用於讀，一個用於寫。下面是一個服務端對多個客戶端等的fifo例子：
/*
* FIFO server
*/
#include "all.h"
int
main(void)
{
int fdw, fdw2;
int fdr;
char clt_path[PATH_LEN] = {'\0'};
char buf[MAX_LINE] = {'\0'};
char *p;
int n;
if (mkfifo(FIFO_SVR, FILE_MODE) == -1 && errno != EEXIST)
perr_exit("mkfifo()");
if ((fdr = open(FIFO_SVR, O_RDONLY)) < 0)
perr_exit("open()");
/*
* 根據fifo的創建規則, 若從一個空管道或fifo讀,
* 而在讀之前管道或fifo有打開來寫的操作, 那么讀操作將會阻塞
* 直到管道或fifo不打開來讀, 或管道或fifo中有數據為止.
*
* 這里,我們的fifo本來是打開用來讀的,但是為了,read不返回0,
* 讓每次client端讀完都阻塞在fifo上,我們又打開一次來讀.
* 見unpv2 charper 4.7
*/
if ((fdw2 = open(FIFO_SVR, O_WRONLY)) < 0)
fprintf(stderr, "open()");
while (1) {
/* read client fifo path from FIFO_SVR */
/* 這里由於FIFO_SVR有打開來寫的操作,所以當管道沒有數據時,
* read會阻塞,而不是返回0.
*/
if (read(fdr, clt_path, PATH_LEN) < 0) {
fprintf(stderr, "read fifo client path error : %s\n", strerror(errno));
break;
}
if ((p = strstr(clt_path, "\r\n")) == NULL) {
fprintf(stderr, "clt_path error: %s\n", clt_path);
break;
}
*p = '\0';
DBG("clt_path", clt_path);
if (access(clt_path, W_OK) == -1) { // client fifo ok, but no permission
perror("access()");
continue;
}
/* open client fifo for write */
if ((fdw = open(clt_path, O_WRONLY)) < 0) {
perror("open()");
continue;
}
if ((n = read(fdr, buf, WORDS_LEN)) > 0) { /* read server words is ok */
printf("server read words : %s\n", buf);
buf[n] = '\0';
write(fdw, buf, strlen(buf));
}
}
close(fdw);
unlink(FIFO_SVR);
exit(0);
}
客戶端的例子：
/*
* Fifo client
*
*/
#include "all.h"
int
main(void)
{
int fdr, fdw;
pid_t pid;
char clt_path[PATH_LEN] = {'\0'};
char buf[MAX_LINE] = {'\0'};
char buf_path[MAX_LINE] = {'\0'};
snprintf(clt_path, PATH_LEN, FIFO_CLT_FMT, (long)getpid());
DBG("clt_path1 = ", clt_path);
snprintf(buf_path, PATH_LEN, "%s\r\n", clt_path);
if (mkfifo(clt_path, FILE_MODE) == -1 && errno != EEXIST)
perr_exit("mkfifo()");
/* client open clt_path for read
* open server for write
*/
if ((fdw = open(FIFO_SVR, O_WRONLY)) < 0)
perr_exit("open()");
/* write my fifo path to server */
if (write(fdw, buf_path, PATH_LEN) != PATH_LEN)
perr_exit("write()");
if (write(fdw, WORDS, WORDS_LEN) < 0) /* write words to fifo server */
perr_exit("error");
if ((fdr = open(clt_path, O_RDONLY)) < 0)
perr_exit("open()");
if (read(fdr, buf, WORDS_LEN) > 0) { /* read reply from fifo server */
buf[WORDS_LEN] = '\0';
printf("server said : %s\n", buf);
}
close(fdr);
unlink(clt_path);
exit(0);
}
2、dup（）函數和dup2（）函數。
有時候，我們希望將標准輸出重定向到一個新的文件描述符，該新文件描述符和原有的文件描述符指向相同的文件，管道或者網絡連接。並且dup返回的文件描述符總是取系統當前可用的最小的整數值。dup2和dup類似，不過他將返回一個不小於file_desctriptor_two的整數值。dup和dup2系統調用失敗時返回-1，並設置errno。
注意：通過dup和dup2創建的問價描述符並不繼承源文件描述符的屬性，比如close-on-exec和
non-blocking等。
實例：使用dup（）創建一個基本的CGI服務器。
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
using namespace std;
int main(int argc,char*argv[]){
const char* ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address,sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
//address.sin_addr.s_addr = inet_addr("127.0.0.1");
inet_pton(AF_INET,ip,&address.sin_addr);
int sock = socket(AF_INET,SOCK_STREAM,0);
if(sock<0){cout<<"socket failed"<<endl;}
int ret = bind(sock,(struct sockaddr*)&address,sizeof(address));
if(ret <0){cout<<"bind failed"<<endl;}
ret = listen(sock,10);
if(ret < 0){cout<<"listen failed"<<endl;}
struct sockaddr_in client;
socklen_t client_addrlength = sizeof(client);
int connfd = accept(sock,(struct sockaddr*)&client,&client_addrlength);
if(connfd<0){cout<<"accept failed"<<endl;}
else{
close(STDOUT_FILENO);
dup(connfd);
cout<<"abcd"<<endl;
close(connfd);
}
close(sock);
return 0;
}
在代碼中，我們先關閉標准輸出文件描述符STDOUT_FILENO（值為1），然后復制socket文件描述符connfd。因為dup總是返回系統中最小的可以調用的文件描述符，所以他的返回值實際上是1，就是之前關閉標准輸出文件描述符的值。這樣一拉，服務器輸出到標准輸出的內容“abcd”就會直接發送到客戶連接對應的socket上，因此cout<<調用的輸出將被客戶端獲得（而不是顯示在服務器程序中端上）。這就是CGI服務器的基本工作原理。
3、（1）通用數據讀寫函數。
#include<sys/socket.h>
ssize_t recvmsg(int sockfd,struct msghdr*msg,int flags);
ssize_t sendmsg(int sockfd,struct msghdr*msg,int flags);
msg是結構體類型的指針，msghdr結構體的定義如下：
struct msghdr{
void* msg_name;//socket地址
socklen_t msg_namelen;//socket地址長度
struct iovec* msg_iov;//分散的內存塊
int msg_iovlen;//分散內存塊的數量
void* msg_control;//指向輔助數據的起始位置
socklen_t msg_controller;//輔助數據的長度
int msg_flags;//復制函數中的flags參數，並在調用中跟新
}
struct iovec{
void* iov_base;//內存起始地址
size_t iov_len;//這塊內存的長度
}
由此可見，iovec結構體封裝了一塊內存的起始位置和長度。msg_iovlen指向iovec的結構體對象有多少個。對於recvmsg而言，數據讀取並存放在msg_iovlen的內存中，這些內存的長度和位置由msg_iov指向的數組制定，分散讀；對於sendmsg而言，msg_iovlen快分散的內存數據將被一並發送，這稱為集中寫。
（2）帶外標記：檢測帶外標記的函數：sockmark(int sockfd);
判斷sockfd是否處於帶外標記，就是下一個被讀取到的數據是否是帶外數據。如果是，sockmark（）返回1，此時我們就可以使用MSG_OOB標志的recv調用來接受帶外數據，如果不是sockmark（）返回0。
（3）地址信息函數。
int getsockname(int sockfd,struct sockaddr* address,socklen_t * address_len);
int getpeername(int sockfd,struct sockaddr* address,socklen_t * address_len);
從sockfd獲得本端（遠端）socket地址，並存儲於address，長度存儲於address_len。
（4）socket選項。
讀取和設置文件描述符的方法：
int getsockopt(int sockfd,int level,int option_name,void* option_value,socklen_t * restrict option_len);
int setsockopt(int sockfd,int level,int option_name,void* option_value,socklen_t * restrict option_len);
sockfd是備操作的目標socket。
level是指定那個協議的選項（SOL_SOCKET,IPPRPTO_IP,IPPROT_IPV6）。
option_name：指定選項的名字。
option_value:操作選項的值。
option_len：操作選項的長度。
getsockopt（）和setsockopt（）成功時候返回0，失敗時返回-1，並設置errno。
注意：服務器而言，部分socket選項只能在調用listen之前針對監聽socket設置才有效。（連接socket只能由accept調用返回，而accept從listen中接受的連接至少已經完成了TCP三次握手的前倆個步驟，進入SYN_RCVD狀態）對監聽socket設置這些選項，那么accept返回的連接socket將自動繼承這些選項。
SO_REUSEADDR選項：