sync code with last fixes and improvements from OpenBSD
This commit is contained in:
parent
f960599e67
commit
691f97cc10
GPG key ID:
F42C07F07E2E35B7
215 changed files with 1520 additions and 11518 deletions
|
|
@ -1,10 +1,10 @@
|
|||
/* $OpenBSD: b_dump.c,v 1.25 2023/07/07 19:37:53 beck Exp $ */
|
||||
/* $OpenBSD: b_dump.c,v 1.26 2023/07/29 02:32:00 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bio.h,v 1.58 2023/07/05 19:25:01 tb Exp $ */
|
||||
/* $OpenBSD: bio.h,v 1.59 2023/07/28 09:58:30 tb Exp $ */
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
|
|
@ -371,11 +371,6 @@ int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
|
|||
#define BIO_C_RESET_READ_REQUEST 147
|
||||
#define BIO_C_SET_MD_CTX 148
|
||||
|
||||
#define BIO_C_SET_PREFIX 149
|
||||
#define BIO_C_GET_PREFIX 150
|
||||
#define BIO_C_SET_SUFFIX 151
|
||||
#define BIO_C_GET_SUFFIX 152
|
||||
|
||||
#define BIO_C_SET_EX_ARG 153
|
||||
#define BIO_C_GET_EX_ARG 154
|
||||
|
||||
|
|
@ -535,16 +530,6 @@ CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func);
|
|||
unsigned long BIO_number_read(BIO *bio);
|
||||
unsigned long BIO_number_written(BIO *bio);
|
||||
|
||||
/* For BIO_f_asn1() */
|
||||
int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
|
||||
asn1_ps_func *prefix_free);
|
||||
int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
|
||||
asn1_ps_func **pprefix_free);
|
||||
int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
|
||||
asn1_ps_func *suffix_free);
|
||||
int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
|
||||
asn1_ps_func **psuffix_free);
|
||||
|
||||
int BIO_get_new_index(void);
|
||||
const BIO_METHOD *BIO_s_file(void);
|
||||
BIO *BIO_new_file(const char *filename, const char *mode);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $OpenBSD: bss_bio.c,v 1.27 2023/07/07 19:37:53 beck Exp $ */
|
||||
/* $OpenBSD: bss_bio.c,v 1.28 2023/07/28 10:13:50 tb Exp $ */
|
||||
/* ====================================================================
|
||||
* Copyright (c) 1998-2003 The OpenSSL Project. All rights reserved.
|
||||
*
|
||||
|
|
@ -251,85 +251,6 @@ bio_read(BIO *bio, char *buf, int size_)
|
|||
return size;
|
||||
}
|
||||
|
||||
/* non-copying interface: provide pointer to available data in buffer
|
||||
* bio_nread0: return number of available bytes
|
||||
* bio_nread: also advance index
|
||||
* (example usage: bio_nread0(), read from buffer, bio_nread()
|
||||
* or just bio_nread(), read from buffer)
|
||||
*/
|
||||
/* WARNING: The non-copying interface is largely untested as of yet
|
||||
* and may contain bugs. */
|
||||
static ssize_t
|
||||
bio_nread0(BIO *bio, char **buf)
|
||||
{
|
||||
struct bio_bio_st *b, *peer_b;
|
||||
ssize_t num;
|
||||
|
||||
BIO_clear_retry_flags(bio);
|
||||
|
||||
if (!bio->init)
|
||||
return 0;
|
||||
|
||||
b = bio->ptr;
|
||||
assert(b != NULL);
|
||||
assert(b->peer != NULL);
|
||||
peer_b = b->peer->ptr;
|
||||
assert(peer_b != NULL);
|
||||
assert(peer_b->buf != NULL);
|
||||
|
||||
peer_b->request = 0;
|
||||
|
||||
if (peer_b->len == 0) {
|
||||
char dummy;
|
||||
|
||||
/* avoid code duplication -- nothing available for reading */
|
||||
return bio_read(bio, &dummy, 1); /* returns 0 or -1 */
|
||||
}
|
||||
|
||||
num = peer_b->len;
|
||||
if (peer_b->size < peer_b->offset + num)
|
||||
/* no ring buffer wrap-around for non-copying interface */
|
||||
num = peer_b->size - peer_b->offset;
|
||||
assert(num > 0);
|
||||
|
||||
if (buf != NULL)
|
||||
*buf = peer_b->buf + peer_b->offset;
|
||||
return num;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
bio_nread(BIO *bio, char **buf, size_t num_)
|
||||
{
|
||||
struct bio_bio_st *b, *peer_b;
|
||||
ssize_t num, available;
|
||||
|
||||
if (num_ > SSIZE_MAX)
|
||||
num = SSIZE_MAX;
|
||||
else
|
||||
num = (ssize_t)num_;
|
||||
|
||||
available = bio_nread0(bio, buf);
|
||||
if (num > available)
|
||||
num = available;
|
||||
if (num <= 0)
|
||||
return num;
|
||||
|
||||
b = bio->ptr;
|
||||
peer_b = b->peer->ptr;
|
||||
|
||||
peer_b->len -= num;
|
||||
if (peer_b->len) {
|
||||
peer_b->offset += num;
|
||||
assert(peer_b->offset <= peer_b->size);
|
||||
if (peer_b->offset == peer_b->size)
|
||||
peer_b->offset = 0;
|
||||
} else
|
||||
peer_b->offset = 0;
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
static int
|
||||
bio_write(BIO *bio, const char *buf, int num_)
|
||||
{
|
||||
|
|
@ -402,85 +323,6 @@ bio_write(BIO *bio, const char *buf, int num_)
|
|||
return num;
|
||||
}
|
||||
|
||||
/* non-copying interface: provide pointer to region to write to
|
||||
* bio_nwrite0: check how much space is available
|
||||
* bio_nwrite: also increase length
|
||||
* (example usage: bio_nwrite0(), write to buffer, bio_nwrite()
|
||||
* or just bio_nwrite(), write to buffer)
|
||||
*/
|
||||
static ssize_t
|
||||
bio_nwrite0(BIO *bio, char **buf)
|
||||
{
|
||||
struct bio_bio_st *b;
|
||||
size_t num;
|
||||
size_t write_offset;
|
||||
|
||||
BIO_clear_retry_flags(bio);
|
||||
|
||||
if (!bio->init)
|
||||
return 0;
|
||||
|
||||
b = bio->ptr;
|
||||
|
||||
assert(b != NULL);
|
||||
assert(b->peer != NULL);
|
||||
assert(b->buf != NULL);
|
||||
|
||||
b->request = 0;
|
||||
if (b->closed) {
|
||||
BIOerror(BIO_R_BROKEN_PIPE);
|
||||
return -1;
|
||||
}
|
||||
|
||||
assert(b->len <= b->size);
|
||||
|
||||
if (b->len == b->size) {
|
||||
BIO_set_retry_write(bio);
|
||||
return -1;
|
||||
}
|
||||
|
||||
num = b->size - b->len;
|
||||
write_offset = b->offset + b->len;
|
||||
if (write_offset >= b->size)
|
||||
write_offset -= b->size;
|
||||
if (write_offset + num > b->size)
|
||||
/* no ring buffer wrap-around for non-copying interface
|
||||
* (to fulfil the promise by BIO_ctrl_get_write_guarantee,
|
||||
* BIO_nwrite may have to be called twice) */
|
||||
num = b->size - write_offset;
|
||||
|
||||
if (buf != NULL)
|
||||
*buf = b->buf + write_offset;
|
||||
assert(write_offset + num <= b->size);
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
bio_nwrite(BIO *bio, char **buf, size_t num_)
|
||||
{
|
||||
struct bio_bio_st *b;
|
||||
ssize_t num, space;
|
||||
|
||||
if (num_ > SSIZE_MAX)
|
||||
num = SSIZE_MAX;
|
||||
else
|
||||
num = (ssize_t)num_;
|
||||
|
||||
space = bio_nwrite0(bio, buf);
|
||||
if (num > space)
|
||||
num = space;
|
||||
if (num <= 0)
|
||||
return num;
|
||||
b = bio->ptr;
|
||||
assert(b != NULL);
|
||||
b->len += num;
|
||||
assert(b->len <= b->size);
|
||||
|
||||
return num;
|
||||
}
|
||||
|
||||
|
||||
static long
|
||||
bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
|
||||
{
|
||||
|
|
@ -564,28 +406,7 @@ bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
|
|||
ret = 1;
|
||||
break;
|
||||
|
||||
case BIO_C_NREAD0:
|
||||
/* prepare for non-copying read */
|
||||
ret = (long) bio_nread0(bio, ptr);
|
||||
break;
|
||||
|
||||
case BIO_C_NREAD:
|
||||
/* non-copying read */
|
||||
ret = (long) bio_nread(bio, ptr, (size_t) num);
|
||||
break;
|
||||
|
||||
case BIO_C_NWRITE0:
|
||||
/* prepare for non-copying write */
|
||||
ret = (long) bio_nwrite0(bio, ptr);
|
||||
break;
|
||||
|
||||
case BIO_C_NWRITE:
|
||||
/* non-copying write */
|
||||
ret = (long) bio_nwrite(bio, ptr, (size_t) num);
|
||||
break;
|
||||
|
||||
|
||||
/* standard CTRL codes follow */
|
||||
/* standard CTRL codes follow */
|
||||
|
||||
case BIO_CTRL_RESET:
|
||||
if (b->buf != NULL) {
|
||||
|
|
@ -817,77 +638,3 @@ BIO_ctrl_reset_read_request(BIO *bio)
|
|||
return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0);
|
||||
}
|
||||
LCRYPTO_ALIAS(BIO_ctrl_reset_read_request);
|
||||
|
||||
|
||||
/* BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now
|
||||
* (conceivably some other BIOs could allow non-copying reads and writes too.)
|
||||
*/
|
||||
int
|
||||
BIO_nread0(BIO *bio, char **buf)
|
||||
{
|
||||
long ret;
|
||||
|
||||
if (!bio->init) {
|
||||
BIOerror(BIO_R_UNINITIALIZED);
|
||||
return -2;
|
||||
}
|
||||
|
||||
ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf);
|
||||
if (ret > INT_MAX)
|
||||
return INT_MAX;
|
||||
else
|
||||
return (int) ret;
|
||||
}
|
||||
LCRYPTO_ALIAS(BIO_nread0);
|
||||
|
||||
int
|
||||
BIO_nread(BIO *bio, char **buf, int num)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!bio->init) {
|
||||
BIOerror(BIO_R_UNINITIALIZED);
|
||||
return -2;
|
||||
}
|
||||
|
||||
ret = (int) BIO_ctrl(bio, BIO_C_NREAD, num, buf);
|
||||
if (ret > 0)
|
||||
bio->num_read += ret;
|
||||
return ret;
|
||||
}
|
||||
LCRYPTO_ALIAS(BIO_nread);
|
||||
|
||||
int
|
||||
BIO_nwrite0(BIO *bio, char **buf)
|
||||
{
|
||||
long ret;
|
||||
|
||||
if (!bio->init) {
|
||||
BIOerror(BIO_R_UNINITIALIZED);
|
||||
return -2;
|
||||
}
|
||||
|
||||
ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf);
|
||||
if (ret > INT_MAX)
|
||||
return INT_MAX;
|
||||
else
|
||||
return (int) ret;
|
||||
}
|
||||
LCRYPTO_ALIAS(BIO_nwrite0);
|
||||
|
||||
int
|
||||
BIO_nwrite(BIO *bio, char **buf, int num)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!bio->init) {
|
||||
BIOerror(BIO_R_UNINITIALIZED);
|
||||
return -2;
|
||||
}
|
||||
|
||||
ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf);
|
||||
if (ret > 0)
|
||||
bio->num_write += ret;
|
||||
return ret;
|
||||
}
|
||||
LCRYPTO_ALIAS(BIO_nwrite);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue