One Level Up Top Level

src/event/quic/ngx_event_quic_udp.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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.     ngx_socket_t        cfd;
  30.     struct iovec        iov[1];
  31.     struct msghdr       msg;
  32.     ngx_sockaddr_t      sa, lsa;
  33.     struct sockaddr    *sockaddr, *local_sockaddr;
  34.     ngx_listening_t    *ls;
  35.     ngx_event_conf_t   *ecf;
  36.     ngx_connection_t   *c, *lc;
  37.     ngx_quic_socket_t  *qsock;
  38.     static u_char       buffer[NGX_QUIC_MAX_UDP_PAYLOAD_SIZE];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  99.             return;
  100.         }

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

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

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

  117. #if (NGX_HAVE_UNIX_DOMAIN)

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

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

  131. #endif

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

  136. #if (NGX_HAVE_ADDRINFO_CMSG)

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

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

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

  154. #endif

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

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

  162.         if (c) {

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

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

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

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

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

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

  185.             qsock = ngx_quic_get_socket(c);

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

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

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

  196.             rev->handler(rev);

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

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

  205.             goto next;
  206.         }

  208. #if (NGX_QUIC_BPF)
  209.         if (lc->read->quic) {
  210.             ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  211.                            "quic new connection on worker socket, dropped");
  212.             goto next;
  213.         }
  214. #endif

  216. #if (NGX_STAT_STUB)
  217.         (void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
  218. #endif

  220.         ngx_accept_disabled = ngx_cycle->connection_n / 8
  221.                               - ngx_cycle->free_connection_n;

  223.         cfd = lc->fd;

  225. #if (NGX_QUIC_BPF)
  226.         if (ngx_quic_bpf_get_worker_fd(lc, &cfd) != NGX_OK) {
  227.             return;
  228.         }
  229. #endif

  231.         c = ngx_get_connection(cfd, ev->log);
  232.         if (c == NULL) {
  233.             return;
  234.         }

  236.         c->shared = 1;
  237.         c->type = SOCK_DGRAM;
  238.         c->socklen = socklen;

  240. #if (NGX_STAT_STUB)
  241.         (void) ngx_atomic_fetch_add(ngx_stat_active, 1);
  242. #endif

  244.         c->pool = ngx_create_pool(ls->pool_size, ev->log);
  245.         if (c->pool == NULL) {
  246.             ngx_quic_close_accepted_connection(c);
  247.             return;
  248.         }

  250.         c->sockaddr = ngx_palloc(c->pool, NGX_SOCKADDRLEN);
  251.         if (c->sockaddr == NULL) {
  252.             ngx_quic_close_accepted_connection(c);
  253.             return;
  254.         }

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

  258.         log = ngx_palloc(c->pool, sizeof(ngx_log_t));
  259.         if (log == NULL) {
  260.             ngx_quic_close_accepted_connection(c);
  261.             return;
  262.         }

  264.         *log = ls->log;

  266.         c->log = log;
  267.         c->pool->log = log;
  268.         c->listening = ls;

  270.         if (local_sockaddr == &lsa.sockaddr) {
  271.             local_sockaddr = ngx_palloc(c->pool, local_socklen);
  272.             if (local_sockaddr == NULL) {
  273.                 ngx_quic_close_accepted_connection(c);
  274.                 return;
  275.             }

  277.             ngx_memcpy(local_sockaddr, &lsa, local_socklen);
  278.         }

  280.         c->local_sockaddr = local_sockaddr;
  281.         c->local_socklen = local_socklen;

  283.         c->buffer = ngx_create_temp_buf(c->pool, n);
  284.         if (c->buffer == NULL) {
  285.             ngx_quic_close_accepted_connection(c);
  286.             return;
  287.         }

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

  291.         rev = c->read;
  292.         wev = c->write;

  294.         rev->active = 1;
  295.         wev->ready = 1;

  297.         rev->log = log;
  298.         wev->log = log;

  300.         /*
  301.          * TODO: MT: - ngx_atomic_fetch_add()
  302.          *             or protection by critical section or light mutex
  303.          *
  304.          * TODO: MP: - allocated in a shared memory
  305.          *           - ngx_atomic_fetch_add()
  306.          *             or protection by critical section or light mutex
  307.          */

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

  311.         c->start_time = ngx_current_msec;

  313. #if (NGX_STAT_STUB)
  314.         (void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
  315. #endif

  317.         if (ls->addr_ntop) {
  318.             c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
  319.             if (c->addr_text.data == NULL) {
  320.                 ngx_quic_close_accepted_connection(c);
  321.                 return;
  322.             }

  324.             c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->socklen,
  325.                                              c->addr_text.data,
  326.                                              ls->addr_text_max_len, 0);
  327.             if (c->addr_text.len == 0) {
  328.                 ngx_quic_close_accepted_connection(c);
  329.                 return;
  330.             }
  331.         }

  333. #if (NGX_DEBUG)
  334.         {
  335.         ngx_str_t  addr;
  336.         u_char     text[NGX_SOCKADDR_STRLEN];

  338.         ngx_debug_accepted_connection(ecf, c);

  340.         if (log->log_level & NGX_LOG_DEBUG_EVENT) {
  341.             addr.data = text;
  342.             addr.len = ngx_sock_ntop(c->sockaddr, c->socklen, text,
  343.                                      NGX_SOCKADDR_STRLEN, 1);

  345.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, log, 0,
  346.                            "*%uA quic recvmsg: %V fd:%d n:%z",
  347.                            c->number, &addr, lc->fd, n);
  348.         }

  350.         }
  351. #endif

  353.         log->data = NULL;
  354.         log->handler = NULL;

  356.         ls->handler(c);

  358.     next:

  360.         if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
  361.             ev->available -= n;
  362.         }

  364.     } while (ev->available);
  365. }


  368. static void
  369. ‌ngx_quic_close_accepted_connection(ngx_connection_t *c)
  370. {
  371.     ngx_free_connection(c);

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

  375.     if (c->pool) {
  376.         ngx_destroy_pool(c->pool);
  377.     }

  379. #if (NGX_STAT_STUB)
  380.     (void) ngx_atomic_fetch_add(ngx_stat_active, -1);
  381. #endif
  382. }


  385. static ngx_connection_t *
  386. ‌ngx_quic_lookup_connection(ngx_listening_t *ls, ngx_str_t *key,
  387.     struct sockaddr *local_sockaddr, socklen_t local_socklen)
  388. {
  389.     uint32_t            hash;
  390.     ngx_int_t           rc;
  391.     ngx_connection_t   *c;
  392.     ngx_rbtree_node_t  *node, *sentinel;
  393.     ngx_quic_socket_t  *qsock;

  395.     if (key->len == 0) {
  396.         return NULL;
  397.     }

  399.     node = ls->rbtree.root;
  400.     sentinel = ls->rbtree.sentinel;
  401.     hash = ngx_crc32_long(key->data, key->len);

  403.     while (node != sentinel) {

  405.         if (hash < node->key) {
  406.             node = node->left;
  407.             continue;
  408.         }

  410.         if (hash > node->key) {
  411.             node = node->right;
  412.             continue;
  413.         }

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

  417.         qsock = (ngx_quic_socket_t *) node;

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

  421.         c = qsock->udp.connection;

  423.         if (rc == 0 && ls->wildcard) {
  424.             rc = ngx_cmp_sockaddr(local_sockaddr, local_socklen,
  425.                                   c->local_sockaddr, c->local_socklen, 1);
  426.         }

  428.         if (rc == 0) {
  429.             c->udp = &qsock->udp;
  430.             return c;
  431.         }

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

  436.     return NULL;
  437. }

One Level Up Top Level