shutdown & close

shutdown可以分别关闭读写或者同时关闭读写
如果关闭读，则接受缓冲区的未读出的所有数据都将丢失，以后不会再接受任何数据
如果关闭写，如果输出缓冲区内有数据，则所有的数据将发送出去后将发送一个FIN信号

而close则是关闭该socket，马上发送FIN信号，所有的未完成发送或者接受的数据都将被丢失

对于慢速网络，应该先进行shutdown，然后一定的时间延迟，再close该socket.

(在你已经发送成功后，而对方如果没有接受完毕，你此时如果关闭socket则对方将收到FIN信号，将不能在接收数据，因此容易出现数据丢失的问题，这是我以前写聊天室时遇到的一个错误，客户端经常报一个与服务器的连接被重置，后来加了一个时间延迟就好了)

 

#include<sys/socket.h>

int shutdown(int sockfd,int how);

how的方式有三种分别是

SHUT_RD（0）：关闭sockfd上的读功能，此选项将不允许sockfd进行读操作。

SHUT_WR（1）：关闭sockfd的写功能，此选项将不允许sockfd进行写操作。

SHUT_RDWR（2）：关闭sockfd的读写功能。

成功则返回0，错误返回-1，错误码errno：EBADF表示sockfd不是一个有效描述符；ENOTCONN表示sockfd未连接；ENOTSOCK表示sockfd是一个文件描述符而不是socket描述符。

close的定义如下：

#include<unistd.h>

int close(int fd);

关闭读写。

成功则返回0，错误返回-1，错误码errno：EBADF表示fd不是一个有效描述符；EINTR表示close函数被信号中断；EIO表示一个IO错误。

下面摘用网上的一段话来说明二者的区别：

close-----关闭本进程的socket id，但链接还是开着的，用这个socket id的其它进程还能用这个链接，能读或写这个socket id

shutdown--则破坏了socket 链接，读的时候可能侦探到EOF结束符，写的时候可能会收到一个SIGPIPE信号.

-------

1>. 如果有多个进程共享一个套接字，close每被调用一次，计数减1，直到计数为0时，也就是所用进程都调用了close，套接字将被释放。
2>. 在多进程中如果一个进程中shutdown(sfd, SHUT_RDWR)后其它的进程将无法进行通信. 如果一个进程close(sfd)将不会影响到其它进程

 

 

 

lighttpd中对出错或传输完时，先shutdown写端，然后再定时器中再close掉。回收该slot(设置状态为CON_STATE_CONNECT，即等待连接）

if ((0 == shutdown(con->fd, SHUT_WR))) {
                    con->close_timeout_ts = srv->cur_ts;
                    connection_set_state(srv, con, CON_STATE_CLOSE);
                } else {
                    connection_close(srv, con);
                }

在main中, HTTP_LINGER_TIMEOUT==5

if (con->state == CON_STATE_CLOSE && (srv->cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT)) {changed = 1;}/* we don't like div by zero */if (0 == (t_diff = srv->cur_ts - con->connection_start)) t_diff = 1;if (con->traffic_limit_reached && (con->conf.kbytes_per_second == 0 || ((con->bytes_written / t_diff) < con->conf.kbytes_per_second * 1024))) {/* enable connection again */con->traffic_limit_reached = 0;changed = 1;}if (changed) {connection_state_machine(srv, con);}

 

case CON_STATE_CLOSE:if (srv->srvconf.log_state_handling) {log_error_write(srv, __FILE__, __LINE__, "sds","state for fd", con->fd, connection_get_state(con->state));}/* we have to do the linger_on_close stuff regardless * of con->keep_alive; even non-keepalive sockets may * still have unread data, and closing before reading * it will make the client not see all our output. */{int len;char buf[1024];len = read(con->fd, buf, sizeof(buf));if (len == 0 || (len < 0 && errno != EAGAIN && errno != EINTR) ) {con->close_timeout_ts = srv->cur_ts - (HTTP_LINGER_TIMEOUT+1);}}if (srv->cur_ts - con->close_timeout_ts > HTTP_LINGER_TIMEOUT) {connection_close(srv, con);if (srv->srvconf.log_state_handling) {log_error_write(srv, __FILE__, __LINE__, "sd","connection closed for fd", con->fd);}}break;

 

  case conn_listening:
            addrlen = sizeof(addr);
            if ((sfd = accept(c->sfd, (struct sockaddr *)&addr, &addrlen)) == -1) {
                if (errno == EAGAIN || errno == EWOULDBLOCK) {
                    /* these are transient, so don't log anything */
                    stop = true;
                } else if (errno == EMFILE) {
                    if (settings.verbose > 0)
                        fprintf(stderr, "Too many open connections/n");
                    accept_new_conns(false);
                    stop = true;
                } else {
                    perror("accept()");
                    stop = true;
                }
                break;
            }
            if ((flags = fcntl(sfd, F_GETFL, 0)) < 0 ||
                fcntl(sfd, F_SETFL, flags | O_NONBLOCK) < 0) {
                perror("setting O_NONBLOCK");
                close(sfd);
                break;
            }

            dispatch_conn_new(sfd, conn_new_cmd, EV_READ | EV_PERSIST,
                                     DATA_BUFFER_SIZE, tcp_transport);
            stop = true;
            break;
case conn_nread:
            if (c->rlbytes == 0) {
                complete_nread(c);
                break;
            }
            /* first check if we have leftovers in the conn_read buffer */
            if (c->rbytes > 0) {
                int tocopy = c->rbytes > c->rlbytes ? c->rlbytes : c->rbytes;
                if (c->ritem != c->rcurr) {
                    memmove(c->ritem, c->rcurr, tocopy);
                }
                c->ritem += tocopy;
                c->rlbytes -= tocopy;
                c->rcurr += tocopy;
                c->rbytes -= tocopy;
                if (c->rlbytes == 0) {
                    break;
                }
            }

            /*  now try reading from the socket */
            res = read(c->sfd, c->ritem, c->rlbytes);
            if (res > 0) {
                pthread_mutex_lock(&c->thread->stats.mutex);
                c->thread->stats.bytes_read += res;
                pthread_mutex_unlock(&c->thread->stats.mutex);
                if (c->rcurr == c->ritem) {
                    c->rcurr += res;
                }
                c->ritem += res;
                c->rlbytes -= res;
                break;
            }
            if (res == 0) { /* end of stream */
                conn_set_state(c, conn_closing);
                break;
            }
            if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
                if (!update_event(c, EV_READ | EV_PERSIST)) {
                    if (settings.verbose > 0)
                        fprintf(stderr, "Couldn't update event/n");
                    conn_set_state(c, conn_closing);
                    break;
                }
                stop = true;
                break;
            }

 

static enum transmit_result transmit(conn *c) {
    assert(c != NULL);

    if (c->msgcurr < c->msgused &&
            c->msglist[c->msgcurr].msg_iovlen == 0) {
        /* Finished writing the current msg; advance to the next. */
        c->msgcurr++;
    }
    if (c->msgcurr < c->msgused) {
        ssize_t res;
        struct msghdr *m = &c->msglist[c->msgcurr];

        res = sendmsg(c->sfd, m, 0);
        if (res > 0) {
            pthread_mutex_lock(&c->thread->stats.mutex);
            c->thread->stats.bytes_written += res;
            pthread_mutex_unlock(&c->thread->stats.mutex);

            /* We've written some of the data. Remove the completed
               iovec entries from the list of pending writes. */
            while (m->msg_iovlen > 0 && res >= m->msg_iov->iov_len) {
                res -= m->msg_iov->iov_len;
                m->msg_iovlen--;
                m->msg_iov++;
            }

            /* Might have written just part of the last iovec entry;
               adjust it so the next write will do the rest. */
            if (res > 0) {
                m->msg_iov->iov_base = (caddr_t)m->msg_iov->iov_base + res;
                m->msg_iov->iov_len -= res;
            }
            return TRANSMIT_INCOMPLETE;
        }
        if (res == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
            if (!update_event(c, EV_WRITE | EV_PERSIST)) {
                if (settings.verbose > 0)
                    fprintf(stderr, "Couldn't update event/n");
                conn_set_state(c, conn_closing);
                return TRANSMIT_HARD_ERROR;
            }
            return TRANSMIT_SOFT_ERROR;
        }
        /* if res == 0 or res == -1 and error is not EAGAIN or EWOULDBLOCK,
           we have a real error, on which we close the connection */
        if (settings.verbose > 0)
            perror("Failed to write, and not due to blocking");

        if (IS_UDP(c->transport))
            conn_set_state(c, conn_read);
        else
            conn_set_state(c, conn_closing);
        return TRANSMIT_HARD_ERROR;
    } else {
        return TRANSMIT_COMPLETE;
    }
}