One Level Up Top Level

src/event/quic/ngx_event_quic_udp.c - nginx source code

Functions defined

Source code


  2. /*
  3. * Copyright (C) Roman Arutyunyan
  4. * Copyright (C) Nginx, Inc.
  5. */


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


  14. static void ngx_quic_close_accepted_connection(ngx_connection_t *c);
  15. static ngx_connection_t *ngx_quic_lookup_connection(ngx_listening_t *ls,
  16.     ngx_str_t *key, struct sockaddr *local_sockaddr, socklen_t local_socklen);


  19. void
  20. ‌ngx_quic_recvmsg(ngx_event_t *ev)
  21. {
  22.     ssize_t             n;
  23.     ngx_str_t           key;
  24.     ngx_buf_t           buf;
  25.     ngx_log_t          *log;
  26.     ngx_err_t           err;
  27.     socklen_t           socklen, local_socklen;
  28.     ngx_event_t        *rev, *wev;
  29.     struct iovec        iov[1];
  30.     struct msghdr       msg;
  31.     ngx_sockaddr_t      sa, lsa;
  32.     struct sockaddr    *sockaddr, *local_sockaddr;
  33.     ngx_listening_t    *ls;
  34.     ngx_event_conf_t   *ecf;
  35.     ngx_connection_t   *c, *lc;
  36.     ngx_quic_socket_t  *qsock;
  37.     static u_char       buffer[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

  39. #if (NGX_HAVE_ADDRINFO_CMSG)
  40.     u_char             msg_control[CMSG_SPACE(sizeof(ngx_addrinfo_t))];
  41. #endif

  43.     if (ev->timedout) {
  44.         if (ngx_enable_accept_events((ngx_cycle_t *) ngx_cycle) != NGX_OK) {
  45.             return;
  46.         }

  48.         ev->timedout = 0;
  49.     }

  51.     ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);

  53.     if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
  54.         ev->available = ecf->multi_accept;
  55.     }

  57.     lc = ev->data;
  58.     ls = lc->listening;
  59.     ev->ready = 0;

  61.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  62.                    "quic recvmsg on %V, ready: %d",
  63.                    &ls->addr_text, ev->available);

  65.     do {
  66.         ngx_memzero(&msg, sizeof(struct msghdr));

  68.         iov[0].iov_base = (void *) buffer;
  69.         iov[0].iov_len = sizeof(buffer);

  71.         msg.msg_name = &sa;
  72.         msg.msg_namelen = sizeof(ngx_sockaddr_t);
  73.         msg.msg_iov = iov;
  74.         msg.msg_iovlen = 1;

  76. #if (NGX_HAVE_ADDRINFO_CMSG)
  77.         if (ls->wildcard) {
  78.             msg.msg_control = &msg_control;
  79.             msg.msg_controllen = sizeof(msg_control);

  81.             ngx_memzero(&msg_control, sizeof(msg_control));
  82.         }
  83. #endif

  85.         n = recvmsg(lc->fd, &msg, 0);

  87.         if (n == -1) {
  88.             err = ngx_socket_errno;

  90.             if (err == NGX_EAGAIN) {
  91.                 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,
  92.                                "quic recvmsg() not ready");
  93.                 return;
  94.             }

  96.             ngx_log_error(NGX_LOG_ALERT, ev->log, err, "quic recvmsg() failed");

  98.             return;
  99.         }

  101. #if (NGX_HAVE_ADDRINFO_CMSG)
  102.         if (msg.msg_flags & (MSG_TRUNC|MSG_CTRUNC)) {
  103.             ngx_log_error(NGX_LOG_ALERT, ev->log, 0,
  104.                           "quic recvmsg() truncated data");
  105.             continue;
  106.         }
  107. #endif

  109.         sockaddr = msg.msg_name;
  110.         socklen = msg.msg_namelen;

  112.         if (socklen > (socklen_t) sizeof(ngx_sockaddr_t)) {
  113.             socklen = sizeof(ngx_sockaddr_t);
  114.         }

  116. #if (NGX_HAVE_UNIX_DOMAIN)

  118.         if (sockaddr->sa_family == AF_UNIX) {
  119.             struct sockaddr_un *saun = (struct sockaddr_un *) sockaddr;

  121.             if (socklen <= (socklen_t) offsetof(struct sockaddr_un, sun_path)
  122.                 || saun->sun_path[0] == '\0')
  123.             {
  124.                 ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ngx_cycle->log, 0,
  125.                                "unbound unix socket");
  126.                 goto next;
  127.             }
  128.         }

  130. #endif

  132.         local_sockaddr = ls->sockaddr;
  133.         local_socklen = ls->socklen;

  135. #if (NGX_HAVE_ADDRINFO_CMSG)

  137.         if (ls->wildcard) {
  138.             struct cmsghdr  *cmsg;

  140.             ngx_memcpy(&lsa, local_sockaddr, local_socklen);
  141.             local_sockaddr = &lsa.sockaddr;

  143.             for (cmsg = CMSG_FIRSTHDR(&msg);
  144.                  cmsg != NULL;
  145.                  cmsg = CMSG_NXTHDR(&msg, cmsg))
  146.             {
  147.                 if (ngx_get_srcaddr_cmsg(cmsg, local_sockaddr) == NGX_OK) {
  148.                     break;
  149.                 }
  150.             }
  151.         }

  153. #endif

  155.         if (ngx_quic_get_packet_dcid(ev->log, buffer, n, &key) != NGX_OK) {
  156.             goto next;
  157.         }

  159.         c = ngx_quic_lookup_connection(ls, &key, local_sockaddr, local_socklen);

  161.         if (c) {

  163. #if (NGX_DEBUG)
  164.             if (c->log->log_level & NGX_LOG_DEBUG_EVENT) {
  165.                 ngx_log_handler_pt  handler;

  167.                 handler = c->log->handler;
  168.                 c->log->handler = NULL;

  170.                 ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  171.                                "quic recvmsg: fd:%d n:%z", c->fd, n);

  173.                 c->log->handler = handler;
  174.             }
  175. #endif

  177.             ngx_memzero(&buf, sizeof(ngx_buf_t));

  179.             buf.pos = buffer;
  180.             buf.last = buffer + n;
  181.             buf.start = buf.pos;
  182.             buf.end = buffer + sizeof(buffer);

  184.             qsock = ngx_quic_get_socket(c);

  186.             ngx_memcpy(&qsock->sockaddr, sockaddr, socklen);
  187.             qsock->socklen = socklen;

  189.             c->udp->buffer = &buf;

  191.             rev = c->read;
  192.             rev->ready = 1;
  193.             rev->active = 0;

  195.             rev->handler(rev);

  197.             if (c->udp) {
  198.                 c->udp->buffer = NULL;
  199.             }

  201.             rev->ready = 0;
  202.             rev->active = 1;

  204.             goto next;
  205.         }

  207. #if (NGX_STAT_STUB)
  208.         (void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
  209. #endif

  211.         ngx_accept_disabled = ngx_cycle->connection_n / 8
  212.                               - ngx_cycle->free_connection_n;

  214.         c = ngx_get_connection(lc->fd, ev->log);
  215.         if (c == NULL) {
  216.             return;
  217.         }

  219.         c->shared = 1;
  220.         c->type = SOCK_DGRAM;
  221.         c->socklen = socklen;

  223. #if (NGX_STAT_STUB)
  224.         (void) ngx_atomic_fetch_add(ngx_stat_active, 1);
  225. #endif

  227.         c->pool = ngx_create_pool(ls->pool_size, ev->log);
  228.         if (c->pool == NULL) {
  229.             ngx_quic_close_accepted_connection(c);
  230.             return;
  231.         }

  233.         c->sockaddr = ngx_palloc(c->pool, NGX_SOCKADDRLEN);
  234.         if (c->sockaddr == NULL) {
  235.             ngx_quic_close_accepted_connection(c);
  236.             return;
  237.         }

  239.         ngx_memcpy(c->sockaddr, sockaddr, socklen);

  241.         log = ngx_palloc(c->pool, sizeof(ngx_log_t));
  242.         if (log == NULL) {
  243.             ngx_quic_close_accepted_connection(c);
  244.             return;
  245.         }

  247.         *log = ls->log;

  249.         c->log = log;
  250.         c->pool->log = log;
  251.         c->listening = ls;

  253.         if (local_sockaddr == &lsa.sockaddr) {
  254.             local_sockaddr = ngx_palloc(c->pool, local_socklen);
  255.             if (local_sockaddr == NULL) {
  256.                 ngx_quic_close_accepted_connection(c);
  257.                 return;
  258.             }

  260.             ngx_memcpy(local_sockaddr, &lsa, local_socklen);
  261.         }

  263.         c->local_sockaddr = local_sockaddr;
  264.         c->local_socklen = local_socklen;

  266.         c->buffer = ngx_create_temp_buf(c->pool, n);
  267.         if (c->buffer == NULL) {
  268.             ngx_quic_close_accepted_connection(c);
  269.             return;
  270.         }

  272.         c->buffer->last = ngx_cpymem(c->buffer->last, buffer, n);

  274.         rev = c->read;
  275.         wev = c->write;

  277.         rev->active = 1;
  278.         wev->ready = 1;

  280.         rev->log = log;
  281.         wev->log = log;

  283.         /*
  284.          * TODO: MT: - ngx_atomic_fetch_add()
  285.          *             or protection by critical section or light mutex
  286.          *
  287.          * TODO: MP: - allocated in a shared memory
  288.          *           - ngx_atomic_fetch_add()
  289.          *             or protection by critical section or light mutex
  290.          */

  292.         c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);

  294.         c->start_time = ngx_current_msec;

  296. #if (NGX_STAT_STUB)
  297.         (void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
  298. #endif

  300.         if (ls->addr_ntop) {
  301.             c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
  302.             if (c->addr_text.data == NULL) {
  303.                 ngx_quic_close_accepted_connection(c);
  304.                 return;
  305.             }

  307.             c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->socklen,
  308.                                              c->addr_text.data,
  309.                                              ls->addr_text_max_len, 0);
  310.             if (c->addr_text.len == 0) {
  311.                 ngx_quic_close_accepted_connection(c);
  312.                 return;
  313.             }
  314.         }

  316. #if (NGX_DEBUG)
  317.         {
  318.         ngx_str_t  addr;
  319.         u_char     text[NGX_SOCKADDR_STRLEN];

  321.         ngx_debug_accepted_connection(ecf, c);

  323.         if (log->log_level & NGX_LOG_DEBUG_EVENT) {
  324.             addr.data = text;
  325.             addr.len = ngx_sock_ntop(c->sockaddr, c->socklen, text,
  326.                                      NGX_SOCKADDR_STRLEN, 1);

  328.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, log, 0,
  329.                            "*%uA quic recvmsg: %V fd:%d n:%z",
  330.                            c->number, &addr, c->fd, n);
  331.         }

  333.         }
  334. #endif

  336.         log->data = NULL;
  337.         log->handler = NULL;

  339.         ls->handler(c);

  341.     next:

  343.         if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  344.             ev->available -= n;
  345.         }

  347.     } while (ev->available);
  348. }


  351. static void
  352. ‌ngx_quic_close_accepted_connection(ngx_connection_t *c)
  353. {
  354.     ngx_free_connection(c);

  356.     c->fd = (ngx_socket_t) -1;

  358.     if (c->pool) {
  359.         ngx_destroy_pool(c->pool);
  360.     }

  362. #if (NGX_STAT_STUB)
  363.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  364. #endif
  365. }


  368. static ngx_connection_t *
  369. ‌ngx_quic_lookup_connection(ngx_listening_t *ls, ngx_str_t *key,
  370.     struct sockaddr *local_sockaddr, socklen_t local_socklen)
  371. {
  372.     uint32_t            hash;
  373.     ngx_int_t           rc;
  374.     ngx_connection_t   *c;
  375.     ngx_rbtree_node_t  *node, *sentinel;
  376.     ngx_quic_socket_t  *qsock;

  378.     if (key->len == 0) {
  379.         return NULL;
  380.     }

  382.     node = ls->rbtree.root;
  383.     sentinel = ls->rbtree.sentinel;
  384.     hash = ngx_crc32_long(key->data, key->len);

  386.     while (node != sentinel) {

  388.         if (hash < node->key) {
  389.             node = node->left;
  390.             continue;
  391.         }

  393.         if (hash > node->key) {
  394.             node = node->right;
  395.             continue;
  396.         }

  398.         /* hash == node->key */

  400.         qsock = (ngx_quic_socket_t *) node;

  402.         rc = ngx_memn2cmp(key->data, qsock->sid.id, key->len, qsock->sid.len);

  404.         c = qsock->udp.connection;

  406.         if (rc == 0 && ls->wildcard) {
  407.             rc = ngx_cmp_sockaddr(local_sockaddr, local_socklen,
  408.                                   c->local_sockaddr, c->local_socklen, 1);
  409.         }

  411.         if (rc == 0) {
  412.             c->udp = &qsock->udp;
  413.             return c;
  414.         }

  416.         node = (rc < 0) ? node->left : node->right;
  417.     }

  419.     return NULL;
  420. }

One Level Up Top Level