mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
180 lines
4.2 KiB
C
180 lines
4.2 KiB
C
// Copyright 2020 Espressif Systems (Shanghai) PTE LTD
|
|
//
|
|
// 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
|
|
|
|
// http://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.
|
|
|
|
#ifndef _OPENSSL_BIO_H
|
|
#define _OPENSSL_BIO_H
|
|
|
|
#include <stddef.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* These are the 'types' of BIOs */
|
|
#define BIO_TYPE_NONE 0
|
|
#define BIO_TYPE_MEM (1 | 0x0400)
|
|
#define BIO_TYPE_BIO (19 | 0x0400) /* (half a) BIO pair */
|
|
|
|
/* Bio object flags */
|
|
#define BIO_FLAGS_READ 0x01
|
|
#define BIO_FLAGS_WRITE 0x02
|
|
|
|
#define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ)
|
|
#define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE)
|
|
|
|
typedef struct bio_st BIO;
|
|
typedef struct bio_method_st BIO_METHOD;
|
|
|
|
/**
|
|
* @brief Create a BIO object as a file type
|
|
* Current implementation return NULL as file types are discouraged on ESP platform
|
|
*
|
|
* @param filename Filename
|
|
* @param mode Mode
|
|
*
|
|
* @return BIO object
|
|
*/
|
|
BIO *BIO_new_file(const char *filename, const char *mode);
|
|
|
|
/**
|
|
* @brief Create a BIO object as a membuf type
|
|
* Current implementation takes a shallow copy of the buffer
|
|
*
|
|
* @param buf Pointer to the buffer
|
|
* @param len Length of the buffer
|
|
*
|
|
* @return BIO object
|
|
*/
|
|
BIO *BIO_new_mem_buf(void *buf, int len);
|
|
|
|
/**
|
|
* @brief create a BIO object
|
|
*
|
|
* @param method - pointer to BIO_METHOD
|
|
*
|
|
* @return pointer to BIO object
|
|
*/
|
|
BIO *BIO_new(BIO_METHOD * method);
|
|
|
|
/**
|
|
* @brief get the memory BIO method function
|
|
*/
|
|
void *BIO_s_mem(void);
|
|
|
|
/**
|
|
* @brief free a BIO object
|
|
*
|
|
* @param x - pointer to BIO object
|
|
*/
|
|
void BIO_free(BIO *b);
|
|
|
|
/**
|
|
* @brief Create a connected pair of BIOs bio1, bio2 with write buffer sizes writebuf1 and writebuf2
|
|
*
|
|
* @param out1 pointer to BIO1
|
|
* @param writebuf1 write size of BIO1 (0 means default size will be used)
|
|
* @param out2 pointer to BIO2
|
|
* @param writebuf2 write size of BIO2 (0 means default size will be used)
|
|
*
|
|
* @return result
|
|
* 0 : failed
|
|
* 1 : OK
|
|
*/
|
|
int BIO_new_bio_pair(BIO **out1, size_t writebuf1, BIO **out2, size_t writebuf2);
|
|
|
|
/**
|
|
* @brief Write data to BIO
|
|
*
|
|
* BIO_TYPE_BIO behaves the same way as OpenSSL bio object, other BIO types mock
|
|
* this functionality to avoid excessive allocation/copy, so the 'data' cannot
|
|
* be freed after the function is called, it should remain valid until BIO object is in use.
|
|
*
|
|
* @param b - pointer to BIO
|
|
* @param data - pointer to data
|
|
* @param dlen - data bytes
|
|
*
|
|
* @return result
|
|
* -1, 0 : failed
|
|
* 1 : OK
|
|
*/
|
|
int BIO_write(BIO *b, const void *data, int dlen);
|
|
|
|
/**
|
|
* @brief Read data from BIO
|
|
*
|
|
* BIO_TYPE_BIO behaves the same way as OpenSSL bio object.
|
|
* Other types just hold pointer
|
|
*
|
|
* @param b - pointer to BIO
|
|
* @param data - pointer to data
|
|
* @param dlen - data bytes
|
|
*
|
|
* @return result
|
|
* -1, 0 : failed
|
|
* 1 : OK
|
|
*/
|
|
int BIO_read(BIO *bio, void *data, int len);
|
|
|
|
/**
|
|
* @brief Get number of pending characters in the BIOs write buffers.
|
|
*
|
|
* @param b Pointer to BIO
|
|
*
|
|
* @return Amount of pending data
|
|
*/
|
|
size_t BIO_wpending(const BIO *bio);
|
|
|
|
/**
|
|
* @brief Get number of pending characters in the BIOs read buffers.
|
|
*
|
|
* @param b Pointer to BIO
|
|
*
|
|
* @return Amount of pending data
|
|
*/
|
|
size_t BIO_ctrl_pending(const BIO *bio);
|
|
|
|
/**
|
|
* @brief Get the maximum length of data that can be currently written to the BIO
|
|
*
|
|
* @param b Pointer to BIO
|
|
*
|
|
* @return Max length of writable data
|
|
*/
|
|
size_t BIO_ctrl_get_write_guarantee(BIO *bio);
|
|
|
|
/**
|
|
* @brief Returns the type of a BIO.
|
|
*
|
|
* @param b Pointer to BIO
|
|
*
|
|
* @return Type of the BIO object
|
|
*/
|
|
int BIO_method_type(const BIO *b);
|
|
|
|
/**
|
|
* @brief Test flags of a BIO.
|
|
*
|
|
* @param b Pointer to BIO
|
|
* @param flags Flags
|
|
*
|
|
* @return BIO object flags masked with the supplied flags
|
|
*/
|
|
int BIO_test_flags(const BIO *b, int flags);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif //_OPENSSL_BIO_H
|