One Level Up Top Level

src/os/unix/ngx_channel.c - nginx-1.31.7 nginx/ @ 939334eff

Data types defined

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_channel.h>


  13. ngx_int_t
  14. ‌ngx_write_channel(ngx_socket_t s, ngx_channel_t *ch, size_t size,
  15.     ngx_log_t *log)
  16. {
  17.     ssize_t             n;
  18.     ngx_err_t           err;
  19.     struct iovec        iov[1];
  20.     struct msghdr       msg;

  22. #if (NGX_HAVE_MSGHDR_MSG_CONTROL)

  24. ‌    union {
  25.         struct cmsghdr  cm;
  26.         char            space[CMSG_SPACE(sizeof(int))];
  27.     } cmsg;

  29.     if (ch->fd == -1) {
  30.         msg.msg_control = NULL;
  31.         msg.msg_controllen = 0;

  33.     } else {
  34.         msg.msg_control = (caddr_t) &cmsg;
  35.         msg.msg_controllen = sizeof(cmsg);

  37.         ngx_memzero(&cmsg, sizeof(cmsg));

  39.         cmsg.cm.cmsg_len = CMSG_LEN(sizeof(int));
  40.         cmsg.cm.cmsg_level = SOL_SOCKET;
  41.         cmsg.cm.cmsg_type = SCM_RIGHTS;

  43.         /*
  44.          * We have to use ngx_memcpy() instead of simple
  45.          *   *(int *) CMSG_DATA(&cmsg.cm) = ch->fd;
  46.          * because some gcc 4.4 with -O2/3/s optimization issues the warning:
  47.          *   dereferencing type-punned pointer will break strict-aliasing rules
  48.          *
  49.          * Fortunately, gcc with -O1 compiles this ngx_memcpy()
  50.          * in the same simple assignment as in the code above
  51.          */

  53.         ngx_memcpy(CMSG_DATA(&cmsg.cm), &ch->fd, sizeof(int));
  54.     }

  56.     msg.msg_flags = 0;

  58. #else

  60.     if (ch->fd == -1) {
  61.         msg.msg_accrights = NULL;
  62.         msg.msg_accrightslen = 0;

  64.     } else {
  65.         msg.msg_accrights = (caddr_t) &ch->fd;
  66.         msg.msg_accrightslen = sizeof(int);
  67.     }

  69. #endif

  71.     iov[0].iov_base = (char *) ch;
  72.     iov[0].iov_len = size;

  74.     msg.msg_name = NULL;
  75.     msg.msg_namelen = 0;
  76.     msg.msg_iov = iov;
  77.     msg.msg_iovlen = 1;

  79.     n = sendmsg(s, &msg, 0);

  81.     if (n == -1) {
  82.         err = ngx_errno;
  83.         if (err == NGX_EAGAIN) {
  84.             return NGX_AGAIN;
  85.         }

  87.         ngx_log_error(NGX_LOG_ALERT, log, err, "sendmsg() failed");
  88.         return NGX_ERROR;
  89.     }

  91.     return NGX_OK;
  92. }


  95. ngx_int_t
  96. ‌ngx_read_channel(ngx_socket_t s, ngx_channel_t *ch, size_t size, ngx_log_t *log)
  97. {
  98.     ssize_t             n;
  99.     ngx_err_t           err;
  100.     struct iovec        iov[1];
  101.     struct msghdr       msg;

  103. #if (NGX_HAVE_MSGHDR_MSG_CONTROL)
  104. ‌    union {
  105.         struct cmsghdr  cm;
  106.         char            space[CMSG_SPACE(sizeof(int))];
  107.     } cmsg;
  108. #else
  109.     int                 fd;
  110. #endif

  112.     iov[0].iov_base = (char *) ch;
  113.     iov[0].iov_len = size;

  115.     msg.msg_name = NULL;
  116.     msg.msg_namelen = 0;
  117.     msg.msg_iov = iov;
  118.     msg.msg_iovlen = 1;

  120. #if (NGX_HAVE_MSGHDR_MSG_CONTROL)
  121.     msg.msg_control = (caddr_t) &cmsg;
  122.     msg.msg_controllen = sizeof(cmsg);
  123. #else
  124.     msg.msg_accrights = (caddr_t) &fd;
  125.     msg.msg_accrightslen = sizeof(int);
  126. #endif

  128.     n = recvmsg(s, &msg, 0);

  130.     if (n == -1) {
  131.         err = ngx_errno;
  132.         if (err == NGX_EAGAIN) {
  133.             return NGX_AGAIN;
  134.         }

  136.         ngx_log_error(NGX_LOG_ALERT, log, err, "recvmsg() failed");

  138.         if (err == NGX_EMSGSIZE || err == NGX_EMFILE) {
  139.             /* file descriptor table is full */
  140.             ngx_memzero(ch, size);
  141.             return 0;
  142.         }

  144.         return NGX_ERROR;
  145.     }

  147.     if (n == 0) {
  148.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, 0, "recvmsg() returned zero");
  149.         return NGX_ERROR;
  150.     }

  152.     if ((size_t) n < sizeof(ngx_channel_t)) {
  153.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  154.                       "recvmsg() returned not enough data: %z", n);
  155.         return NGX_ERROR;
  156.     }

  158. #if (NGX_HAVE_MSGHDR_MSG_CONTROL)

  160.     if (ch->command == NGX_CMD_OPEN_CHANNEL) {

  162.         if (msg.msg_controllen < (socklen_t) CMSG_LEN(sizeof(int))) {
  163.             ngx_log_error(NGX_LOG_ALERT, log, 0,
  164.                           "recvmsg() returned too small ancillary data");
  165.             ch->fd = -1;

  167.         } else if (cmsg.cm.cmsg_level != SOL_SOCKET
  168.                    || cmsg.cm.cmsg_type != SCM_RIGHTS)
  169.         {
  170.             ngx_log_error(NGX_LOG_ALERT, log, 0,
  171.                           "recvmsg() returned invalid ancillary data "
  172.                           "level %d or type %d",
  173.                           cmsg.cm.cmsg_level, cmsg.cm.cmsg_type);
  174.             return NGX_ERROR;

  176.         } else {

  178.             /* ch->fd = *(int *) CMSG_DATA(&cmsg.cm); */

  180.             ngx_memcpy(&ch->fd, CMSG_DATA(&cmsg.cm), sizeof(int));
  181.         }
  182.     }

  184.     if (msg.msg_flags & MSG_TRUNC) {
  185.         ngx_log_error(NGX_LOG_ALERT, log, 0,
  186.                       "recvmsg() truncated data");
  187.     }

  189. #else

  191.     if (ch->command == NGX_CMD_OPEN_CHANNEL) {
  192.         if (msg.msg_accrightslen != sizeof(int)) {
  193.             ngx_log_error(NGX_LOG_ALERT, log, 0,
  194.                           "recvmsg() returned no ancillary data");
  195.             ch->fd = -1;

  197.         } else {
  198.             ch->fd = fd;
  199.         }
  200.     }

  202. #endif

  204.     return n;
  205. }


  208. ngx_int_t
  209. ‌ngx_add_channel_event(ngx_cycle_t *cycle, ngx_fd_t fd, ngx_int_t event,
  210.     ngx_event_handler_pt handler)
  211. {
  212.     ngx_event_t       *ev, *rev, *wev;
  213.     ngx_connection_t  *c;

  215.     c = ngx_get_connection(fd, cycle->log);

  217.     if (c == NULL) {
  218.         return NGX_ERROR;
  219.     }

  221.     c->pool = cycle->pool;

  223.     rev = c->read;
  224.     wev = c->write;

  226.     rev->log = cycle->log;
  227.     wev->log = cycle->log;

  229.     rev->channel = 1;
  230.     wev->channel = 1;

  232.     ev = (event == NGX_READ_EVENT) ? rev : wev;

  234.     ev->handler = handler;

  236.     if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {
  237.         if (ngx_add_conn(c) == NGX_ERROR) {
  238.             ngx_free_connection(c);
  239.             return NGX_ERROR;
  240.         }

  242.     } else {
  243.         if (ngx_add_event(ev, event, 0) == NGX_ERROR) {
  244.             ngx_free_connection(c);
  245.             return NGX_ERROR;
  246.         }
  247.     }

  249.     return NGX_OK;
  250. }


  253. void
  254. ‌ngx_close_channel(ngx_fd_t *fd, ngx_log_t *log)
  255. {
  256.     if (close(fd[0]) == -1) {
  257.         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "close() channel failed");
  258.     }

  260.     if (close(fd[1]) == -1) {
  261.         ngx_log_error(NGX_LOG_ALERT, log, ngx_errno, "close() channel failed");
  262.     }
  263. }

One Level Up Top Level