从一个非阻塞的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);&nbsp;//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返回值可以 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、位于应用层、创数层之间，提供数据加密、用户验证和保证数据完整性的一种网络协议；

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

 加密算法一般分为两种: '对称加密' 和 '非对称加密'。
 '对称加密': 也叫'密钥加密'，就是指加密和解密使用的是相同的密钥。
 '非对称加密': 也叫'公钥加密'，就是指加密和解密使用的是不同的密钥。

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; //握手失败  

}