include/internal/quic_ssl.h

   1 /*
   2  * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #ifndef OSSL_QUIC_SSL_H
  11 # define OSSL_QUIC_SSL_H
  12
  13 # include <openssl/ssl.h>
  14 # include <openssl/bio.h>
  15 # include "internal/quic_record_rx.h" /* OSSL_QRX */
  16 # include "internal/quic_ackm.h"      /* OSSL_ACKM */
  17 # include "internal/quic_channel.h"   /* QUIC_CHANNEL */
  18
  19 # ifndef OPENSSL_NO_QUIC
  20
  21 __owur SSL *ossl_quic_new(SSL_CTX *ctx);
  22 __owur int ossl_quic_init(SSL *s);
  23 void ossl_quic_deinit(SSL *s);
  24 void ossl_quic_free(SSL *s);
  25 int ossl_quic_reset(SSL *s);
  26 int ossl_quic_clear(SSL *s);
  27 __owur int ossl_quic_accept(SSL *s);
  28 __owur int ossl_quic_connect(SSL *s);
  29 __owur int ossl_quic_read(SSL *s, void *buf, size_t len, size_t *readbytes);
  30 __owur int ossl_quic_peek(SSL *s, void *buf, size_t len, size_t *readbytes);
  31 __owur int ossl_quic_write_flags(SSL *s, const void *buf, size_t len,
  32                                  uint64_t flags, size_t *written);
  33 __owur int ossl_quic_write(SSL *s, const void *buf, size_t len, size_t *written);
  34 __owur long ossl_quic_ctrl(SSL *s, int cmd, long larg, void *parg);
  35 __owur long ossl_quic_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg);
  36 __owur long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp) (void));
  37 __owur long ossl_quic_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void));
  38 __owur size_t ossl_quic_pending(const SSL *s);
  39 __owur int ossl_quic_key_update(SSL *s, int update_type);
  40 __owur int ossl_quic_get_key_update_type(const SSL *s);
  41 __owur const SSL_CIPHER *ossl_quic_get_cipher_by_char(const unsigned char *p);
  42 __owur int ossl_quic_num_ciphers(void);
  43 __owur const SSL_CIPHER *ossl_quic_get_cipher(unsigned int u);
  44 int ossl_quic_renegotiate_check(SSL *ssl, int initok);
  45
  46 typedef struct quic_conn_st QUIC_CONNECTION;
  47 typedef struct quic_xso_st QUIC_XSO;
  48
  49 int ossl_quic_do_handshake(SSL *s);
  50 void ossl_quic_set_connect_state(SSL *s);
  51 void ossl_quic_set_accept_state(SSL *s);
  52
  53 __owur int ossl_quic_has_pending(const SSL *s);
  54 __owur int ossl_quic_handle_events(SSL *s);
  55 __owur int ossl_quic_get_event_timeout(SSL *s, struct timeval *tv,
  56                                        int *is_infinite);
  57 OSSL_TIME ossl_quic_get_event_deadline(SSL *s);
  58 __owur int ossl_quic_get_rpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *d);
  59 __owur int ossl_quic_get_wpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *d);
  60 __owur int ossl_quic_get_net_read_desired(SSL *s);
  61 __owur int ossl_quic_get_net_write_desired(SSL *s);
  62 __owur int ossl_quic_get_error(const SSL *s, int i);
  63 __owur int ossl_quic_want(const SSL *s);
  64 __owur int ossl_quic_conn_get_blocking_mode(const SSL *s);
  65 __owur int ossl_quic_conn_set_blocking_mode(SSL *s, int blocking);
  66 __owur int ossl_quic_conn_shutdown(SSL *s, uint64_t flags,
  67                                    const SSL_SHUTDOWN_EX_ARGS *args,
  68                                    size_t args_len);
  69 __owur int ossl_quic_conn_stream_conclude(SSL *s);
  70 void ossl_quic_conn_set0_net_rbio(SSL *s, BIO *net_wbio);
  71 void ossl_quic_conn_set0_net_wbio(SSL *s, BIO *net_wbio);
  72 BIO *ossl_quic_conn_get_net_rbio(const SSL *s);
  73 BIO *ossl_quic_conn_get_net_wbio(const SSL *s);
  74 __owur int ossl_quic_conn_set_initial_peer_addr(SSL *s,
  75                                                 const BIO_ADDR *peer_addr);
  76 __owur SSL *ossl_quic_conn_stream_new(SSL *s, uint64_t flags);
  77 __owur SSL *ossl_quic_get0_connection(SSL *s);
  78 __owur int ossl_quic_get_stream_type(SSL *s);
  79 __owur uint64_t ossl_quic_get_stream_id(SSL *s);
  80 __owur int ossl_quic_is_stream_local(SSL *s);
  81 __owur int ossl_quic_set_default_stream_mode(SSL *s, uint32_t mode);
  82 __owur SSL *ossl_quic_detach_stream(SSL *s);
  83 __owur int ossl_quic_attach_stream(SSL *conn, SSL *stream);
  84 __owur int ossl_quic_set_incoming_stream_policy(SSL *s, int policy,
  85                                                 uint64_t aec);
  86 __owur SSL *ossl_quic_accept_stream(SSL *s, uint64_t flags);
  87 __owur size_t ossl_quic_get_accept_stream_queue_len(SSL *s);
  88
  89 __owur int ossl_quic_stream_reset(SSL *ssl,
  90                                   const SSL_STREAM_RESET_ARGS *args,
  91                                   size_t args_len);
  92
  93 __owur int ossl_quic_get_stream_read_state(SSL *ssl);
  94 __owur int ossl_quic_get_stream_write_state(SSL *ssl);
  95 __owur int ossl_quic_get_stream_read_error_code(SSL *ssl,
  96                                                 uint64_t *app_error_code);
  97 __owur int ossl_quic_get_stream_write_error_code(SSL *ssl,
  98                                                  uint64_t *app_error_code);
  99 __owur int ossl_quic_get_conn_close_info(SSL *ssl,
 100                                          SSL_CONN_CLOSE_INFO *info,
 101                                          size_t info_len);
 102
 103 uint64_t ossl_quic_set_options(SSL *s, uint64_t opts);
 104 uint64_t ossl_quic_clear_options(SSL *s, uint64_t opts);
 105 uint64_t ossl_quic_get_options(const SSL *s);
 106
 107 /* Modifies write buffer size for a stream. */
 108 __owur int ossl_quic_set_write_buffer_size(SSL *s, size_t size);
 109
 110 /*
 111  * Used to override ossl_time_now() for debug purposes. While this may be
 112  * overridden at any time, expect strange results if you change it after
 113  * connecting.
 114  */
 115 int ossl_quic_conn_set_override_now_cb(SSL *s,
 116                                        OSSL_TIME (*now_cb)(void *arg),
 117                                        void *now_cb_arg);
 118
 119 /*
 120  * Condvar waiting in the assist thread doesn't support time faking as it relies
 121  * on the OS's notion of time, thus this is used in test code to force a
 122  * spurious wakeup instead.
 123  */
 124 void ossl_quic_conn_force_assist_thread_wake(SSL *s);
 125
 126 /* For use by tests only. */
 127 QUIC_CHANNEL *ossl_quic_conn_get_channel(SSL *s);
 128
 129 int ossl_quic_has_pending(const SSL *s);
 130 int ossl_quic_get_shutdown(const SSL *s);
 131
 132 /*
 133  * Set QLOG diagnostic title. String is copied internally on success and need
 134  * not remain allocated. Only has any effect if logging has not already begun.
 135  * For use by tests only. Setting this on a context affects any QCSO created
 136  * after this is called but does not affect QCSOs already created from a
 137  * context.
 138  */
 139 int ossl_quic_set_diag_title(SSL_CTX *ctx, const char *title);
 140
 141 # endif
 142
 143 #endif