unix网络编程2 读写函数介绍

Inroduction

• 这一节首先介绍必要的基础知识，比如网络字节序和主机字节序，套接字地址结构，然后详细叙述各个套接字api，最后给出一个线程安全的读写函数，读写函数非常重要，其中还会写一个带缓冲的读函数，用于处理文本行，减少上下文切换。

基本函数介绍

• ipv4套接字介绍(这里没把套接字结构里面所有内容写出来)

#include<netinet/in.h>
struct sockaddr{
    sa_famliy_t sin_family;//协议族，ipv4是AF_INET
    in_port_t sin_port;//端口号
    struct in_addr sin_addr;//网络字节序32位ip地址
 }

• 套接字地址有很多种如下图
  

• 不仅仅是ipv4套接字地址结构，还有ipv6，unix域等，每一种协议的地址结构是不同的，后面使用的套接字函数如bind是ANSI C之前定义的，以前是定义的通用套接字结构，为了使用这些函数，必须进行强制类型转换。

• 通用套接字地址结构

struct sockaddr{
    sa_family_t sin_family;
}

• 字节排序函数

#include<netinet/in.h>
下面两个函数为主机字节序转网络字节序
htons 16位
htonl 32位

    void bzero(void *dest,size_t nbytes);
    目标字符串指定数目字节置为0，常用来把套接字地址结构置为0

I/O包

• 下面介绍读写函数，上一节介绍了应用进程的缓冲区可以无限，但是在TCP层的缓冲区是由对端告知的有限大小，所以read和write会返回不足值所以网络数据可能会反复使用read,write，下面会介绍一个健壮I/O包解决多次多写，而且这些函数是线程安全的。

• 首先介绍基本读写函数

注意ssize_t与size_t的区别
ssize_t 被定义为int有符号
size_t 被定义为unsigned int 无符号整型

#include<unistd.h>
从fd描述符关联的文件读数据到buf
返回值：成功返回读的字节数，若是EOF返回0(没有数据可读了)，出错-1
ssize_t read(int fd,void *buf,size_t n);

ssize_t write(int fd,const void *buf,size_t n);
从buf写n个字节到fd关联的文件
返回值：成功返回写的字节数，出错-1

• 无缓冲区输入输出函数
  直接在存储器和文件之间交换数据，没有缓冲。把2进制数据写到网络很有用
  下面这个读函数在网络数据很有用，对于一个很大的数据可以反复调用read函数，而且出现中断返回，每个函数手动重启read

ssize_t rio_readn(int fd,void *buf,size_t n){
    size_t nleft;//剩下多少没有读完的数据
    char *pbuf;
    nleft = n;
    pbuf = buf;//用来指示当前读到缓冲区哪一个字节的数据

    while(nleft > 0){
        if((nread = read(fd,buf,n))< 0){
            if(errno == EINTR)//中断
                nread = 0 //重新再读
            else 
                return -1;
        }else if(nread == 0)//没数据读了这种情况造成不足值
                break;
       pbuf += nread;
       nleft -= nread;
    }

    return (n-nleft);//返回读了的多少字节的数据
}

ssize_t rio_written(int fd,const void *buf,size_t n){
        size_t nleft = n;
        char *pbuf = buf;
        while(nleft > 0){
            if((nwritten = write(fd,buf,n)) < 0 ){
                if(errno == EINTR)
                    nwritten = 0;
                else 
                    return -1;
            }
            pbuf += nwritten;
            nleft -= nwritten;
        }
        return n;
}

• 带缓冲的读函数
  这样做的目的减少read的反复读，减少陷入内核，上下文切换的开销
  下面一读函数是缓冲的，它从fd出读10240字节(1024的倍数)到缓冲区。这样做我们需要定义一个结构，如下

#define RIO_BUFSIZE 10240
typedef struct {
    int rio_fd;//用来关联的文件描述符
    int rio_cnt;//内部缓冲区中剩余字节数
    char rio_buf[RIO_BUFSIZE];//内部缓冲区
    char *rio_bufp;//如果内部缓冲区已经读了一部分那么rio_bufp的作用就是指向已读完的字节的下一个

}rio_t

• 初始化函数
  用来把文件描述符和上面的结构联系起来，并初始化

void rio_readinit(rio_t *rp,int fd){
    rp->rio_fd = fd;
    rp->cnt = 0;
    rp->rio_bufp = rp->rio_buf;
}

• 带缓冲的read函数

ssize_t rio_read(rio_t *rp,char *buf,size_t n){
    int cnt;
    //缓冲区没数据就调用读函数往缓冲区读数据
    while(rp->rio_cnt <=0){
        if((rp->rio_cnt = read(rp->rio_fd,rp-  >rio_buf,sizeof(rp->rio_buf)))<0){
            if(errno != EINTR)
                return -1;
        }else if(rp->rio_cnt == 0){//没数据读了EOF
            return 0;
        }else
        rp->rio_bufp =  rp->rio_buf;//每一次重新填充缓冲区，就把rio_bufp置"0"
    }
    cnt = n;
    if(rp->rio_cnt < n)
        cnt  = rp->rio_cnt;
    memcpy(buf,rp->rio_bufp,cnt);
    rp->rio_bufp += cnt;
    rio_cnt -= cnt;
    return cnt;
}

• 带缓冲区的readn函数

ssize_t readnb(rio_t *rp,void *buf,size_t n){
        size_t  nleft = n;
        ssize_t nread;
        char *bufp = buf; 
        while(nleft > 0){
            if((nread = rio_read(rp->fd,buf,n)) < 0){
                if(errno == EINTR)
                    nread = 0;
            }else if(nread == 0){
                break;
            }
            bufp += nread; 
            nleft -= nread;
        }
        return (n-nleft);

}

• 带缓冲的readline

void readlineb(rio_t *rp,void *buf,size_t maxlen){

        ssize_t  rc;//读一个字节
        char c ,*bufp = buf
        for(n = 1; n < maxlen ;n++){
            if((rc = rio_read(rp->fd,&c,1)) == 1){
                *bufp++ = c;
                if(c == '\n')
                    break;
            }else if(rc == 0){
                if(n == 1)
                    return 0;//没有数据读
                else
                    break;//读到数据，遇到EOF
            }else
                return -1;
        }
        *bufp = 0;
        return n;
}