One Level Up Top Level

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

Functions defined

Source code


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


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


  13. ngx_int_t
  14. ‌ngx_quic_open_sockets(ngx_connection_t *c, ngx_quic_connection_t *qc,
  15.     ngx_quic_header_t *pkt)
  16. {
  17.     ngx_quic_socket_t     *qsock, *tmp;
  18.     ngx_quic_client_id_t  *cid;

  20.     /*
  21.      * qc->path = NULL
  22.      *
  23.      * qc->nclient_ids = 0
  24.      * qc->nsockets = 0
  25.      * qc->max_retired_seqnum = 0
  26.      * qc->client_seqnum = 0
  27.      */

  29.     ngx_queue_init(&qc->sockets);
  30.     ngx_queue_init(&qc->free_sockets);

  32.     ngx_queue_init(&qc->paths);
  33.     ngx_queue_init(&qc->free_paths);

  35.     ngx_queue_init(&qc->client_ids);
  36.     ngx_queue_init(&qc->free_client_ids);

  38.     qc->tp.original_dcid.len = pkt->odcid.len;
  39.     qc->tp.original_dcid.data = ngx_pstrdup(c->pool, &pkt->odcid);
  40.     if (qc->tp.original_dcid.data == NULL) {
  41.         return NGX_ERROR;
  42.     }

  44.     /* socket to use for further processing (id auto-generated) */
  45.     qsock = ngx_quic_create_socket(c, qc);
  46.     if (qsock == NULL) {
  47.         return NGX_ERROR;
  48.     }

  50.     /* socket is listening at new server id */
  51.     if (ngx_quic_listen(c, qc, qsock) != NGX_OK) {
  52.         return NGX_ERROR;
  53.     }

  55.     qsock->used = 1;

  57.     qc->tp.initial_scid.len = qsock->sid.len;
  58.     qc->tp.initial_scid.data = ngx_pnalloc(c->pool, qsock->sid.len);
  59.     if (qc->tp.initial_scid.data == NULL) {
  60.         goto failed;
  61.     }
  62.     ngx_memcpy(qc->tp.initial_scid.data, qsock->sid.id, qsock->sid.len);

  64.     /* for all packets except first, this is set at udp layer */
  65.     c->udp = &qsock->udp;

  67.     /* ngx_quic_get_connection(c) macro is now usable */

  69.     /* we have a client identified by scid */
  70.     cid = ngx_quic_create_client_id(c, &pkt->scid, 0, NULL);
  71.     if (cid == NULL) {
  72.         goto failed;
  73.     }

  75.     /* path of the first packet is our initial active path */
  76.     qc->path = ngx_quic_new_path(c, c->sockaddr, c->socklen, cid);
  77.     if (qc->path == NULL) {
  78.         goto failed;
  79.     }

  81.     qc->path->tag = NGX_QUIC_PATH_ACTIVE;

  83.     if (pkt->validated) {
  84.         qc->path->validated = 1;
  85.     }

  87.     ngx_quic_path_dbg(c, "set active", qc->path);

  89.     tmp = ngx_pcalloc(c->pool, sizeof(ngx_quic_socket_t));
  90.     if (tmp == NULL) {
  91.         goto failed;
  92.     }

  94.     tmp->sid.seqnum = NGX_QUIC_UNSET_PN; /* temporary socket */

  96.     ngx_memcpy(tmp->sid.id, pkt->dcid.data, pkt->dcid.len);
  97.     tmp->sid.len = pkt->dcid.len;

  99.     if (ngx_quic_listen(c, qc, tmp) != NGX_OK) {
  100.         goto failed;
  101.     }

  103.     return NGX_OK;

  105. failed:

  107.     ngx_rbtree_delete(&c->listening->rbtree, &qsock->udp.node);
  108.     c->udp = NULL;

  110.     return NGX_ERROR;
  111. }


  114. ngx_quic_socket_t *
  115. ‌ngx_quic_create_socket(ngx_connection_t *c, ngx_quic_connection_t *qc)
  116. {
  117.     ngx_queue_t        *q;
  118.     ngx_quic_socket_t  *sock;

  120.     if (!ngx_queue_empty(&qc->free_sockets)) {

  122.         q = ngx_queue_head(&qc->free_sockets);
  123.         sock = ngx_queue_data(q, ngx_quic_socket_t, queue);

  125.         ngx_queue_remove(&sock->queue);

  127.         ngx_memzero(sock, sizeof(ngx_quic_socket_t));

  129.     } else {

  131.         sock = ngx_pcalloc(c->pool, sizeof(ngx_quic_socket_t));
  132.         if (sock == NULL) {
  133.             return NULL;
  134.         }
  135.     }

  137.     sock->sid.len = NGX_QUIC_SERVER_CID_LEN;
  138.     if (ngx_quic_create_server_id(c, sock->sid.id) != NGX_OK) {
  139.         return NULL;
  140.     }

  142.     sock->sid.seqnum = qc->server_seqnum++;

  144.     return sock;
  145. }


  148. void
  149. ‌ngx_quic_close_socket(ngx_connection_t *c, ngx_quic_socket_t *qsock)
  150. {
  151.     ngx_quic_connection_t  *qc;

  153.     qc = ngx_quic_get_connection(c);

  155.     ngx_queue_remove(&qsock->queue);
  156.     ngx_queue_insert_head(&qc->free_sockets, &qsock->queue);

  158.     ngx_rbtree_delete(&c->listening->rbtree, &qsock->udp.node);
  159.     qc->nsockets--;

  161.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
  162.                    "quic socket seq:%L closed nsock:%ui",
  163.                    (int64_t) qsock->sid.seqnum, qc->nsockets);
  164. }


  167. ngx_int_t
  168. ‌ngx_quic_listen(ngx_connection_t *c, ngx_quic_connection_t *qc,
  169.     ngx_quic_socket_t *qsock)
  170. {
  171.     ngx_str_t              id;
  172.     ngx_quic_server_id_t  *sid;

  174.     sid = &qsock->sid;

  176.     id.data = sid->id;
  177.     id.len = sid->len;

  179.     qsock->udp.connection = c;
  180.     qsock->udp.node.key = ngx_crc32_long(id.data, id.len);
  181.     qsock->udp.key = id;

  183.     ngx_rbtree_insert(&c->listening->rbtree, &qsock->udp.node);

  185.     ngx_queue_insert_tail(&qc->sockets, &qsock->queue);

  187.     qc->nsockets++;
  188.     qsock->quic = qc;

  190.     ngx_log_debug3(NGX_LOG_DEBUG_EVENT, c->log, 0,
  191.                    "quic socket seq:%L listening at sid:%xV nsock:%ui",
  192.                    (int64_t) sid->seqnum, &id, qc->nsockets);

  194.     return NGX_OK;
  195. }


  198. void
  199. ‌ngx_quic_close_sockets(ngx_connection_t *c)
  200. {
  201.     ngx_queue_t            *q;
  202.     ngx_quic_socket_t      *qsock;
  203.     ngx_quic_connection_t  *qc;

  205.     qc = ngx_quic_get_connection(c);

  207.     while (!ngx_queue_empty(&qc->sockets)) {
  208.         q = ngx_queue_head(&qc->sockets);
  209.         qsock = ngx_queue_data(q, ngx_quic_socket_t, queue);

  211.         ngx_quic_close_socket(c, qsock);
  212.     }
  213. }


  216. ngx_quic_socket_t *
  217. ‌ngx_quic_find_socket(ngx_connection_t *c, uint64_t seqnum)
  218. {
  219.     ngx_queue_t            *q;
  220.     ngx_quic_socket_t      *qsock;
  221.     ngx_quic_connection_t  *qc;

  223.     qc = ngx_quic_get_connection(c);

  225.     for (q = ngx_queue_head(&qc->sockets);
  226.          q != ngx_queue_sentinel(&qc->sockets);
  227.          q = ngx_queue_next(q))
  228.     {
  229.         qsock = ngx_queue_data(q, ngx_quic_socket_t, queue);

  231.         if (qsock->sid.seqnum == seqnum) {
  232.             return qsock;
  233.         }
  234.     }

  236.     return NULL;
  237. }

One Level Up Top Level