A local copy of OpenSSL from GitHub
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

842 lines
36 KiB

18 years ago
18 years ago
18 years ago
18 years ago
18 years ago
18 years ago
18 years ago
24 years ago
24 years ago
24 years ago
24 years ago
24 years ago
18 years ago
18 years ago
18 years ago
18 years ago
18 years ago
18 years ago
9 years ago
24 years ago
24 years ago
  1. /*
  2. * Copyright 1995-2018 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. #ifndef OPENSSL_BIO_H
  10. # define OPENSSL_BIO_H
  11. # pragma once
  12. # include <openssl/macros.h>
  13. # ifndef OPENSSL_NO_DEPRECATED_3_0
  14. # define HEADER_BIO_H
  15. # endif
  16. # include <openssl/e_os2.h>
  17. # ifndef OPENSSL_NO_STDIO
  18. # include <stdio.h>
  19. # endif
  20. # include <stdarg.h>
  21. # include <openssl/crypto.h>
  22. # include <openssl/bioerr.h>
  23. #ifdef __cplusplus
  24. extern "C" {
  25. #endif
  26. /* There are the classes of BIOs */
  27. # define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */
  28. # define BIO_TYPE_FILTER 0x0200
  29. # define BIO_TYPE_SOURCE_SINK 0x0400
  30. /* These are the 'types' of BIOs */
  31. # define BIO_TYPE_NONE 0
  32. # define BIO_TYPE_MEM ( 1|BIO_TYPE_SOURCE_SINK)
  33. # define BIO_TYPE_FILE ( 2|BIO_TYPE_SOURCE_SINK)
  34. # define BIO_TYPE_FD ( 4|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
  35. # define BIO_TYPE_SOCKET ( 5|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
  36. # define BIO_TYPE_NULL ( 6|BIO_TYPE_SOURCE_SINK)
  37. # define BIO_TYPE_SSL ( 7|BIO_TYPE_FILTER)
  38. # define BIO_TYPE_MD ( 8|BIO_TYPE_FILTER)
  39. # define BIO_TYPE_BUFFER ( 9|BIO_TYPE_FILTER)
  40. # define BIO_TYPE_CIPHER (10|BIO_TYPE_FILTER)
  41. # define BIO_TYPE_BASE64 (11|BIO_TYPE_FILTER)
  42. # define BIO_TYPE_CONNECT (12|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
  43. # define BIO_TYPE_ACCEPT (13|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
  44. # define BIO_TYPE_NBIO_TEST (16|BIO_TYPE_FILTER)/* server proxy BIO */
  45. # define BIO_TYPE_NULL_FILTER (17|BIO_TYPE_FILTER)
  46. # define BIO_TYPE_BIO (19|BIO_TYPE_SOURCE_SINK)/* half a BIO pair */
  47. # define BIO_TYPE_LINEBUFFER (20|BIO_TYPE_FILTER)
  48. # define BIO_TYPE_DGRAM (21|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
  49. # define BIO_TYPE_ASN1 (22|BIO_TYPE_FILTER)
  50. # define BIO_TYPE_COMP (23|BIO_TYPE_FILTER)
  51. # ifndef OPENSSL_NO_SCTP
  52. # define BIO_TYPE_DGRAM_SCTP (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR)
  53. # endif
  54. #define BIO_TYPE_START 128
  55. /*
  56. * BIO_FILENAME_READ|BIO_CLOSE to open or close on free.
  57. * BIO_set_fp(in,stdin,BIO_NOCLOSE);
  58. */
  59. # define BIO_NOCLOSE 0x00
  60. # define BIO_CLOSE 0x01
  61. /*
  62. * These are used in the following macros and are passed to BIO_ctrl()
  63. */
  64. # define BIO_CTRL_RESET 1/* opt - rewind/zero etc */
  65. # define BIO_CTRL_EOF 2/* opt - are we at the eof */
  66. # define BIO_CTRL_INFO 3/* opt - extra tit-bits */
  67. # define BIO_CTRL_SET 4/* man - set the 'IO' type */
  68. # define BIO_CTRL_GET 5/* man - get the 'IO' type */
  69. # define BIO_CTRL_PUSH 6/* opt - internal, used to signify change */
  70. # define BIO_CTRL_POP 7/* opt - internal, used to signify change */
  71. # define BIO_CTRL_GET_CLOSE 8/* man - set the 'close' on free */
  72. # define BIO_CTRL_SET_CLOSE 9/* man - set the 'close' on free */
  73. # define BIO_CTRL_PENDING 10/* opt - is their more data buffered */
  74. # define BIO_CTRL_FLUSH 11/* opt - 'flush' buffered output */
  75. # define BIO_CTRL_DUP 12/* man - extra stuff for 'duped' BIO */
  76. # define BIO_CTRL_WPENDING 13/* opt - number of bytes still to write */
  77. # define BIO_CTRL_SET_CALLBACK 14/* opt - set callback function */
  78. # define BIO_CTRL_GET_CALLBACK 15/* opt - set callback function */
  79. # define BIO_CTRL_PEEK 29/* BIO_f_buffer special */
  80. # define BIO_CTRL_SET_FILENAME 30/* BIO_s_file special */
  81. /* dgram BIO stuff */
  82. # define BIO_CTRL_DGRAM_CONNECT 31/* BIO dgram special */
  83. # define BIO_CTRL_DGRAM_SET_CONNECTED 32/* allow for an externally connected
  84. * socket to be passed in */
  85. # define BIO_CTRL_DGRAM_SET_RECV_TIMEOUT 33/* setsockopt, essentially */
  86. # define BIO_CTRL_DGRAM_GET_RECV_TIMEOUT 34/* getsockopt, essentially */
  87. # define BIO_CTRL_DGRAM_SET_SEND_TIMEOUT 35/* setsockopt, essentially */
  88. # define BIO_CTRL_DGRAM_GET_SEND_TIMEOUT 36/* getsockopt, essentially */
  89. # define BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP 37/* flag whether the last */
  90. # define BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP 38/* I/O operation tiemd out */
  91. /* #ifdef IP_MTU_DISCOVER */
  92. # define BIO_CTRL_DGRAM_MTU_DISCOVER 39/* set DF bit on egress packets */
  93. /* #endif */
  94. # define BIO_CTRL_DGRAM_QUERY_MTU 40/* as kernel for current MTU */
  95. # define BIO_CTRL_DGRAM_GET_FALLBACK_MTU 47
  96. # define BIO_CTRL_DGRAM_GET_MTU 41/* get cached value for MTU */
  97. # define BIO_CTRL_DGRAM_SET_MTU 42/* set cached value for MTU.
  98. * want to use this if asking
  99. * the kernel fails */
  100. # define BIO_CTRL_DGRAM_MTU_EXCEEDED 43/* check whether the MTU was
  101. * exceed in the previous write
  102. * operation */
  103. # define BIO_CTRL_DGRAM_GET_PEER 46
  104. # define BIO_CTRL_DGRAM_SET_PEER 44/* Destination for the data */
  105. # define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT 45/* Next DTLS handshake timeout
  106. * to adjust socket timeouts */
  107. # define BIO_CTRL_DGRAM_SET_DONT_FRAG 48
  108. # define BIO_CTRL_DGRAM_GET_MTU_OVERHEAD 49
  109. /* Deliberately outside of OPENSSL_NO_SCTP - used in bss_dgram.c */
  110. # define BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE 50
  111. # ifndef OPENSSL_NO_SCTP
  112. /* SCTP stuff */
  113. # define BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY 51
  114. # define BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY 52
  115. # define BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD 53
  116. # define BIO_CTRL_DGRAM_SCTP_GET_SNDINFO 60
  117. # define BIO_CTRL_DGRAM_SCTP_SET_SNDINFO 61
  118. # define BIO_CTRL_DGRAM_SCTP_GET_RCVINFO 62
  119. # define BIO_CTRL_DGRAM_SCTP_SET_RCVINFO 63
  120. # define BIO_CTRL_DGRAM_SCTP_GET_PRINFO 64
  121. # define BIO_CTRL_DGRAM_SCTP_SET_PRINFO 65
  122. # define BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN 70
  123. # endif
  124. # define BIO_CTRL_DGRAM_SET_PEEK_MODE 71
  125. /*
  126. * internal BIO:
  127. * # define BIO_CTRL_SET_KTLS_SEND 72
  128. * # define BIO_CTRL_SET_KTLS_SEND_CTRL_MSG 74
  129. * # define BIO_CTRL_CLEAR_KTLS_CTRL_MSG 75
  130. */
  131. # define BIO_CTRL_GET_KTLS_SEND 73
  132. # define BIO_CTRL_GET_KTLS_RECV 76
  133. # define BIO_CTRL_DGRAM_SCTP_WAIT_FOR_DRY 77
  134. # define BIO_CTRL_DGRAM_SCTP_MSG_WAITING 78
  135. /* BIO_f_prefix controls */
  136. # define BIO_CTRL_SET_PREFIX 79
  137. # define BIO_CTRL_SET_INDENT 80
  138. # define BIO_CTRL_GET_INDENT 81
  139. # ifndef OPENSSL_NO_KTLS
  140. # define BIO_get_ktls_send(b) \
  141. BIO_ctrl(b, BIO_CTRL_GET_KTLS_SEND, 0, NULL)
  142. # define BIO_get_ktls_recv(b) \
  143. BIO_ctrl(b, BIO_CTRL_GET_KTLS_RECV, 0, NULL)
  144. # else
  145. # define BIO_get_ktls_send(b) (0)
  146. # define BIO_get_ktls_recv(b) (0)
  147. # endif
  148. /* modifiers */
  149. # define BIO_FP_READ 0x02
  150. # define BIO_FP_WRITE 0x04
  151. # define BIO_FP_APPEND 0x08
  152. # define BIO_FP_TEXT 0x10
  153. # define BIO_FLAGS_READ 0x01
  154. # define BIO_FLAGS_WRITE 0x02
  155. # define BIO_FLAGS_IO_SPECIAL 0x04
  156. # define BIO_FLAGS_RWS (BIO_FLAGS_READ|BIO_FLAGS_WRITE|BIO_FLAGS_IO_SPECIAL)
  157. # define BIO_FLAGS_SHOULD_RETRY 0x08
  158. # ifndef OPENSSL_NO_DEPRECATED_3_0
  159. /* This #define was replaced by an internal constant and should not be used. */
  160. # define BIO_FLAGS_UPLINK 0
  161. # endif
  162. # define BIO_FLAGS_BASE64_NO_NL 0x100
  163. /*
  164. * This is used with memory BIOs:
  165. * BIO_FLAGS_MEM_RDONLY means we shouldn't free up or change the data in any way;
  166. * BIO_FLAGS_NONCLEAR_RST means we shouldn't clear data on reset.
  167. */
  168. # define BIO_FLAGS_MEM_RDONLY 0x200
  169. # define BIO_FLAGS_NONCLEAR_RST 0x400
  170. # define BIO_FLAGS_IN_EOF 0x800
  171. typedef union bio_addr_st BIO_ADDR;
  172. typedef struct bio_addrinfo_st BIO_ADDRINFO;
  173. int BIO_get_new_index(void);
  174. void BIO_set_flags(BIO *b, int flags);
  175. int BIO_test_flags(const BIO *b, int flags);
  176. void BIO_clear_flags(BIO *b, int flags);
  177. # define BIO_get_flags(b) BIO_test_flags(b, ~(0x0))
  178. # define BIO_set_retry_special(b) \
  179. BIO_set_flags(b, (BIO_FLAGS_IO_SPECIAL|BIO_FLAGS_SHOULD_RETRY))
  180. # define BIO_set_retry_read(b) \
  181. BIO_set_flags(b, (BIO_FLAGS_READ|BIO_FLAGS_SHOULD_RETRY))
  182. # define BIO_set_retry_write(b) \
  183. BIO_set_flags(b, (BIO_FLAGS_WRITE|BIO_FLAGS_SHOULD_RETRY))
  184. /* These are normally used internally in BIOs */
  185. # define BIO_clear_retry_flags(b) \
  186. BIO_clear_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
  187. # define BIO_get_retry_flags(b) \
  188. BIO_test_flags(b, (BIO_FLAGS_RWS|BIO_FLAGS_SHOULD_RETRY))
  189. /* These should be used by the application to tell why we should retry */
  190. # define BIO_should_read(a) BIO_test_flags(a, BIO_FLAGS_READ)
  191. # define BIO_should_write(a) BIO_test_flags(a, BIO_FLAGS_WRITE)
  192. # define BIO_should_io_special(a) BIO_test_flags(a, BIO_FLAGS_IO_SPECIAL)
  193. # define BIO_retry_type(a) BIO_test_flags(a, BIO_FLAGS_RWS)
  194. # define BIO_should_retry(a) BIO_test_flags(a, BIO_FLAGS_SHOULD_RETRY)
  195. /*
  196. * The next three are used in conjunction with the BIO_should_io_special()
  197. * condition. After this returns true, BIO *BIO_get_retry_BIO(BIO *bio, int
  198. * *reason); will walk the BIO stack and return the 'reason' for the special
  199. * and the offending BIO. Given a BIO, BIO_get_retry_reason(bio) will return
  200. * the code.
  201. */
  202. /*
  203. * Returned from the SSL bio when the certificate retrieval code had an error
  204. */
  205. # define BIO_RR_SSL_X509_LOOKUP 0x01
  206. /* Returned from the connect BIO when a connect would have blocked */
  207. # define BIO_RR_CONNECT 0x02
  208. /* Returned from the accept BIO when an accept would have blocked */
  209. # define BIO_RR_ACCEPT 0x03
  210. /* These are passed by the BIO callback */
  211. # define BIO_CB_FREE 0x01
  212. # define BIO_CB_READ 0x02
  213. # define BIO_CB_WRITE 0x03
  214. # define BIO_CB_PUTS 0x04
  215. # define BIO_CB_GETS 0x05
  216. # define BIO_CB_CTRL 0x06
  217. /*
  218. * The callback is called before and after the underling operation, The
  219. * BIO_CB_RETURN flag indicates if it is after the call
  220. */
  221. # define BIO_CB_RETURN 0x80
  222. # define BIO_CB_return(a) ((a)|BIO_CB_RETURN)
  223. # define BIO_cb_pre(a) (!((a)&BIO_CB_RETURN))
  224. # define BIO_cb_post(a) ((a)&BIO_CB_RETURN)
  225. typedef long (*BIO_callback_fn)(BIO *b, int oper, const char *argp, int argi,
  226. long argl, long ret);
  227. typedef long (*BIO_callback_fn_ex)(BIO *b, int oper, const char *argp,
  228. size_t len, int argi,
  229. long argl, int ret, size_t *processed);
  230. BIO_callback_fn BIO_get_callback(const BIO *b);
  231. void BIO_set_callback(BIO *b, BIO_callback_fn callback);
  232. BIO_callback_fn_ex BIO_get_callback_ex(const BIO *b);
  233. void BIO_set_callback_ex(BIO *b, BIO_callback_fn_ex callback);
  234. char *BIO_get_callback_arg(const BIO *b);
  235. void BIO_set_callback_arg(BIO *b, char *arg);
  236. typedef struct bio_method_st BIO_METHOD;
  237. const char *BIO_method_name(const BIO *b);
  238. int BIO_method_type(const BIO *b);
  239. typedef int BIO_info_cb(BIO *, int, int);
  240. typedef BIO_info_cb bio_info_cb; /* backward compatibility */
  241. DEFINE_STACK_OF(BIO)
  242. /* Prefix and suffix callback in ASN1 BIO */
  243. typedef int asn1_ps_func (BIO *b, unsigned char **pbuf, int *plen,
  244. void *parg);
  245. typedef void (*BIO_dgram_sctp_notification_handler_fn) (BIO *b,
  246. void *context,
  247. void *buf);
  248. # ifndef OPENSSL_NO_SCTP
  249. /* SCTP parameter structs */
  250. struct bio_dgram_sctp_sndinfo {
  251. uint16_t snd_sid;
  252. uint16_t snd_flags;
  253. uint32_t snd_ppid;
  254. uint32_t snd_context;
  255. };
  256. struct bio_dgram_sctp_rcvinfo {
  257. uint16_t rcv_sid;
  258. uint16_t rcv_ssn;
  259. uint16_t rcv_flags;
  260. uint32_t rcv_ppid;
  261. uint32_t rcv_tsn;
  262. uint32_t rcv_cumtsn;
  263. uint32_t rcv_context;
  264. };
  265. struct bio_dgram_sctp_prinfo {
  266. uint16_t pr_policy;
  267. uint32_t pr_value;
  268. };
  269. # endif
  270. /*
  271. * #define BIO_CONN_get_param_hostname BIO_ctrl
  272. */
  273. # define BIO_C_SET_CONNECT 100
  274. # define BIO_C_DO_STATE_MACHINE 101
  275. # define BIO_C_SET_NBIO 102
  276. /* # define BIO_C_SET_PROXY_PARAM 103 */
  277. # define BIO_C_SET_FD 104
  278. # define BIO_C_GET_FD 105
  279. # define BIO_C_SET_FILE_PTR 106
  280. # define BIO_C_GET_FILE_PTR 107
  281. # define BIO_C_SET_FILENAME 108
  282. # define BIO_C_SET_SSL 109
  283. # define BIO_C_GET_SSL 110
  284. # define BIO_C_SET_MD 111
  285. # define BIO_C_GET_MD 112
  286. # define BIO_C_GET_CIPHER_STATUS 113
  287. # define BIO_C_SET_BUF_MEM 114
  288. # define BIO_C_GET_BUF_MEM_PTR 115
  289. # define BIO_C_GET_BUFF_NUM_LINES 116
  290. # define BIO_C_SET_BUFF_SIZE 117
  291. # define BIO_C_SET_ACCEPT 118
  292. # define BIO_C_SSL_MODE 119
  293. # define BIO_C_GET_MD_CTX 120
  294. /* # define BIO_C_GET_PROXY_PARAM 121 */
  295. # define BIO_C_SET_BUFF_READ_DATA 122/* data to read first */
  296. # define BIO_C_GET_CONNECT 123
  297. # define BIO_C_GET_ACCEPT 124
  298. # define BIO_C_SET_SSL_RENEGOTIATE_BYTES 125
  299. # define BIO_C_GET_SSL_NUM_RENEGOTIATES 126
  300. # define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT 127
  301. # define BIO_C_FILE_SEEK 128
  302. # define BIO_C_GET_CIPHER_CTX 129
  303. # define BIO_C_SET_BUF_MEM_EOF_RETURN 130/* return end of input
  304. * value */
  305. # define BIO_C_SET_BIND_MODE 131
  306. # define BIO_C_GET_BIND_MODE 132
  307. # define BIO_C_FILE_TELL 133
  308. # define BIO_C_GET_SOCKS 134
  309. # define BIO_C_SET_SOCKS 135
  310. # define BIO_C_SET_WRITE_BUF_SIZE 136/* for BIO_s_bio */
  311. # define BIO_C_GET_WRITE_BUF_SIZE 137
  312. # define BIO_C_MAKE_BIO_PAIR 138
  313. # define BIO_C_DESTROY_BIO_PAIR 139
  314. # define BIO_C_GET_WRITE_GUARANTEE 140
  315. # define BIO_C_GET_READ_REQUEST 141
  316. # define BIO_C_SHUTDOWN_WR 142
  317. # define BIO_C_NREAD0 143
  318. # define BIO_C_NREAD 144
  319. # define BIO_C_NWRITE0 145
  320. # define BIO_C_NWRITE 146
  321. # define BIO_C_RESET_READ_REQUEST 147
  322. # define BIO_C_SET_MD_CTX 148
  323. # define BIO_C_SET_PREFIX 149
  324. # define BIO_C_GET_PREFIX 150
  325. # define BIO_C_SET_SUFFIX 151
  326. # define BIO_C_GET_SUFFIX 152
  327. # define BIO_C_SET_EX_ARG 153
  328. # define BIO_C_GET_EX_ARG 154
  329. # define BIO_C_SET_CONNECT_MODE 155
  330. # define BIO_set_app_data(s,arg) BIO_set_ex_data(s,0,arg)
  331. # define BIO_get_app_data(s) BIO_get_ex_data(s,0)
  332. # define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL)
  333. # ifndef OPENSSL_NO_SOCK
  334. /* IP families we support, for BIO_s_connect() and BIO_s_accept() */
  335. /* Note: the underlying operating system may not support some of them */
  336. # define BIO_FAMILY_IPV4 4
  337. # define BIO_FAMILY_IPV6 6
  338. # define BIO_FAMILY_IPANY 256
  339. /* BIO_s_connect() */
  340. # define BIO_set_conn_hostname(b,name) BIO_ctrl(b,BIO_C_SET_CONNECT,0, \
  341. (char *)(name))
  342. # define BIO_set_conn_port(b,port) BIO_ctrl(b,BIO_C_SET_CONNECT,1, \
  343. (char *)(port))
  344. # define BIO_set_conn_address(b,addr) BIO_ctrl(b,BIO_C_SET_CONNECT,2, \
  345. (char *)(addr))
  346. # define BIO_set_conn_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_CONNECT,3,f)
  347. # define BIO_get_conn_hostname(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,0))
  348. # define BIO_get_conn_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,1))
  349. # define BIO_get_conn_address(b) ((const BIO_ADDR *)BIO_ptr_ctrl(b,BIO_C_GET_CONNECT,2))
  350. # define BIO_get_conn_ip_family(b) BIO_ctrl(b,BIO_C_GET_CONNECT,3,NULL)
  351. # define BIO_set_conn_mode(b,n) BIO_ctrl(b,BIO_C_SET_CONNECT_MODE,(n),NULL)
  352. /* BIO_s_accept() */
  353. # define BIO_set_accept_name(b,name) BIO_ctrl(b,BIO_C_SET_ACCEPT,0, \
  354. (char *)(name))
  355. # define BIO_set_accept_port(b,port) BIO_ctrl(b,BIO_C_SET_ACCEPT,1, \
  356. (char *)(port))
  357. # define BIO_get_accept_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,0))
  358. # define BIO_get_accept_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,1))
  359. # define BIO_get_peer_name(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,2))
  360. # define BIO_get_peer_port(b) ((const char *)BIO_ptr_ctrl(b,BIO_C_GET_ACCEPT,3))
  361. /* #define BIO_set_nbio(b,n) BIO_ctrl(b,BIO_C_SET_NBIO,(n),NULL) */
  362. # define BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,2,(n)?(void *)"a":NULL)
  363. # define BIO_set_accept_bios(b,bio) BIO_ctrl(b,BIO_C_SET_ACCEPT,3, \
  364. (char *)(bio))
  365. # define BIO_set_accept_ip_family(b,f) BIO_int_ctrl(b,BIO_C_SET_ACCEPT,4,f)
  366. # define BIO_get_accept_ip_family(b) BIO_ctrl(b,BIO_C_GET_ACCEPT,4,NULL)
  367. /* Aliases kept for backward compatibility */
  368. # define BIO_BIND_NORMAL 0
  369. # define BIO_BIND_REUSEADDR BIO_SOCK_REUSEADDR
  370. # define BIO_BIND_REUSEADDR_IF_UNUSED BIO_SOCK_REUSEADDR
  371. # define BIO_set_bind_mode(b,mode) BIO_ctrl(b,BIO_C_SET_BIND_MODE,mode,NULL)
  372. # define BIO_get_bind_mode(b) BIO_ctrl(b,BIO_C_GET_BIND_MODE,0,NULL)
  373. /* BIO_s_accept() and BIO_s_connect() */
  374. # define BIO_do_connect(b) BIO_do_handshake(b)
  375. # define BIO_do_accept(b) BIO_do_handshake(b)
  376. # endif /* OPENSSL_NO_SOCK */
  377. # define BIO_do_handshake(b) BIO_ctrl(b,BIO_C_DO_STATE_MACHINE,0,NULL)
  378. /* BIO_s_datagram(), BIO_s_fd(), BIO_s_socket(), BIO_s_accept() and BIO_s_connect() */
  379. # define BIO_set_fd(b,fd,c) BIO_int_ctrl(b,BIO_C_SET_FD,c,fd)
  380. # define BIO_get_fd(b,c) BIO_ctrl(b,BIO_C_GET_FD,0,(char *)(c))
  381. /* BIO_s_file() */
  382. # define BIO_set_fp(b,fp,c) BIO_ctrl(b,BIO_C_SET_FILE_PTR,c,(char *)(fp))
  383. # define BIO_get_fp(b,fpp) BIO_ctrl(b,BIO_C_GET_FILE_PTR,0,(char *)(fpp))
  384. /* BIO_s_fd() and BIO_s_file() */
  385. # define BIO_seek(b,ofs) (int)BIO_ctrl(b,BIO_C_FILE_SEEK,ofs,NULL)
  386. # define BIO_tell(b) (int)BIO_ctrl(b,BIO_C_FILE_TELL,0,NULL)
  387. /*
  388. * name is cast to lose const, but might be better to route through a
  389. * function so we can do it safely
  390. */
  391. # ifdef CONST_STRICT
  392. /*
  393. * If you are wondering why this isn't defined, its because CONST_STRICT is
  394. * purely a compile-time kludge to allow const to be checked.
  395. */
  396. int BIO_read_filename(BIO *b, const char *name);
  397. # else
  398. # define BIO_read_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
  399. BIO_CLOSE|BIO_FP_READ,(char *)(name))
  400. # endif
  401. # define BIO_write_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
  402. BIO_CLOSE|BIO_FP_WRITE,name)
  403. # define BIO_append_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
  404. BIO_CLOSE|BIO_FP_APPEND,name)
  405. # define BIO_rw_filename(b,name) (int)BIO_ctrl(b,BIO_C_SET_FILENAME, \
  406. BIO_CLOSE|BIO_FP_READ|BIO_FP_WRITE,name)
  407. /*
  408. * WARNING WARNING, this ups the reference count on the read bio of the SSL
  409. * structure. This is because the ssl read BIO is now pointed to by the
  410. * next_bio field in the bio. So when you free the BIO, make sure you are
  411. * doing a BIO_free_all() to catch the underlying BIO.
  412. */
  413. # define BIO_set_ssl(b,ssl,c) BIO_ctrl(b,BIO_C_SET_SSL,c,(char *)(ssl))
  414. # define BIO_get_ssl(b,sslp) BIO_ctrl(b,BIO_C_GET_SSL,0,(char *)(sslp))
  415. # define BIO_set_ssl_mode(b,client) BIO_ctrl(b,BIO_C_SSL_MODE,client,NULL)
  416. # define BIO_set_ssl_renegotiate_bytes(b,num) \
  417. BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_BYTES,num,NULL)
  418. # define BIO_get_num_renegotiates(b) \
  419. BIO_ctrl(b,BIO_C_GET_SSL_NUM_RENEGOTIATES,0,NULL)
  420. # define BIO_set_ssl_renegotiate_timeout(b,seconds) \
  421. BIO_ctrl(b,BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT,seconds,NULL)
  422. /* defined in evp.h */
  423. /* #define BIO_set_md(b,md) BIO_ctrl(b,BIO_C_SET_MD,1,(char *)(md)) */
  424. # define BIO_get_mem_data(b,pp) BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)(pp))
  425. # define BIO_set_mem_buf(b,bm,c) BIO_ctrl(b,BIO_C_SET_BUF_MEM,c,(char *)(bm))
  426. # define BIO_get_mem_ptr(b,pp) BIO_ctrl(b,BIO_C_GET_BUF_MEM_PTR,0, \
  427. (char *)(pp))
  428. # define BIO_set_mem_eof_return(b,v) \
  429. BIO_ctrl(b,BIO_C_SET_BUF_MEM_EOF_RETURN,v,NULL)
  430. /* For the BIO_f_buffer() type */
  431. # define BIO_get_buffer_num_lines(b) BIO_ctrl(b,BIO_C_GET_BUFF_NUM_LINES,0,NULL)
  432. # define BIO_set_buffer_size(b,size) BIO_ctrl(b,BIO_C_SET_BUFF_SIZE,size,NULL)
  433. # define BIO_set_read_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,0)
  434. # define BIO_set_write_buffer_size(b,size) BIO_int_ctrl(b,BIO_C_SET_BUFF_SIZE,size,1)
  435. # define BIO_set_buffer_read_data(b,buf,num) BIO_ctrl(b,BIO_C_SET_BUFF_READ_DATA,num,buf)
  436. /* Don't use the next one unless you know what you are doing :-) */
  437. # define BIO_dup_state(b,ret) BIO_ctrl(b,BIO_CTRL_DUP,0,(char *)(ret))
  438. # define BIO_reset(b) (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
  439. # define BIO_eof(b) (int)BIO_ctrl(b,BIO_CTRL_EOF,0,NULL)
  440. # define BIO_set_close(b,c) (int)BIO_ctrl(b,BIO_CTRL_SET_CLOSE,(c),NULL)
  441. # define BIO_get_close(b) (int)BIO_ctrl(b,BIO_CTRL_GET_CLOSE,0,NULL)
  442. # define BIO_pending(b) (int)BIO_ctrl(b,BIO_CTRL_PENDING,0,NULL)
  443. # define BIO_wpending(b) (int)BIO_ctrl(b,BIO_CTRL_WPENDING,0,NULL)
  444. /* ...pending macros have inappropriate return type */
  445. size_t BIO_ctrl_pending(BIO *b);
  446. size_t BIO_ctrl_wpending(BIO *b);
  447. # define BIO_flush(b) (int)BIO_ctrl(b,BIO_CTRL_FLUSH,0,NULL)
  448. # define BIO_get_info_callback(b,cbp) (int)BIO_ctrl(b,BIO_CTRL_GET_CALLBACK,0, \
  449. cbp)
  450. # define BIO_set_info_callback(b,cb) (int)BIO_callback_ctrl(b,BIO_CTRL_SET_CALLBACK,cb)
  451. /* For the BIO_f_buffer() type */
  452. # define BIO_buffer_get_num_lines(b) BIO_ctrl(b,BIO_CTRL_GET,0,NULL)
  453. # define BIO_buffer_peek(b,s,l) BIO_ctrl(b,BIO_CTRL_PEEK,(l),(s))
  454. /* For BIO_s_bio() */
  455. # define BIO_set_write_buf_size(b,size) (int)BIO_ctrl(b,BIO_C_SET_WRITE_BUF_SIZE,size,NULL)
  456. # define BIO_get_write_buf_size(b,size) (size_t)BIO_ctrl(b,BIO_C_GET_WRITE_BUF_SIZE,size,NULL)
  457. # define BIO_make_bio_pair(b1,b2) (int)BIO_ctrl(b1,BIO_C_MAKE_BIO_PAIR,0,b2)
  458. # define BIO_destroy_bio_pair(b) (int)BIO_ctrl(b,BIO_C_DESTROY_BIO_PAIR,0,NULL)
  459. # define BIO_shutdown_wr(b) (int)BIO_ctrl(b, BIO_C_SHUTDOWN_WR, 0, NULL)
  460. /* macros with inappropriate type -- but ...pending macros use int too: */
  461. # define BIO_get_write_guarantee(b) (int)BIO_ctrl(b,BIO_C_GET_WRITE_GUARANTEE,0,NULL)
  462. # define BIO_get_read_request(b) (int)BIO_ctrl(b,BIO_C_GET_READ_REQUEST,0,NULL)
  463. size_t BIO_ctrl_get_write_guarantee(BIO *b);
  464. size_t BIO_ctrl_get_read_request(BIO *b);
  465. int BIO_ctrl_reset_read_request(BIO *b);
  466. /* ctrl macros for dgram */
  467. # define BIO_ctrl_dgram_connect(b,peer) \
  468. (int)BIO_ctrl(b,BIO_CTRL_DGRAM_CONNECT,0, (char *)(peer))
  469. # define BIO_ctrl_set_connected(b,peer) \
  470. (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_CONNECTED, 0, (char *)(peer))
  471. # define BIO_dgram_recv_timedout(b) \
  472. (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP, 0, NULL)
  473. # define BIO_dgram_send_timedout(b) \
  474. (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP, 0, NULL)
  475. # define BIO_dgram_get_peer(b,peer) \
  476. (int)BIO_ctrl(b, BIO_CTRL_DGRAM_GET_PEER, 0, (char *)(peer))
  477. # define BIO_dgram_set_peer(b,peer) \
  478. (int)BIO_ctrl(b, BIO_CTRL_DGRAM_SET_PEER, 0, (char *)(peer))
  479. # define BIO_dgram_get_mtu_overhead(b) \
  480. (unsigned int)BIO_ctrl((b), BIO_CTRL_DGRAM_GET_MTU_OVERHEAD, 0, NULL)
  481. /* ctrl macros for BIO_f_prefix */
  482. # define BIO_set_prefix(b,p) BIO_ctrl((b), BIO_CTRL_SET_PREFIX, 0, (void *)(p))
  483. # define BIO_set_indent(b,i) BIO_ctrl((b), BIO_CTRL_SET_INDENT, (i), NULL)
  484. # define BIO_get_indent(b) BIO_ctrl((b), BIO_CTRL_GET_INDENT, 0, NULL)
  485. #define BIO_get_ex_new_index(l, p, newf, dupf, freef) \
  486. CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_BIO, l, p, newf, dupf, freef)
  487. int BIO_set_ex_data(BIO *bio, int idx, void *data);
  488. void *BIO_get_ex_data(BIO *bio, int idx);
  489. uint64_t BIO_number_read(BIO *bio);
  490. uint64_t BIO_number_written(BIO *bio);
  491. /* For BIO_f_asn1() */
  492. int BIO_asn1_set_prefix(BIO *b, asn1_ps_func *prefix,
  493. asn1_ps_func *prefix_free);
  494. int BIO_asn1_get_prefix(BIO *b, asn1_ps_func **pprefix,
  495. asn1_ps_func **pprefix_free);
  496. int BIO_asn1_set_suffix(BIO *b, asn1_ps_func *suffix,
  497. asn1_ps_func *suffix_free);
  498. int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix,
  499. asn1_ps_func **psuffix_free);
  500. const BIO_METHOD *BIO_s_file(void);
  501. BIO *BIO_new_file(const char *filename, const char *mode);
  502. # ifndef OPENSSL_NO_STDIO
  503. BIO *BIO_new_fp(FILE *stream, int close_flag);
  504. # endif
  505. BIO *BIO_new(const BIO_METHOD *type);
  506. int BIO_free(BIO *a);
  507. void BIO_set_data(BIO *a, void *ptr);
  508. void *BIO_get_data(BIO *a);
  509. void BIO_set_init(BIO *a, int init);
  510. int BIO_get_init(BIO *a);
  511. void BIO_set_shutdown(BIO *a, int shut);
  512. int BIO_get_shutdown(BIO *a);
  513. void BIO_vfree(BIO *a);
  514. int BIO_up_ref(BIO *a);
  515. int BIO_read(BIO *b, void *data, int dlen);
  516. int BIO_read_ex(BIO *b, void *data, size_t dlen, size_t *readbytes);
  517. int BIO_gets(BIO *bp, char *buf, int size);
  518. int BIO_write(BIO *b, const void *data, int dlen);
  519. int BIO_write_ex(BIO *b, const void *data, size_t dlen, size_t *written);
  520. int BIO_puts(BIO *bp, const char *buf);
  521. int BIO_indent(BIO *b, int indent, int max);
  522. long BIO_ctrl(BIO *bp, int cmd, long larg, void *parg);
  523. long BIO_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp);
  524. void *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
  525. long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
  526. BIO *BIO_push(BIO *b, BIO *append);
  527. BIO *BIO_pop(BIO *b);
  528. void BIO_free_all(BIO *a);
  529. BIO *BIO_find_type(BIO *b, int bio_type);
  530. BIO *BIO_next(BIO *b);
  531. void BIO_set_next(BIO *b, BIO *next);
  532. BIO *BIO_get_retry_BIO(BIO *bio, int *reason);
  533. int BIO_get_retry_reason(BIO *bio);
  534. void BIO_set_retry_reason(BIO *bio, int reason);
  535. BIO *BIO_dup_chain(BIO *in);
  536. int BIO_nread0(BIO *bio, char **buf);
  537. int BIO_nread(BIO *bio, char **buf, int num);
  538. int BIO_nwrite0(BIO *bio, char **buf);
  539. int BIO_nwrite(BIO *bio, char **buf, int num);
  540. long BIO_debug_callback(BIO *bio, int cmd, const char *argp, int argi,
  541. long argl, long ret);
  542. const BIO_METHOD *BIO_s_mem(void);
  543. const BIO_METHOD *BIO_s_secmem(void);
  544. BIO *BIO_new_mem_buf(const void *buf, int len);
  545. # ifndef OPENSSL_NO_SOCK
  546. const BIO_METHOD *BIO_s_socket(void);
  547. const BIO_METHOD *BIO_s_connect(void);
  548. const BIO_METHOD *BIO_s_accept(void);
  549. # endif
  550. const BIO_METHOD *BIO_s_fd(void);
  551. const BIO_METHOD *BIO_s_log(void);
  552. const BIO_METHOD *BIO_s_bio(void);
  553. const BIO_METHOD *BIO_s_null(void);
  554. const BIO_METHOD *BIO_f_null(void);
  555. const BIO_METHOD *BIO_f_buffer(void);
  556. const BIO_METHOD *BIO_f_linebuffer(void);
  557. const BIO_METHOD *BIO_f_nbio_test(void);
  558. const BIO_METHOD *BIO_f_prefix(void);
  559. # ifndef OPENSSL_NO_DGRAM
  560. const BIO_METHOD *BIO_s_datagram(void);
  561. int BIO_dgram_non_fatal_error(int error);
  562. BIO *BIO_new_dgram(int fd, int close_flag);
  563. # ifndef OPENSSL_NO_SCTP
  564. const BIO_METHOD *BIO_s_datagram_sctp(void);
  565. BIO *BIO_new_dgram_sctp(int fd, int close_flag);
  566. int BIO_dgram_is_sctp(BIO *bio);
  567. int BIO_dgram_sctp_notification_cb(BIO *b,
  568. BIO_dgram_sctp_notification_handler_fn handle_notifications,
  569. void *context);
  570. int BIO_dgram_sctp_wait_for_dry(BIO *b);
  571. int BIO_dgram_sctp_msg_waiting(BIO *b);
  572. # endif
  573. # endif
  574. # ifndef OPENSSL_NO_SOCK
  575. int BIO_sock_should_retry(int i);
  576. int BIO_sock_non_fatal_error(int error);
  577. int BIO_socket_wait(int fd, int for_read, time_t max_time);
  578. # endif
  579. int BIO_wait(BIO *bio, time_t max_time, unsigned int milliseconds);
  580. int BIO_connect_retry(BIO *bio, int timeout);
  581. int BIO_fd_should_retry(int i);
  582. int BIO_fd_non_fatal_error(int error);
  583. int BIO_dump_cb(int (*cb) (const void *data, size_t len, void *u),
  584. void *u, const void *s, int len);
  585. int BIO_dump_indent_cb(int (*cb) (const void *data, size_t len, void *u),
  586. void *u, const void *s, int len, int indent);
  587. int BIO_dump(BIO *b, const void *bytes, int len);
  588. int BIO_dump_indent(BIO *b, const void *bytes, int len, int indent);
  589. # ifndef OPENSSL_NO_STDIO
  590. int BIO_dump_fp(FILE *fp, const void *s, int len);
  591. int BIO_dump_indent_fp(FILE *fp, const void *s, int len, int indent);
  592. # endif
  593. int BIO_hex_string(BIO *out, int indent, int width, const void *data,
  594. int datalen);
  595. # ifndef OPENSSL_NO_SOCK
  596. BIO_ADDR *BIO_ADDR_new(void);
  597. int BIO_ADDR_rawmake(BIO_ADDR *ap, int family,
  598. const void *where, size_t wherelen, unsigned short port);
  599. void BIO_ADDR_free(BIO_ADDR *);
  600. void BIO_ADDR_clear(BIO_ADDR *ap);
  601. int BIO_ADDR_family(const BIO_ADDR *ap);
  602. int BIO_ADDR_rawaddress(const BIO_ADDR *ap, void *p, size_t *l);
  603. unsigned short BIO_ADDR_rawport(const BIO_ADDR *ap);
  604. char *BIO_ADDR_hostname_string(const BIO_ADDR *ap, int numeric);
  605. char *BIO_ADDR_service_string(const BIO_ADDR *ap, int numeric);
  606. char *BIO_ADDR_path_string(const BIO_ADDR *ap);
  607. const BIO_ADDRINFO *BIO_ADDRINFO_next(const BIO_ADDRINFO *bai);
  608. int BIO_ADDRINFO_family(const BIO_ADDRINFO *bai);
  609. int BIO_ADDRINFO_socktype(const BIO_ADDRINFO *bai);
  610. int BIO_ADDRINFO_protocol(const BIO_ADDRINFO *bai);
  611. const BIO_ADDR *BIO_ADDRINFO_address(const BIO_ADDRINFO *bai);
  612. void BIO_ADDRINFO_free(BIO_ADDRINFO *bai);
  613. enum BIO_hostserv_priorities {
  614. BIO_PARSE_PRIO_HOST, BIO_PARSE_PRIO_SERV
  615. };
  616. int BIO_parse_hostserv(const char *hostserv, char **host, char **service,
  617. enum BIO_hostserv_priorities hostserv_prio);
  618. enum BIO_lookup_type {
  619. BIO_LOOKUP_CLIENT, BIO_LOOKUP_SERVER
  620. };
  621. int BIO_lookup(const char *host, const char *service,
  622. enum BIO_lookup_type lookup_type,
  623. int family, int socktype, BIO_ADDRINFO **res);
  624. int BIO_lookup_ex(const char *host, const char *service,
  625. int lookup_type, int family, int socktype, int protocol,
  626. BIO_ADDRINFO **res);
  627. int BIO_sock_error(int sock);
  628. int BIO_socket_ioctl(int fd, long type, void *arg);
  629. int BIO_socket_nbio(int fd, int mode);
  630. int BIO_sock_init(void);
  631. # ifndef OPENSSL_NO_DEPRECATED_1_1_0
  632. # define BIO_sock_cleanup() while(0) continue
  633. # endif
  634. int BIO_set_tcp_ndelay(int sock, int turn_on);
  635. DEPRECATEDIN_1_1_0(struct hostent *BIO_gethostbyname(const char *name))
  636. DEPRECATEDIN_1_1_0(int BIO_get_port(const char *str, unsigned short *port_ptr))
  637. DEPRECATEDIN_1_1_0(int BIO_get_host_ip(const char *str, unsigned char *ip))
  638. DEPRECATEDIN_1_1_0(int BIO_get_accept_socket(char *host_port, int mode))
  639. DEPRECATEDIN_1_1_0(int BIO_accept(int sock, char **ip_port))
  640. union BIO_sock_info_u {
  641. BIO_ADDR *addr;
  642. };
  643. enum BIO_sock_info_type {
  644. BIO_SOCK_INFO_ADDRESS
  645. };
  646. int BIO_sock_info(int sock,
  647. enum BIO_sock_info_type type, union BIO_sock_info_u *info);
  648. # define BIO_SOCK_REUSEADDR 0x01
  649. # define BIO_SOCK_V6_ONLY 0x02
  650. # define BIO_SOCK_KEEPALIVE 0x04
  651. # define BIO_SOCK_NONBLOCK 0x08
  652. # define BIO_SOCK_NODELAY 0x10
  653. int BIO_socket(int domain, int socktype, int protocol, int options);
  654. int BIO_connect(int sock, const BIO_ADDR *addr, int options);
  655. int BIO_bind(int sock, const BIO_ADDR *addr, int options);
  656. int BIO_listen(int sock, const BIO_ADDR *addr, int options);
  657. int BIO_accept_ex(int accept_sock, BIO_ADDR *addr, int options);
  658. int BIO_closesocket(int sock);
  659. BIO *BIO_new_socket(int sock, int close_flag);
  660. BIO *BIO_new_connect(const char *host_port);
  661. BIO *BIO_new_accept(const char *host_port);
  662. # endif /* OPENSSL_NO_SOCK*/
  663. BIO *BIO_new_fd(int fd, int close_flag);
  664. int BIO_new_bio_pair(BIO **bio1, size_t writebuf1,
  665. BIO **bio2, size_t writebuf2);
  666. /*
  667. * If successful, returns 1 and in *bio1, *bio2 two BIO pair endpoints.
  668. * Otherwise returns 0 and sets *bio1 and *bio2 to NULL. Size 0 uses default
  669. * value.
  670. */
  671. void BIO_copy_next_retry(BIO *b);
  672. /*
  673. * long BIO_ghbn_ctrl(int cmd,int iarg,char *parg);
  674. */
  675. # define ossl_bio__attr__(x)
  676. # if defined(__GNUC__) && defined(__STDC_VERSION__) \
  677. && !defined(__APPLE__)
  678. /*
  679. * Because we support the 'z' modifier, which made its appearance in C99,
  680. * we can't use __attribute__ with pre C99 dialects.
  681. */
  682. # if __STDC_VERSION__ >= 199901L
  683. # undef ossl_bio__attr__
  684. # define ossl_bio__attr__ __attribute__
  685. # if __GNUC__*10 + __GNUC_MINOR__ >= 44
  686. # define ossl_bio__printf__ __gnu_printf__
  687. # else
  688. # define ossl_bio__printf__ __printf__
  689. # endif
  690. # endif
  691. # endif
  692. int BIO_printf(BIO *bio, const char *format, ...)
  693. ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 3)));
  694. int BIO_vprintf(BIO *bio, const char *format, va_list args)
  695. ossl_bio__attr__((__format__(ossl_bio__printf__, 2, 0)));
  696. int BIO_snprintf(char *buf, size_t n, const char *format, ...)
  697. ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 4)));
  698. int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args)
  699. ossl_bio__attr__((__format__(ossl_bio__printf__, 3, 0)));
  700. # undef ossl_bio__attr__
  701. # undef ossl_bio__printf__
  702. BIO_METHOD *BIO_meth_new(int type, const char *name);
  703. void BIO_meth_free(BIO_METHOD *biom);
  704. int (*BIO_meth_get_write(const BIO_METHOD *biom)) (BIO *, const char *, int);
  705. int (*BIO_meth_get_write_ex(const BIO_METHOD *biom)) (BIO *, const char *, size_t,
  706. size_t *);
  707. int BIO_meth_set_write(BIO_METHOD *biom,
  708. int (*write) (BIO *, const char *, int));
  709. int BIO_meth_set_write_ex(BIO_METHOD *biom,
  710. int (*bwrite) (BIO *, const char *, size_t, size_t *));
  711. int (*BIO_meth_get_read(const BIO_METHOD *biom)) (BIO *, char *, int);
  712. int (*BIO_meth_get_read_ex(const BIO_METHOD *biom)) (BIO *, char *, size_t, size_t *);
  713. int BIO_meth_set_read(BIO_METHOD *biom,
  714. int (*read) (BIO *, char *, int));
  715. int BIO_meth_set_read_ex(BIO_METHOD *biom,
  716. int (*bread) (BIO *, char *, size_t, size_t *));
  717. int (*BIO_meth_get_puts(const BIO_METHOD *biom)) (BIO *, const char *);
  718. int BIO_meth_set_puts(BIO_METHOD *biom,
  719. int (*puts) (BIO *, const char *));
  720. int (*BIO_meth_get_gets(const BIO_METHOD *biom)) (BIO *, char *, int);
  721. int BIO_meth_set_gets(BIO_METHOD *biom,
  722. int (*gets) (BIO *, char *, int));
  723. long (*BIO_meth_get_ctrl(const BIO_METHOD *biom)) (BIO *, int, long, void *);
  724. int BIO_meth_set_ctrl(BIO_METHOD *biom,
  725. long (*ctrl) (BIO *, int, long, void *));
  726. int (*BIO_meth_get_create(const BIO_METHOD *bion)) (BIO *);
  727. int BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *));
  728. int (*BIO_meth_get_destroy(const BIO_METHOD *biom)) (BIO *);
  729. int BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *));
  730. long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *biom))
  731. (BIO *, int, BIO_info_cb *);
  732. int BIO_meth_set_callback_ctrl(BIO_METHOD *biom,
  733. long (*callback_ctrl) (BIO *, int,
  734. BIO_info_cb *));
  735. # ifdef __cplusplus
  736. }
  737. # endif
  738. #endif