crypto/bio/socket.cc

// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <openssl/bio.h>

#if !defined(OPENSSL_NO_SOCK)

#include <fcntl.h>
#include <string.h>
#include <limits.h>

#include <algorithm>

#if !defined(OPENSSL_WINDOWS)
#include <unistd.h>
#else
#include <winsock2.h>
OPENSSL_MSVC_PRAGMA(comment(lib, "Ws2_32.lib"))
#endif

#include "internal.h"


using namespace bssl;

#if !defined(OPENSSL_WINDOWS)
static int closesocket(int sock) { return close(sock); }
#endif

static int sock_free(BIO *bio) {
  if (BIO_get_shutdown(bio)) {
    if (BIO_get_init(bio)) {
      closesocket(FromOpaque(bio)->num);
    }
    BIO_set_init(bio, 0);
    BIO_clear_retry_flags(bio);
  }
  return 1;
}

static int sock_read(BIO *b, char *out, int outl) {
  bio_clear_socket_error();
#if defined(OPENSSL_WINDOWS)
  int ret = recv(FromOpaque(b)->num, out, outl, 0);
#else
  int ret = (int)read(FromOpaque(b)->num, out, outl);
#endif
  BIO_clear_retry_flags(b);
  if (ret <= 0) {
    if (bio_socket_should_retry(ret)) {
      BIO_set_retry_read(b);
    }
  }
  return ret;
}

static int sock_write_ex(BIO *b, const char *in, size_t inl,
                         size_t *out_written) {
  bio_clear_socket_error();
#if defined(OPENSSL_WINDOWS)
  inl = std::min(inl, size_t{INT_MAX});
  int ret = send(FromOpaque(b)->num, in, static_cast<int>(inl), 0);
#else
  ssize_t ret = write(FromOpaque(b)->num, in, inl);
#endif
  BIO_clear_retry_flags(b);
  if (ret <= 0) {
    if (bio_socket_should_retry(ret)) {
      BIO_set_retry_write(b);
    }
    return 0;
  }

  *out_written = ret;
  return 1;
}

static long sock_ctrl(BIO *b, int cmd, long num, void *ptr) {
  switch (cmd) {
    case BIO_C_SET_FD:
      sock_free(b);
      FromOpaque(b)->num = *static_cast<int *>(ptr);
      BIO_set_shutdown(b, static_cast<int>(num));
      BIO_set_init(b, 1);
      return 1;
    case BIO_C_GET_FD:
      if (BIO_get_init(b)) {
        int *out = static_cast<int *>(ptr);
        if (out != nullptr) {
          *out = FromOpaque(b)->num;
        }
        return FromOpaque(b)->num;
      }
      return -1;
    case BIO_CTRL_GET_CLOSE:
      return BIO_get_shutdown(b);
    case BIO_CTRL_SET_CLOSE:
      BIO_set_shutdown(b, static_cast<int>(num));
      return 1;
    case BIO_CTRL_FLUSH:
      return 1;
    default:
      return 0;
  }
}

static const BIO_METHOD methods_sockp = {
    BIO_TYPE_SOCKET,    "socket",
    /*bwrite=*/nullptr, sock_write_ex,
    sock_read,          nullptr /* gets, */,
    sock_ctrl,          nullptr /* create */,
    sock_free,          nullptr /* callback_ctrl */,
};

const BIO_METHOD *BIO_s_socket() { return &methods_sockp; }

BIO *BIO_new_socket(int fd, int close_flag) {
  BIO *ret;

  ret = BIO_new(BIO_s_socket());
  if (ret == nullptr) {
    return nullptr;
  }
  BIO_set_fd(ret, fd, close_flag);
  return ret;
}

// These functions are provided solely for compatibility with software that
// tries to copy and then modify `BIO_s_socket`. See bio.h for details.
// PostgreSQL's use makes several fragile assumptions on `BIO_s_socket`:
//
// - We do not store anything in `BIO_set_data`. (Broken in upstream OpenSSL,
//   which broke PostgreSQL.)
// - We do not store anything in `BIO_set_app_data`.
// - `BIO_s_socket` is implemented internally using the non-`size_t`-clean
//   I/O functions rather than the `size_t`-clean ones.
// - `BIO_METHOD` never gains another function pointer that is used in concert
//   with any of the functions here.
//
// Some other projects doing similar things use `BIO_meth_get_read` and
// `BIO_meth_get_write` and in turn assume that `BIO_s_socket` has not been
// ported to the `size_t`-clean `BIO_read_ex` and `BIO_write_ex`. (Not yet
// implemented in BoringSSL.)
//
// This is hopelessly fragile. PostgreSQL 18 will include a fix to stop using
// these APIs, but older versions and other software remain impacted, so we
// implement these functions, but only support `BIO_s_socket`. For now they just
// return the underlying functions, but if we ever need to break the above
// assumptions, we can return an older, frozen version of `BIO_s_socket`.
// Limiting to exactly one allowed `BIO_METHOD` lets us do this.
//
// These functions are also deprecated in upstream OpenSSL. See
// https://github.com/openssl/openssl/issues/26047
//
// TODO(davidben): Once Folly and all versions of PostgreSQL we care about are
// updated or patched, remove these functions.

int (*BIO_meth_get_write(const BIO_METHOD *method))(BIO *, const char *, int) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->bwrite;
}

int (*BIO_meth_get_read(const BIO_METHOD *method))(BIO *, char *, int) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->bread;
}

int (*BIO_meth_get_gets(const BIO_METHOD *method))(BIO *, char *, int) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->bgets;
}

int (*BIO_meth_get_puts(const BIO_METHOD *method))(BIO *, const char *) {
  BSSL_CHECK(method == BIO_s_socket());
  return nullptr;
}

long (*BIO_meth_get_ctrl(const BIO_METHOD *method))(BIO *, int, long, void *) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->ctrl;
}

int (*BIO_meth_get_create(const BIO_METHOD *method))(BIO *) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->create;
}

int (*BIO_meth_get_destroy(const BIO_METHOD *method))(BIO *) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->destroy;
}

long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *method))(BIO *, int,
                                                             bio_info_cb) {
  BSSL_CHECK(method == BIO_s_socket());
  return method->callback_ctrl;
}

#endif  // OPENSSL_NO_SOCK