nginx&http 第五章 https non-fd 读写检测

EPOLL的LT/ET 模式下的读写

　　从一个非阻塞的socket上调用recv/send函数, 返回EAGAIN或者EWOULDBLOCK(注: EAGAIN就是EWOULDBLOCK)
从字面上看, 意思是:EAGAIN: 再试一次，EWOULDBLOCK: 如果这是一个阻塞socket, 操作将被block，error输出: Resource temporarily unavailable，这个错误表示资源暂时不够，能read时，读缓冲区没有数据，或者write时，写缓冲区满了。遇到这种情况，如果是阻塞socket，read/write就要阻塞掉。而如果是非阻塞socket，read/write立即返回-1，同时errno设置为EAGAIN。所以，对于阻塞socket，read/write返回-1代表网络出错了。但对于非阻塞socket，read/write返回-1不一定网络真的出错了。可能是Resource temporarily unavailable。这时应该继续尝试，直到Resource available。

综上，对于non-blocking的socket，正确的读写操作为:
读：忽略掉errno = EAGAIN的错误，下次继续读
写：忽略掉errno = EAGAIN的错误，下次继续写

epoll 的LT和ET二者的差异在于

level-trigger模式下只要某个socket处于readable/writable状态，无论什么时候进行epoll_wait都会返回该socket；

edge-trigger模式下只有某个socket从unreadable变为readable或从unwritable变为writable时，epoll_wait才会返回该socket。

epoll的ET模式下，正确的读写方式:
读：只要可读，就一直读，直到返回0，或者ret = -1， errno = EAGAIN
写:只要可写，就一直写，直到数据发送完，或者ret = -1， errno = EAGAIN

static int do_raw_read(int fd, void *buf, int *bufsize, void *userdata)

{

    ssize_t len = 0, res;

    int is_first_recv = 0;

    while(len < *bufsize) {

        res = recv(fd, buf + len, *bufsize - len, 0);

        if (res < 0) {

            do_warn("errno:%d, %s\n", cross_sock_errno, strerror(errno));

            if (sock_errno == EINTR)

                continue;

            else if (sock_errno == EAGAIN)

                break;

            else

                return -1;

        }

        if (res == 0) {

            if (is_first_recv == 0)

                return 1;       //EOF of fd

            else

                break;

        }

        len += res;

        is_first_recv = 1;

    }

    *bufsize = len;

    return 0;

}

int nwrite, data_size = strlen(buf);

 n = data_size;

 while (n > 0) {

     nwrite = write(fd, buf + data_size - n, n);

     if (nwrite < n) {

         if(nwrite == -1 && errno != EINTR)

                      continue;

         if (nwrite == -1 && errno != EAGAIN) {

            do_debug("errno:%d, %s\n", sock_errno, strerror(errno));

         }

　　　do_warn("errno:%d, %s\n", sock_errno, strerror(errno));　  　

         break;

     }

     n -= nwrite;

}

socket的accept，accept 要考虑 2 个问题
(1) 阻塞模式 accept 存在的问题
考虑这种情况：TCP连接被客户端夭折，即在服务器调用accept之前，客户端主动发送RST终止连接，导致刚刚建立的连接从就绪队列中移出，
如果套接口被设置成阻塞模式，服务器就会一直阻塞在accept调用上，直到其他某个客户建立一个新的连接为止。但是在此期间，服务器单
纯地阻塞在accept调用上，就绪队列中的其他描述符都得不到处理。

解决办法是把监听套接口设置为非阻塞，当客户在服务器调用accept之前中止某个连接时，accept调用可以立即返回-1，这时源自Berkeley的
实现会在内核中处理该事件，并不会将该事件通知给epoll，而其他实现把errno设置为ECONNABORTED或者EPROTO错误，我们应该忽略这两个错误。

(2)ET模式下accept存在的问题
考虑这种情况：多个连接同时到达，服务器的TCP就绪队列瞬间积累多个就绪连接，由于是边缘触发模式，epoll只会通知一次，accept只处理
一个连接，导致TCP就绪队列中剩下的连接都得不到处理。

解决办法是用while循环抱住accept调用，处理完TCP就绪队列中的所有连接后再退出循环。如何知道是否处理完就绪队列中的所有连接呢？accept
返回-1并且errno设置为EAGAIN就表示所有连接都处理完。

 do {

  /*

            针对非阻塞I/O执行的系统调用则总是立即返回，而不管事件足否已经发生。如果事件没有眭即发生，这些系统调用就

        返回—1．和出错的情况一样。此时我们必须根据errno来区分这两种情况。对accept、send和recv而言，事件未发牛时errno

        通常被设置成EAGAIN（意为“再来一次”）或者EWOULDBLOCK（意为“期待阻塞”）：对conncct而言，errno则被

        设置成EINPROGRESS（意为“在处理中"）。

          */

        s = accept(lc->fd, (struct sockaddr *) sa, &socklen);

        if (s == (socket_t) -1) {

            err = socket_errno;

            /* 如果要去一次性读取所有的accept信息，当读取完毕后，通过这里返回。所有的accept事件都读取完毕 */

            if (err == NGX_EAGAIN) { //如果event{}开启multi_accept，则在accept完该listen ip:port对应的ip和端口连接后，会通过这里返回

                return;

            }

           if (err == NGX_EMFILE || err == NGX_ENFILE) {

                    do_warn("");// Too many descriptors are in use by this process.

                    return;

            }

            if (err == NGX_ECONNABORTED || err= EPROTO) {

               continue;

            }

            return;

        }

        process_new_fd(s);

    } while (flag); //一次性读取所有当前的accept，直到accept返回NGX_EAGAIN，然后退出

}

使用Linux epoll模型，水平触发模式；当socket可写时，会不停的触发socket可写的事件，如何处理?????????????????

　　　　开始不把socket加入epoll，需要向socket写数据的时候，直接调用write或者send发送数据。如果返回EAGAIN，把socket加入epoll，在epoll的
驱动下写数据，全部数据发送完毕后，再移出epoll。这种方式的优点是：数据不多的时候可以避免epoll的事件处理，提高效率。

int main(){

     if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

         do_debug("sockfd\n");

         exit(1);

     }

     setnonblocking(listenfd);

     bzero(&local, sizeof(local));

     local.sin_family = AF_INET;

     local.sin_addr.s_addr = htonl(INADDR_ANY);;

     local.sin_port = htons(PORT);

     if( bind(listenfd, (struct sockaddr *) &local, sizeof(local)) < 0) {

         do_debug("bind\n");

         exit(1);

     }

     listen(listenfd, 20);

     epfd = epoll_create(MAX_EVENTS);

     if (epfd == -1) {

         do_debug("epoll_create");

         exit(EXIT_FAILURE);

     }

     ev.events = EPOLLIN;

     ev.data.fd = listenfd;

     if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {

         do_debug("epoll_ctl: listen_sock");

         exit(EXIT_FAILURE);

     }

     for (;;) {

         nfds = epoll_wait(epfd, events, MAX_EVENTS, timer); //timer为-1表示无限等待

         if (nfds == -1) {

             do_debug("epoll_pwait");
　　　　　　　　if (errno == NGX_EINTR) {

　　　　　　　　}

             exit(EXIT_FAILURE);

         }

 　　　　　if (0 == nfds){
          }

         for (i = 0; i < nfds; ++i) {

             fd = events[i].data.fd;

             if (fd == listenfd) {

                 while ((sock_fd = accept(listenfd,(struct sockaddr *) &remote,

                                 (size_t *)&addrlen)) > 0) {

                     setnonblocking(sock_fd);

                     ev.events = EPOLLIN | EPOLLET;

                     ev.data.fd = sock_fd;

                     if (epoll_ctl(epfd, EPOLL_CTL_ADD, sock_fd,

                                 &ev) == -1) {

                         do_debug("epoll_ctl: add");

                         exit(EXIT_FAILURE);

                     }

                 }

                 if (sock_fd == -1) {

                     if (errno != EAGAIN && errno != ECONNABORTED

                             && errno != EPROTO && errno != EINTR)

                         do_debug("accept");

                 }

                 continue;

             }  
　　　　　　　　if (events[i].events & (EPOLLERR|EPOLLHUP)) {
　　　　　　　　　
　　　　　　　　　　　　　　　　　　　process------
              }

             if (events[i].events & EPOLLIN) {

                 n = 0;

                 while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {

                     n += nread;

                 }

                 if (nread == -1 && errno != EAGAIN) {

                     do_debug("read error");

                 }

                 ev.data.fd = fd;

                 ev.events = events[i].events | EPOLLOUT;

                 if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {

                 }

             }

             if (events[i].events & EPOLLOUT) {

                 sprintf_n(buf, buf_len, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World");

                 int nwrite, data_size = strlen(buf);

                 n = data_size;

                 while (n > 0) {

                     nwrite = write(fd, buf + data_size - n, n);

                     if (nwrite < n) {

                         if (nwrite == -1 && errno != EAGAIN) {

                             do_debug("write error");

                         }

                         break;

                     }

                     n -= nwrite;

                 }

                 close(fd);

             }

         }

     }

     return 0;

 }

　　调用connect方法向上游服务器发起TCP连接，作为非阻塞套接字，connect方法可能立刻返回连接建立成功，也可能告诉用户继续等待上游服务器的响应对connect连接是否建立.

　　针对非阻塞I/O执行的系统调用则总是立即返回，而不管事件足否已经发生。如果事件没有眭即发生，这些系统调用就返回—1．和出错的情况一样。此时我们必须根据errno来区分这两种情况。对accept、send和recv而言，事件未发牛时errno通常被设置成EAGAIN（意为“再来一次”）或者EWOULDBLOCK（意为“期待阻塞”）：对conncct而言，errno则被
设置成EINPROGRESS（意为“在处理中"）。connect的时候返回成功后使用的sock就是socket创建的sock，这和服务器端accept成功返回一个新的sock不一样.

rc = connect(s, pc->sockaddr, pc->socklen); //connect返回值可以<linux高性能服务器开发> 9.5节

    if (rc == -1) {

        err = socket_errno;

        if (err != NGX_EINPROGRESS)

        {

            if (err == NGX_ECONNREFUSED

                /*

                 * Linux returns EAGAIN instead of ECONNREFUSED

                 * for unix sockets if listen queue is full

                 */

                || err == EAGAIN

                || err == ECONNRESET

                || err == ENETDOWN

                || err == ENETUNREACH

                || err == EHOSTDOWN

                || err == EHOSTUNREACH)

            {

                do_err();

            } else {

                do_warn();

            }

            return ;

        }

    }

static int do_in_progress(xx *clidata)

{

    clidata->in_progress = 0;

    if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) == 0

        && error == 0) {

        /* success connecting */

        do_process_con_server();

    } else {

        /* failed connecting */

    }

    return 1;

}

connect 链接成功后：fd 应该是可读同时可写。

ssl连接建立--ssl握手

SSL协议是基于TCP、位于应用层、创数层之间，提供数据加密、用户验证和保证数据完整性的一种网络协议；

SSL/TLS 加密方式：

对称加密和非对称加密结合；

 加密算法一般分为两种: '对称加密' 和 '非对称加密'。

 '对称加密': 也叫'密钥加密'，就是指加密和解密使用的是相同的密钥。

 '非对称加密': 也叫'公钥加密'，就是指加密和解密使用的是不同的密钥。

do_ssl_init( )

{

    SSL_library_init();

    SSL_load_error_strings();

    OpenSSL_add_all_algorithms();

}

do_ssl_create(ssl_t *ssl)

{

    ssl->ctx = SSL_CTX_new(SSLv23_method());

}

//server端需要初始化证书与私钥

string cert = "server.pem", key = "server.pem";

r = SSL_CTX_use_certificate_file(g_sslCtx, cert.c_str(), SSL_FILETYPE_PEM);

r = SSL_CTX_use_PrivateKey_file(g_sslCtx, key.c_str(), SSL_FILETYPE_PEM);

r = SSL_CTX_check_private_key(g_sslCtx);

// 使用已建立连接的socket初始化ssl

sc->connection = SSL_new(ssl->ctx);

SSL_set_fd(sc->connection, c->fd)

if (flags & NGX_SSL_CLIENT) {//客户端

        SSL_set_connect_state(sc->connection);

    } else {//服务器端

        SSL_set_accept_state(sc->connection);

}

//epoll_wait后，如果SSL相关的socket有读写事件需要处理则进行SSL握手，直到握手完成

int r = SSL_do_handshake(sc->connection_);

if (r == 1) { // 若返回值为1，则SSL握手已完成

　 process_add_epoll_fd();

　　return;

}

int err = SSL_get_error(sc->connection, r););

if (err == SSL_ERROR_WANT_WRITE) { //SSL需要在非阻塞socket可写时写入数据

    c->events_ |= EPOLLIN; //等待socket可读

　　  c->events_ &= ~EPOLLOUT; //暂时不关注socket可写状态

    c->write->ready = 0;

    c->read->handler = ssl_handshake_handler;

    c->write->handler = ssl_handshake_handler;

    if (ngx_handle_read_event(c->read, 0, NGX_FUNC_LINE) != NGX_OK) {

        return NGX_ERROR;

    }

    if (ngx_handle_write_event(c->write, 0, NGX_FUNC_LINE) != NGX_OK) {

        return NGX_ERROR;

    }

    return NGX_AGAIN; //需要继续握手

} else if (err == SSL_ERROR_WANT_READ) { //SSL需要在非阻塞socket可读时读入数据

　　

    c->events_ |= EPOLLOUT;

　　    c->events_ &= ~EPOLLIN;

    c->read->ready = 0;

    c->read->handler = ssl_handshake_handler;

    c->write->handler = ssl_handshake_handler;

    if (ngx_handle_read_event(c->read, 0, NGX_FUNC_LINE) != NGX_OK) {

        return NGX_ERROR;

     }

     if (ngx_handle_write_event(c->write, 0, NGX_FUNC_LINE) != NGX_OK) {

         return NGX_ERROR;

     }

      return NGX_AGAIN; //需要继续握手

} else { //错误

　　ERR_print_errors(errBio);

}

5. 握手完成后，进行SSL数据的读写

SSL_write(ssl->connection, data, size);

SSL_read(ssl->connection, data, size);

以ngx 为例：

accept new fd 后 ：

ngx_http_init_connection 中调用

    rev->handler = ngx_http_ssl_handshake;

tcp 数据到服务端---ssl开始：

    服务器处理数据---ngx_http_ssl_handshake----> rc = ngx_ssl_handshake(c);;ssl握手

如果握手完成：

//ssl单向认证四次握手完成后执行该handler

                c->ssl->handler = ngx_http_ssl_handshake_handler;

如果握手失败：设置fd 回调函数--- c->read->handler = ngx_ssl_handshake_handler;

// TLS单向认证 协议握手过程参考http://www.ruanyifeng.com/blog/2014/02/ssl_tls.html

//tls单向认证四次握手过程，都会调用该函数处理，返回NGX_AGAIN表示握手还没有完成，需要再次进行后续握手过程

ngx_int_t

ngx_ssl_handshake(ngx_connection_t *c)

{

    int        n, sslerr;

    ngx_err_t  err;

    ngx_ssl_clear_error(c->log);

    //这里会试着握手

    n = SSL_do_handshake(c->ssl->connection); //改函数内部会调用ngx_http_ssl_alpn_select执行

    //0x80:SSLv2  0x16:SSLv3/TLSv1

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_do_handshake: %d", n);

    if (n == 1) { //握手完成

        if (ngx_handle_read_event(c->read, 0, NGX_FUNC_LINE) != NGX_OK) {

            return NGX_ERROR;

        }

        if (ngx_handle_write_event(c->write, 0, NGX_FUNC_LINE) != NGX_OK) {

            return NGX_ERROR;

        }

        return NGX_OK;//握手完成

    }

    sslerr = SSL_get_error(c->ssl->connection, n);

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0, "SSL_get_error: %d", sslerr);

    //这里应该再重新接收一次和NGINX一样,等待下一次循环（epoll）再进行，同时设置读写句柄，以便下次读取的时候直接进行握手

    //单向认证四次握手过程还没有完成，需要继续握手

    if (sslerr == SSL_ERROR_WANT_READ) {  //# define SSL_ERROR_WANT_READ             2

        c->read->ready = 0;

        c->read->handler = ngx_ssl_handshake_handler;

        c->write->handler = ngx_ssl_handshake_handler;

        if (ngx_handle_read_event(c->read, 0, NGX_FUNC_LINE) != NGX_OK) {

            return NGX_ERROR;

        }

        if (ngx_handle_write_event(c->write, 0, NGX_FUNC_LINE) != NGX_OK) {

            return NGX_ERROR;

        }

        return NGX_AGAIN;//需要继续握手

    }

    if (sslerr == SSL_ERROR_WANT_WRITE) {

        c->write->ready = 0;

        c->read->handler = ngx_ssl_handshake_handler;

        c->write->handler = ngx_ssl_handshake_handler;

        if (ngx_handle_read_event(c->read, 0, NGX_FUNC_LINE) != NGX_OK) {

            return NGX_ERROR;

        }

        if (ngx_handle_write_event(c->write, 0, NGX_FUNC_LINE) != NGX_OK) {

            return NGX_ERROR;

        }

        return NGX_AGAIN; //需要继续握手

    }

    return NGX_ERROR; //握手失败

}

巴特西

nginx&http 第五章 https non-fd 读写检测

EPOLL的LT/ET 模式下的读写

ssl连接建立--ssl握手

SSL/TLS 加密方式：

最新文章

热门文章