One Level Up Top Level

src/os/unix/ngx_recv.c - nginx-1.7.10

Functions defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_event.h>


  13. #if (NGX_HAVE_KQUEUE)

  15. ssize_t
  16. ‌ngx_unix_recv(ngx_connection_t *c, u_char *buf, size_t size)
  17. {
  18.     ssize_t       n;
  19.     ngx_err_t     err;
  20.     ngx_event_t  *rev;

  22.     rev = c->read;

  24.     if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  25.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  26.                        "recv: eof:%d, avail:%d, err:%d",
  27.                        rev->pending_eof, rev->available, rev->kq_errno);

  29.         if (rev->available == 0) {
  30.             if (rev->pending_eof) {
  31.                 rev->ready = 0;
  32.                 rev->eof = 1;

  34.                 if (rev->kq_errno) {
  35.                     rev->error = 1;
  36.                     ngx_set_socket_errno(rev->kq_errno);

  38.                     return ngx_connection_error(c, rev->kq_errno,
  39.                                "kevent() reported about an closed connection");
  40.                 }

  42.                 return 0;

  44.             } else {
  45.                 rev->ready = 0;
  46.                 return NGX_AGAIN;
  47.             }
  48.         }
  49.     }

  51.     do {
  52.         n = recv(c->fd, buf, size, 0);

  54.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  55.                        "recv: fd:%d %d of %d", c->fd, n, size);

  57.         if (n >= 0) {
  58.             if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  59.                 rev->available -= n;

  61.                 /*
  62.                  * rev->available may be negative here because some additional
  63.                  * bytes may be received between kevent() and recv()
  64.                  */

  66.                 if (rev->available <= 0) {
  67.                     if (!rev->pending_eof) {
  68.                         rev->ready = 0;
  69.                     }

  71.                     if (rev->available < 0) {
  72.                         rev->available = 0;
  73.                     }
  74.                 }

  76.                 if (n == 0) {

  78.                     /*
  79.                      * on FreeBSD recv() may return 0 on closed socket
  80.                      * even if kqueue reported about available data
  81.                      */

  83.                     rev->ready = 0;
  84.                     rev->eof = 1;
  85.                     rev->available = 0;
  86.                 }

  88.                 return n;
  89.             }

  91.             if ((size_t) n < size
  92.                 && !(ngx_event_flags & NGX_USE_GREEDY_EVENT))
  93.             {
  94.                 rev->ready = 0;
  95.             }

  97.             if (n == 0) {
  98.                 rev->eof = 1;
  99.             }

  101.             return n;
  102.         }

  104.         err = ngx_socket_errno;

  106.         if (err == NGX_EAGAIN || err == NGX_EINTR) {
  107.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  108.                            "recv() not ready");
  109.             n = NGX_AGAIN;

  111.         } else {
  112.             n = ngx_connection_error(c, err, "recv() failed");
  113.             break;
  114.         }

  116.     } while (err == NGX_EINTR);

  118.     rev->ready = 0;

  120.     if (n == NGX_ERROR) {
  121.         rev->error = 1;
  122.     }

  124.     return n;
  125. }

  127. #else /* ! NGX_HAVE_KQUEUE */

  129. ssize_t
  130. ‌ngx_unix_recv(ngx_connection_t *c, u_char *buf, size_t size)
  131. {
  132.     ssize_t       n;
  133.     ngx_err_t     err;
  134.     ngx_event_t  *rev;

  136.     rev = c->read;

  138.     do {
  139.         n = recv(c->fd, buf, size, 0);

  141.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  142.                        "recv: fd:%d %d of %d", c->fd, n, size);

  144.         if (n == 0) {
  145.             rev->ready = 0;
  146.             rev->eof = 1;
  147.             return n;

  149.         } else if (n > 0) {

  151.             if ((size_t) n < size
  152.                 && !(ngx_event_flags & NGX_USE_GREEDY_EVENT))
  153.             {
  154.                 rev->ready = 0;
  155.             }

  157.             return n;
  158.         }

  160.         err = ngx_socket_errno;

  162.         if (err == NGX_EAGAIN || err == NGX_EINTR) {
  163.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, err,
  164.                            "recv() not ready");
  165.             n = NGX_AGAIN;

  167.         } else {
  168.             n = ngx_connection_error(c, err, "recv() failed");
  169.             break;
  170.         }

  172.     } while (err == NGX_EINTR);

  174.     rev->ready = 0;

  176.     if (n == NGX_ERROR) {
  177.         rev->error = 1;
  178.     }

  180.     return n;
  181. }

  183. #endif /* NGX_HAVE_KQUEUE */

One Level Up Top Level