/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

 * are also available at https://curl.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

 * copies of the Software, and permit persons to whom the Software is

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 * SPDX-License-Identifier: curl

 *

 ***************************************************************************/

#include "curl_setup.h"

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#include "urldata.h"

#include "dynbuf.h"

#include "cfilters.h"

#include "curl_log.h"

#include "curl_msh3.h"

#include "curl_ngtcp2.h"

#include "curl_quiche.h"

#include "vquic.h"

#include "vquic_int.h"

/* The last 3 #include files should be in this order */

#include "curl_printf.h"

#include "curl_memory.h"

#include "memdebug.h"

#ifdef ENABLE_QUIC

#ifdef O_BINARY

#define QLOGMODE O_WRONLY|O_CREAT|O_BINARY

#else

#define QLOGMODE O_WRONLY|O_CREAT

#endif

void Curl_quic_ver(char *p, size_t len)

{

#if defined(USE_NGTCP2) && defined(USE_NGHTTP3)

  Curl_ngtcp2_ver(p, len);

#elif defined(USE_QUICHE)

  Curl_quiche_ver(p, len);

#elif defined(USE_MSH3)

  Curl_msh3_ver(p, len);

#endif

}

CURLcode vquic_ctx_init(struct cf_quic_ctx *qctx, size_t pktbuflen)

{

  qctx->num_blocked_pkt = 0;

  qctx->num_blocked_pkt_sent = 0;

  memset(&qctx->blocked_pkt, 0, sizeof(qctx->blocked_pkt));

  qctx->pktbuflen = pktbuflen;

  qctx->pktbuf = malloc(qctx->pktbuflen);

  if(!qctx->pktbuf)

    return CURLE_OUT_OF_MEMORY;

#if defined(__linux__) && defined(UDP_SEGMENT) && defined(HAVE_SENDMSG)

  qctx->no_gso = FALSE;

#else

  qctx->no_gso = TRUE;

#endif

  return CURLE_OK;

}

void vquic_ctx_free(struct cf_quic_ctx *qctx)

{

  free(qctx->pktbuf);

  qctx->pktbuf = NULL;

}

static CURLcode send_packet_no_gso(struct Curl_cfilter *cf,

                                   struct Curl_easy *data,

                                   struct cf_quic_ctx *qctx,

                                   const uint8_t *pkt, size_t pktlen,

                                   size_t gsolen, size_t *psent);

static CURLcode do_sendmsg(struct Curl_cfilter *cf,

                           struct Curl_easy *data,

                           struct cf_quic_ctx *qctx,

                           const uint8_t *pkt, size_t pktlen, size_t gsolen,

                           size_t *psent)

{

#ifdef HAVE_SENDMSG

  struct iovec msg_iov;

  struct msghdr msg = {0};

  ssize_t sent;

#if defined(__linux__) && defined(UDP_SEGMENT)

  uint8_t msg_ctrl[32];

  struct cmsghdr *cm;

#endif

  *psent = 0;

  msg_iov.iov_base = (uint8_t *)pkt;

  msg_iov.iov_len = pktlen;

  msg.msg_iov = &msg_iov;

  msg.msg_iovlen = 1;

#if defined(__linux__) && defined(UDP_SEGMENT)

  if(pktlen > gsolen) {

    /* Only set this, when we need it. macOS, for example,

     * does not seem to like a msg_control of length 0. */

    msg.msg_control = msg_ctrl;

    assert(sizeof(msg_ctrl) >= CMSG_SPACE(sizeof(uint16_t)));

    msg.msg_controllen = CMSG_SPACE(sizeof(uint16_t));

    cm = CMSG_FIRSTHDR(&msg);

    cm->cmsg_level = SOL_UDP;

    cm->cmsg_type = UDP_SEGMENT;

    cm->cmsg_len = CMSG_LEN(sizeof(uint16_t));

    *(uint16_t *)(void *)CMSG_DATA(cm) = gsolen & 0xffff;

  }

#endif

  while((sent = sendmsg(qctx->sockfd, &msg, 0)) == -1 && SOCKERRNO == EINTR)

    ;

  if(sent == -1) {

    switch(SOCKERRNO) {

    case EAGAIN:

#if EAGAIN != EWOULDBLOCK

    case EWOULDBLOCK:

#endif

      return CURLE_AGAIN;

    case EMSGSIZE:

      /* UDP datagram is too large; caused by PMTUD. Just let it be lost. */

      break;

    case EIO:

      if(pktlen > gsolen) {

        /* GSO failure */

        failf(data, "sendmsg() returned %zd (errno %d); disable GSO", sent,

              SOCKERRNO);

        qctx->no_gso = TRUE;

        return send_packet_no_gso(cf, data, qctx, pkt, pktlen, gsolen, psent);

      }

      /* FALLTHROUGH */

    default:

      failf(data, "sendmsg() returned %zd (errno %d)", sent, SOCKERRNO);

      return CURLE_SEND_ERROR;

    }

  }

  else {

    assert(pktlen == (size_t)sent);

  }

#else

  ssize_t sent;

  (void)gsolen;

  *psent = 0;

  while((sent = send(qctx->sockfd,

                     (const char *)pkt, (SEND_TYPE_ARG3)pktlen, 0)) == -1 &&

        SOCKERRNO == EINTR)

    ;

  if(sent == -1) {

    if(SOCKERRNO == EAGAIN || SOCKERRNO == EWOULDBLOCK) {

      return CURLE_AGAIN;

    }

    else {

      failf(data, "send() returned %zd (errno %d)", sent, SOCKERRNO);

      if(SOCKERRNO != EMSGSIZE) {

        return CURLE_SEND_ERROR;

      }

      /* UDP datagram is too large; caused by PMTUD. Just let it be

         lost. */

    }

  }

#endif

  (void)cf;

  *psent = pktlen;

  return CURLE_OK;

}

static CURLcode send_packet_no_gso(struct Curl_cfilter *cf,

                                   struct Curl_easy *data,

                                   struct cf_quic_ctx *qctx,

                                   const uint8_t *pkt, size_t pktlen,

                                   size_t gsolen, size_t *psent)

{

  const uint8_t *p, *end = pkt + pktlen;

  size_t sent;

  *psent = 0;

  for(p = pkt; p < end; p += gsolen) {

    size_t len = CURLMIN(gsolen, (size_t)(end - p));

    CURLcode curlcode = do_sendmsg(cf, data, qctx, p, len, len, &sent);

    if(curlcode != CURLE_OK) {

      return curlcode;

    }

    *psent += sent;

  }

  return CURLE_OK;

}

CURLcode vquic_send_packet(struct Curl_cfilter *cf,

                           struct Curl_easy *data,

                           struct cf_quic_ctx *qctx,

                           const uint8_t *pkt, size_t pktlen, size_t gsolen,

                           size_t *psent)

{

  if(qctx->no_gso && pktlen > gsolen) {

    return send_packet_no_gso(cf, data, qctx, pkt, pktlen, gsolen, psent);

  }

  return do_sendmsg(cf, data, qctx, pkt, pktlen, gsolen, psent);

}

void vquic_push_blocked_pkt(struct Curl_cfilter *cf,

                            struct cf_quic_ctx *qctx,

                            const uint8_t *pkt, size_t pktlen, size_t gsolen)

{

  struct vquic_blocked_pkt *blkpkt;

  (void)cf;

  assert(qctx->num_blocked_pkt <

         sizeof(qctx->blocked_pkt) / sizeof(qctx->blocked_pkt[0]));

  blkpkt = &qctx->blocked_pkt[qctx->num_blocked_pkt++];

  blkpkt->pkt = pkt;

  blkpkt->pktlen = pktlen;

  blkpkt->gsolen = gsolen;

}

CURLcode vquic_send_blocked_pkt(struct Curl_cfilter *cf,

                                struct Curl_easy *data,

                                struct cf_quic_ctx *qctx)

{

  size_t sent;

  CURLcode curlcode;

  struct vquic_blocked_pkt *blkpkt;

  (void)cf;

  for(; qctx->num_blocked_pkt_sent < qctx->num_blocked_pkt;

      ++qctx->num_blocked_pkt_sent) {

    blkpkt = &qctx->blocked_pkt[qctx->num_blocked_pkt_sent];

    curlcode = vquic_send_packet(cf, data, qctx, blkpkt->pkt,

                                 blkpkt->pktlen, blkpkt->gsolen, &sent);

    if(curlcode) {

      if(curlcode == CURLE_AGAIN) {

        blkpkt->pkt += sent;

        blkpkt->pktlen -= sent;

      }

      return curlcode;

    }

  }

  qctx->num_blocked_pkt = 0;

  qctx->num_blocked_pkt_sent = 0;

  return CURLE_OK;

}

/*

 * If the QLOGDIR environment variable is set, open and return a file

 * descriptor to write the log to.

 *

 * This function returns error if something failed outside of failing to

 * create the file. Open file success is deemed by seeing if the returned fd

 * is != -1.

 */

CURLcode Curl_qlogdir(struct Curl_easy *data,

                      unsigned char *scid,

                      size_t scidlen,

                      int *qlogfdp)

{

  const char *qlog_dir = getenv("QLOGDIR");

  *qlogfdp = -1;

  if(qlog_dir) {

    struct dynbuf fname;

    CURLcode result;

    unsigned int i;

    Curl_dyn_init(&fname, DYN_QLOG_NAME);

    result = Curl_dyn_add(&fname, qlog_dir);

    if(!result)

      result = Curl_dyn_add(&fname, "/");

    for(i = 0; (i < scidlen) && !result; i++) {

      char hex[3];

      msnprintf(hex, 3, "%02x", scid[i]);

      result = Curl_dyn_add(&fname, hex);

    }

    if(!result)

      result = Curl_dyn_add(&fname, ".sqlog");

    if(!result) {

      int qlogfd = open(Curl_dyn_ptr(&fname), QLOGMODE,

                        data->set.new_file_perms);

      if(qlogfd != -1)

        *qlogfdp = qlogfd;

    }

    Curl_dyn_free(&fname);

    if(result)

      return result;

  }

  return CURLE_OK;

}

CURLcode Curl_cf_quic_create(struct Curl_cfilter **pcf,

                             struct Curl_easy *data,

                             struct connectdata *conn,

                             const struct Curl_addrinfo *ai,

                             int transport)

{

  (void)transport;

  DEBUGASSERT(transport == TRNSPRT_QUIC);

#if defined(USE_NGTCP2) && defined(USE_NGHTTP3)

  return Curl_cf_ngtcp2_create(pcf, data, conn, ai);

#elif defined(USE_QUICHE)

  return Curl_cf_quiche_create(pcf, data, conn, ai);

#elif defined(USE_MSH3)

  return Curl_cf_msh3_create(pcf, data, conn, ai);

#else

  *pcf = NULL;

  (void)data;

  (void)conn;

  (void)ai;

  return CURLE_NOT_BUILT_IN;

#endif

}

bool Curl_conn_is_http3(const struct Curl_easy *data,

                        const struct connectdata *conn,

                        int sockindex)

{

#if defined(USE_NGTCP2) && defined(USE_NGHTTP3)

  return Curl_conn_is_ngtcp2(data, conn, sockindex);

#elif defined(USE_QUICHE)

  return Curl_conn_is_quiche(data, conn, sockindex);

#elif defined(USE_MSH3)

  return Curl_conn_is_msh3(data, conn, sockindex);

#else

  return ((conn->handler->protocol & PROTO_FAMILY_HTTP) &&

          (conn->httpversion == 30));

#endif

}

CURLcode Curl_conn_may_http3(struct Curl_easy *data,

                             const struct connectdata *conn)

{

  if(conn->transport == TRNSPRT_UNIX) {

    /* cannot do QUIC over a unix domain socket */

    return CURLE_QUIC_CONNECT_ERROR;

  }

  if(!(conn->handler->flags & PROTOPT_SSL)) {

    failf(data, "HTTP/3 requested for non-HTTPS URL");

    return CURLE_URL_MALFORMAT;

  }

#ifndef CURL_DISABLE_PROXY

  if(conn->bits.socksproxy) {

    failf(data, "HTTP/3 is not supported over a SOCKS proxy");

    return CURLE_URL_MALFORMAT;

  }

  if(conn->bits.httpproxy && conn->bits.tunnel_proxy) {

    failf(data, "HTTP/3 is not supported over a HTTP proxy");

    return CURLE_URL_MALFORMAT;

  }

#endif

  return CURLE_OK;

}

#else /* ENABLE_QUIC */

CURLcode Curl_conn_may_http3(struct Curl_easy *data,

                             const struct connectdata *conn)

{

  (void)conn;

  (void)data;

  DEBUGF(infof(data, "QUIC is not supported in this build"));

  return CURLE_NOT_BUILT_IN;

}

#endif /* !ENABLE_QUIC */