← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/boringssl/src/include/openssl/bio.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/boringssl/src/include/openssl/bio.h
1
 
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2
 
 * All rights reserved.
3
 
 *
4
 
 * This package is an SSL implementation written
5
 
 * by Eric Young (eay@cryptsoft.com).
6
 
 * The implementation was written so as to conform with Netscapes SSL.
7
 
 *
8
 
 * This library is free for commercial and non-commercial use as long as
9
 
 * the following conditions are aheared to.  The following conditions
10
 
 * apply to all code found in this distribution, be it the RC4, RSA,
11
 
 * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12
 
 * included with this distribution is covered by the same copyright terms
13
 
 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14
 
 *
15
 
 * Copyright remains Eric Young's, and as such any Copyright notices in
16
 
 * the code are not to be removed.
17
 
 * If this package is used in a product, Eric Young should be given attribution
18
 
 * as the author of the parts of the library used.
19
 
 * This can be in the form of a textual message at program startup or
20
 
 * in documentation (online or textual) provided with the package.
21
 
 *
22
 
 * Redistribution and use in source and binary forms, with or without
23
 
 * modification, are permitted provided that the following conditions
24
 
 * are met:
25
 
 * 1. Redistributions of source code must retain the copyright
26
 
 *    notice, this list of conditions and the following disclaimer.
27
 
 * 2. Redistributions in binary form must reproduce the above copyright
28
 
 *    notice, this list of conditions and the following disclaimer in the
29
 
 *    documentation and/or other materials provided with the distribution.
30
 
 * 3. All advertising materials mentioning features or use of this software
31
 
 *    must display the following acknowledgement:
32
 
 *    "This product includes cryptographic software written by
33
 
 *     Eric Young (eay@cryptsoft.com)"
34
 
 *    The word 'cryptographic' can be left out if the rouines from the library
35
 
 *    being used are not cryptographic related :-).
36
 
 * 4. If you include any Windows specific code (or a derivative thereof) from
37
 
 *    the apps directory (application code) you must include an acknowledgement:
38
 
 *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39
 
 *
40
 
 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41
 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43
 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44
 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45
 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46
 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48
 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49
 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50
 
 * SUCH DAMAGE.
51
 
 *
52
 
 * The licence and distribution terms for any publically available version or
53
 
 * derivative of this code cannot be changed.  i.e. this code cannot simply be
54
 
 * copied and put under another distribution licence
55
 
 * [including the GNU Public Licence.] */
56
 
 
57
 
#ifndef OPENSSL_HEADER_BIO_H
58
 
#define OPENSSL_HEADER_BIO_H
59
 
 
60
 
#include <openssl/base.h>
61
 
 
62
 
#include <stdio.h>  /* For FILE */
63
 
 
64
 
#include <openssl/err.h> /* for ERR_print_errors_fp */
65
 
#include <openssl/ex_data.h>
66
 
#include <openssl/stack.h>
67
 
#include <openssl/thread.h>
68
 
 
69
 
#if defined(__cplusplus)
70
 
extern "C" {
71
 
#endif
72
 
 
73
 
 
74
 
/* BIO abstracts over a file-descriptor like interface. */
75
 
 
76
 
 
77
 
/* Allocation and freeing. */
78
 
 
79
 
DEFINE_STACK_OF(BIO);
80
 
 
81
 
/* BIO_new creates a new BIO with the given type and a reference count of one.
82
 
 * It returns the fresh |BIO|, or NULL on error. */
83
 
OPENSSL_EXPORT BIO *BIO_new(const BIO_METHOD *type);
84
 
 
85
 
/* BIO_free decrements the reference count of |bio|. If the reference count
86
 
 * drops to zero, it (optionally) calls the BIO's callback with |BIO_CB_FREE|,
87
 
 * frees the ex_data and then, if the BIO has a destroy callback for the
88
 
 * method, calls it. Finally it frees |bio| itself. It then repeats that for
89
 
 * the next BIO in the chain, if any.
90
 
 *
91
 
 * It returns one on success or zero otherwise. */
92
 
OPENSSL_EXPORT int BIO_free(BIO *bio);
93
 
 
94
 
/* BIO_vfree performs the same actions as |BIO_free|, but has a void return
95
 
 * value. This is provided for API-compat.
96
 
 *
97
 
 * TODO(fork): remove. */
98
 
OPENSSL_EXPORT void BIO_vfree(BIO *bio);
99
 
 
100
 
/* BIO_up_ref increments the reference count of |bio| and returns it. */
101
 
OPENSSL_EXPORT BIO *BIO_up_ref(BIO *bio);
102
 
 
103
 
 
104
 
/* Basic I/O. */
105
 
 
106
 
/* BIO_read attempts to read |len| bytes into |data|. It returns the number of
107
 
 * bytes read, zero on EOF, or a negative number on error. */
108
 
OPENSSL_EXPORT int BIO_read(BIO *bio, void *data, int len);
109
 
 
110
 
/* BIO_gets "reads a line" from |bio| and puts at most |size| bytes into |buf|.
111
 
 * It returns the number of bytes read or a negative number on error. The
112
 
 * phrase "reads a line" is in quotes in the previous sentence because the
113
 
 * exact operation depends on the BIO's method. For example, a digest BIO will
114
 
 * return the digest in response to a |BIO_gets| call.
115
 
 *
116
 
 * TODO(fork): audit the set of BIOs that we end up needing. If all actually
117
 
 * return a line for this call, remove the warning above. */
118
 
OPENSSL_EXPORT int BIO_gets(BIO *bio, char *buf, int size);
119
 
 
120
 
/* BIO_write writes |len| bytes from |data| to BIO. It returns the number of
121
 
 * bytes written or a negative number on error. */
122
 
OPENSSL_EXPORT int BIO_write(BIO *bio, const void *data, int len);
123
 
 
124
 
/* BIO_puts writes a NUL terminated string from |buf| to |bio|. It returns the
125
 
 * number of bytes written or a negative number on error. */
126
 
OPENSSL_EXPORT int BIO_puts(BIO *bio, const char *buf);
127
 
 
128
 
/* BIO_flush flushes any buffered output. It returns one on success and zero
129
 
 * otherwise. */
130
 
OPENSSL_EXPORT int BIO_flush(BIO *bio);
131
 
 
132
 
 
133
 
/* Low-level control functions.
134
 
 *
135
 
 * These are generic functions for sending control requests to a BIO. In
136
 
 * general one should use the wrapper functions like |BIO_get_close|. */
137
 
 
138
 
/* BIO_ctrl sends the control request |cmd| to |bio|. The |cmd| argument should
139
 
 * be one of the |BIO_C_*| values. */
140
 
OPENSSL_EXPORT long BIO_ctrl(BIO *bio, int cmd, long larg, void *parg);
141
 
 
142
 
/* BIO_ptr_ctrl acts like |BIO_ctrl| but passes the address of a |void*|
143
 
 * pointer as |parg| and returns the value that is written to it, or NULL if
144
 
 * the control request returns <= 0. */
145
 
OPENSSL_EXPORT char *BIO_ptr_ctrl(BIO *bp, int cmd, long larg);
146
 
 
147
 
/* BIO_int_ctrl acts like |BIO_ctrl| but passes the address of a copy of |iarg|
148
 
 * as |parg|. */
149
 
OPENSSL_EXPORT long BIO_int_ctrl(BIO *bp, int cmd, long larg, int iarg);
150
 
 
151
 
/* BIO_reset resets |bio| to its initial state, the precise meaning of which
152
 
 * depends on the concrete type of |bio|. It returns one on success and zero
153
 
 * otherwise. */
154
 
OPENSSL_EXPORT int BIO_reset(BIO *bio);
155
 
 
156
 
/* BIO_set_flags ORs |flags| with |bio->flags|. */
157
 
OPENSSL_EXPORT void BIO_set_flags(BIO *bio, int flags);
158
 
 
159
 
/* BIO_test_flags returns |bio->flags| AND |flags|. */
160
 
OPENSSL_EXPORT int BIO_test_flags(const BIO *bio, int flags);
161
 
 
162
 
/* BIO_should_read returns non-zero if |bio| encountered a temporary error
163
 
 * while reading (i.e. EAGAIN), indicating that the caller should retry the
164
 
 * read. */
165
 
OPENSSL_EXPORT int BIO_should_read(const BIO *bio);
166
 
 
167
 
/* BIO_should_write returns non-zero if |bio| encountered a temporary error
168
 
 * while writing (i.e. EAGAIN), indicating that the caller should retry the
169
 
 * write. */
170
 
OPENSSL_EXPORT int BIO_should_write(const BIO *bio);
171
 
 
172
 
/* BIO_should_retry returns non-zero if the reason that caused a failed I/O
173
 
 * operation is temporary and thus the operation should be retried. Otherwise,
174
 
 * it was a permanent error and it returns zero. */
175
 
OPENSSL_EXPORT int BIO_should_retry(const BIO *bio);
176
 
 
177
 
/* BIO_should_io_special returns non-zero if |bio| encountered a temporary
178
 
 * error while performing a special I/O operation, indicating that the caller
179
 
 * should retry. The operation that caused the error is returned by
180
 
 * |BIO_get_retry_reason|. */
181
 
OPENSSL_EXPORT int BIO_should_io_special(const BIO *bio);
182
 
 
183
 
/* BIO_RR_SSL_X509_LOOKUP indicates that an SSL BIO blocked because the SSL
184
 
 * library returned with SSL_ERROR_WANT_X509_LOOKUP.
185
 
 *
186
 
 * TODO(fork): remove. */
187
 
#define BIO_RR_SSL_X509_LOOKUP 0x01
188
 
 
189
 
/* BIO_RR_CONNECT indicates that a connect would have blocked */
190
 
#define BIO_RR_CONNECT 0x02
191
 
 
192
 
/* BIO_RR_ACCEPT indicates that an accept would have blocked */
193
 
#define BIO_RR_ACCEPT 0x03
194
 
 
195
 
/* BIO_RR_SSL_CHANNEL_ID_LOOKUP indicates that the ChannelID code cannot find
196
 
 * a private key for a TLS connection. */
197
 
#define BIO_RR_SSL_CHANNEL_ID_LOOKUP 0x04
198
 
 
199
 
/* BIO_get_retry_reason returns the special I/O operation that needs to be
200
 
 * retried. The return value is one of the |BIO_RR_*| values. */
201
 
OPENSSL_EXPORT int BIO_get_retry_reason(const BIO *bio);
202
 
 
203
 
/* BIO_clear_flags ANDs |bio->flags| with the bitwise-complement of |flags|. */
204
 
OPENSSL_EXPORT void BIO_clear_flags(BIO *bio, int flags);
205
 
 
206
 
/* BIO_set_retry_read sets the |BIO_FLAGS_READ| and |BIO_FLAGS_SHOULD_RETRY|
207
 
 * flags on |bio|. */
208
 
OPENSSL_EXPORT void BIO_set_retry_read(BIO *bio);
209
 
 
210
 
/* BIO_set_retry_write sets the |BIO_FLAGS_WRITE| and |BIO_FLAGS_SHOULD_RETRY|
211
 
 * flags on |bio|. */
212
 
OPENSSL_EXPORT void BIO_set_retry_write(BIO *bio);
213
 
 
214
 
/* BIO_get_retry_flags gets the |BIO_FLAGS_READ|, |BIO_FLAGS_WRITE|,
215
 
 * |BIO_FLAGS_IO_SPECIAL| and |BIO_FLAGS_SHOULD_RETRY| flags from |bio|. */
216
 
OPENSSL_EXPORT int BIO_get_retry_flags(BIO *bio);
217
 
 
218
 
/* BIO_clear_retry_flags clears the |BIO_FLAGS_READ|, |BIO_FLAGS_WRITE|,
219
 
 * |BIO_FLAGS_IO_SPECIAL| and |BIO_FLAGS_SHOULD_RETRY| flags from |bio|. */
220
 
OPENSSL_EXPORT void BIO_clear_retry_flags(BIO *bio);
221
 
 
222
 
/* BIO_method_type returns the type of |bio|, which is one of the |BIO_TYPE_*|
223
 
 * values. */
224
 
OPENSSL_EXPORT int BIO_method_type(const BIO *bio);
225
 
 
226
 
/* bio_info_cb is the type of a callback function that can be called for most
227
 
 * BIO operations. The |event| argument is one of |BIO_CB_*| and can be ORed
228
 
 * with |BIO_CB_RETURN| if the callback is being made after the operation in
229
 
 * question. In that case, |return_value| will contain the return value from
230
 
 * the operation. */
231
 
typedef long (*bio_info_cb)(BIO *bio, int event, const char *parg, int cmd,
232
 
                            long larg, long return_value);
233
 
 
234
 
/* BIO_callback_ctrl allows the callback function to be manipulated. The |cmd|
235
 
 * arg will generally be |BIO_CTRL_SET_CALLBACK| but arbitary command values
236
 
 * can be interpreted by the |BIO|. */
237
 
OPENSSL_EXPORT long BIO_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp);
238
 
 
239
 
/* BIO_pending returns the number of bytes pending to be read. */
240
 
OPENSSL_EXPORT size_t BIO_pending(const BIO *bio);
241
 
 
242
 
/* BIO_ctrl_pending calls |BIO_pending| and exists only for compatibility with
243
 
 * OpenSSL. */
244
 
OPENSSL_EXPORT size_t BIO_ctrl_pending(const BIO *bio);
245
 
 
246
 
/* BIO_wpending returns the number of bytes pending to be written. */
247
 
OPENSSL_EXPORT size_t BIO_wpending(const BIO *bio);
248
 
 
249
 
/* BIO_set_close sets the close flag for |bio|. The meaning of which depends on
250
 
 * the type of |bio| but, for example, a memory BIO interprets the close flag
251
 
 * as meaning that it owns its buffer. It returns one on success and zero
252
 
 * otherwise. */
253
 
OPENSSL_EXPORT int BIO_set_close(BIO *bio, int close_flag);
254
 
 
255
 
/* BIO_set_callback sets a callback function that will be called before and
256
 
 * after most operations. See the comment above |bio_info_cb|. */
257
 
OPENSSL_EXPORT void BIO_set_callback(BIO *bio, bio_info_cb callback_func);
258
 
 
259
 
/* BIO_set_callback_arg sets the opaque pointer value that can be read within a
260
 
 * callback with |BIO_get_callback_arg|. */
261
 
OPENSSL_EXPORT void BIO_set_callback_arg(BIO *bio, char *arg);
262
 
 
263
 
/* BIO_get_callback_arg returns the last value of the opaque callback pointer
264
 
 * set by |BIO_set_callback_arg|. */
265
 
OPENSSL_EXPORT char *BIO_get_callback_arg(const BIO *bio);
266
 
 
267
 
/* BIO_number_read returns the number of bytes that have been read from
268
 
 * |bio|. */
269
 
OPENSSL_EXPORT size_t BIO_number_read(const BIO *bio);
270
 
 
271
 
/* BIO_number_written returns the number of bytes that have been written to
272
 
 * |bio|. */
273
 
OPENSSL_EXPORT size_t BIO_number_written(const BIO *bio);
274
 
 
275
 
 
276
 
/* Managing chains of BIOs.
277
 
 *
278
 
 * BIOs can be put into chains where the output of one is used as the input of
279
 
 * the next etc. The most common case is a buffering BIO, which accepts and
280
 
 * buffers writes until flushed into the next BIO in the chain. */
281
 
 
282
 
/* BIO_push adds |appended_bio| to the end of the chain with |bio| at the head.
283
 
 * It returns |bio|. Note that |appended_bio| may be the head of a chain itself
284
 
 * and thus this function can be used to join two chains.
285
 
 *
286
 
 * BIO_push takes ownership of the caller's reference to |appended_bio|. */
287
 
OPENSSL_EXPORT BIO *BIO_push(BIO *bio, BIO *appended_bio);
288
 
 
289
 
/* BIO_pop removes |bio| from the head of a chain and returns the next BIO in
290
 
 * the chain, or NULL if there is no next BIO.
291
 
 *
292
 
 * The caller takes ownership of the chain's reference to |bio|. */
293
 
OPENSSL_EXPORT BIO *BIO_pop(BIO *bio);
294
 
 
295
 
/* BIO_next returns the next BIO in the chain after |bio|, or NULL if there is
296
 
 * no such BIO. */
297
 
OPENSSL_EXPORT BIO *BIO_next(BIO *bio);
298
 
 
299
 
/* BIO_free_all calls |BIO_free|.
300
 
 *
301
 
 * TODO(fork): update callers and remove. */
302
 
OPENSSL_EXPORT void BIO_free_all(BIO *bio);
303
 
 
304
 
/* BIO_find_type walks a chain of BIOs and returns the first that matches
305
 
 * |type|, which is one of the |BIO_TYPE_*| values. */
306
 
OPENSSL_EXPORT BIO *BIO_find_type(BIO *bio, int type);
307
 
 
308
 
/* BIO_copy_next_retry sets the retry flags and |retry_reason| of |bio| from
309
 
 * the next BIO in the chain. */
310
 
OPENSSL_EXPORT void BIO_copy_next_retry(BIO *bio);
311
 
 
312
 
 
313
 
/* Printf functions.
314
 
 *
315
 
 * These functions are versions of printf functions that output to a BIO rather
316
 
 * than a FILE. */
317
 
#ifdef __GNUC__
318
 
#define __bio_h__attr__ __attribute__
319
 
#else
320
 
#define __bio_h__attr__(x)
321
 
#endif
322
 
OPENSSL_EXPORT int BIO_printf(BIO *bio, const char *format, ...)
323
 
    __bio_h__attr__((__format__(__printf__, 2, 3)));
324
 
#undef __bio_h__attr__
325
 
 
326
 
 
327
 
/* Utility functions. */
328
 
 
329
 
/* BIO_indent prints min(|indent|, |max_indent|) spaces. It returns one on
330
 
 * success and zero otherwise. */
331
 
OPENSSL_EXPORT int BIO_indent(BIO *bio, unsigned indent, unsigned max_indent);
332
 
 
333
 
/* BIO_hexdump writes a hex dump of |data| to |bio|. Each line will be indented
334
 
 * by |indent| spaces. */
335
 
OPENSSL_EXPORT int BIO_hexdump(BIO *bio, const uint8_t *data, size_t len,
336
 
                               unsigned indent);
337
 
 
338
 
/* BIO_print_errors prints the current contents of the error stack to |bio|
339
 
 * using human readable strings where possible. */
340
 
OPENSSL_EXPORT void BIO_print_errors(BIO *bio);
341
 
 
342
 
/* BIO_read_asn1 reads a single ASN.1 object from |bio|. If successful it sets
343
 
 * |*out| to be an allocated buffer (that should be freed with |OPENSSL_free|),
344
 
 * |*out_size| to the length, in bytes, of that buffer and returns one.
345
 
 * Otherwise it returns zero.
346
 
 *
347
 
 * If the length of the object is greater than |max_len| or 2^32 then the
348
 
 * function will fail. Long-form tags are not supported. If the length of the
349
 
 * object is indefinite the full contents of |bio| are read, unless it would be
350
 
 * greater than |max_len|, in which case the function fails.
351
 
 *
352
 
 * If the function fails then some unknown amount of data may have been read
353
 
 * from |bio|. */
354
 
OPENSSL_EXPORT int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len,
355
 
                                 size_t max_len);
356
 
 
357
 
 
358
 
/* Memory BIOs.
359
 
 *
360
 
 * Memory BIOs can be used as a read-only source (with |BIO_new_mem_buf|) or a
361
 
 * writable sink (with |BIO_new|, |BIO_s_mem| and |BIO_get_mem_buf|). Data
362
 
 * written to a writable, memory BIO can be recalled by reading from it.
363
 
 *
364
 
 * Calling |BIO_reset| on a read-only BIO resets it to the original contents.
365
 
 * On a writable BIO, it clears any data.
366
 
 *
367
 
 * If the close flag is set to |BIO_NOCLOSE| (not the default) then the
368
 
 * underlying |BUF_MEM| will not be freed when the |BIO| is freed.
369
 
 *
370
 
 * Memory BIOs support |BIO_gets| and |BIO_puts|.
371
 
 *
372
 
 * |BIO_eof| is true if no data is in the BIO.
373
 
 *
374
 
 * |BIO_ctrl_pending| returns the number of bytes currently stored. */
375
 
 
376
 
/* BIO_s_mem returns a |BIO_METHOD| that uses a in-memory buffer. */
377
 
OPENSSL_EXPORT const BIO_METHOD *BIO_s_mem(void);
378
 
 
379
 
/* BIO_new_mem_buf creates BIO that reads and writes from |len| bytes at |buf|.
380
 
 * It does not take ownership of |buf|. It returns the BIO or NULL on error.
381
 
 *
382
 
 * If |len| is negative, then |buf| is treated as a NUL-terminated string, but
383
 
 * don't depend on this in new code. */
384
 
OPENSSL_EXPORT BIO *BIO_new_mem_buf(void *buf, int len);
385
 
 
386
 
/* BIO_mem_contents sets |*out_contents| to point to the current contents of
387
 
 * |bio| and |*out_len| to contain the length of that data. It returns one on
388
 
 * success and zero otherwise. */
389
 
OPENSSL_EXPORT int BIO_mem_contents(const BIO *bio,
390
 
                                    const uint8_t **out_contents,
391
 
                                    size_t *out_len);
392
 
 
393
 
/* BIO_get_mem_data sets |*contents| to point to the current contents of |bio|
394
 
 * and returns the length of the data.
395
 
 *
396
 
 * WARNING: don't use this, use |BIO_mem_contents|. A return value of zero from
397
 
 * this function can mean either that it failed or that the memory buffer is
398
 
 * empty. */
399
 
OPENSSL_EXPORT long BIO_get_mem_data(BIO *bio, char **contents);
400
 
 
401
 
/* BIO_get_mem_ptr sets |*out| to a BUF_MEM containing the current contents of
402
 
 * |bio|. It returns one on success or zero on error. */
403
 
OPENSSL_EXPORT int BIO_get_mem_ptr(BIO *bio, BUF_MEM **out);
404
 
 
405
 
/* BIO_set_mem_buf sets |b| as the contents of |bio|. If |take_ownership| is
406
 
 * non-zero, then |b| will be freed when |bio| is closed. Returns one on
407
 
 * success or zero otherwise. */
408
 
OPENSSL_EXPORT int BIO_set_mem_buf(BIO *bio, BUF_MEM *b, int take_ownership);
409
 
 
410
 
/* BIO_set_mem_eof_return sets the value that will be returned from reading
411
 
 * |bio| when empty. If |eof_value| is zero then an empty memory BIO will
412
 
 * return EOF (that is it will return zero and |BIO_should_retry| will be
413
 
 * false). If |eof_value| is non zero then it will return |eof_value| when it
414
 
 * is empty and it will set the read retry flag (that is |BIO_read_retry| is
415
 
 * true). To avoid ambiguity with a normal positive return value, |eof_value|
416
 
 * should be set to a negative value, typically -1.
417
 
 *
418
 
 * For a read-only BIO, the default is zero (EOF). For a writable BIO, the
419
 
 * default is -1 so that additional data can be written once exhausted. */
420
 
OPENSSL_EXPORT int BIO_set_mem_eof_return(BIO *bio, int eof_value);
421
 
 
422
 
 
423
 
/* File descriptor BIOs.
424
 
 *
425
 
 * File descriptor BIOs are wrappers around the system's |read| and |write|
426
 
 * functions. If the close flag is set then then |close| is called on the
427
 
 * underlying file descriptor when the BIO is freed.
428
 
 *
429
 
 * |BIO_reset| attempts to seek the file pointer to the start of file using
430
 
 * |lseek|.
431
 
 *
432
 
 * |BIO_seek| sets the file pointer to position |off| from start of file using
433
 
 * |lseek|.
434
 
 *
435
 
 * |BIO_tell| returns the current file position. */
436
 
 
437
 
/* BIO_s_fd returns a |BIO_METHOD| for file descriptor fds. */
438
 
OPENSSL_EXPORT const BIO_METHOD *BIO_s_fd(void);
439
 
 
440
 
/* BIO_new_fd creates a new file descriptor BIO wrapping |fd|. If |close_flag|
441
 
 * is non-zero, then |fd| will be closed when the BIO is. */
442
 
OPENSSL_EXPORT BIO *BIO_new_fd(int fd, int close_flag);
443
 
 
444
 
/* BIO_set_fd sets the file descriptor of |bio| to |fd|. If |close_flag| is
445
 
 * non-zero then |fd| will be closed when |bio| is. It returns one on success
446
 
 * or zero on error. */
447
 
OPENSSL_EXPORT int BIO_set_fd(BIO *bio, int fd, int close_flag);
448
 
 
449
 
/* BIO_get_fd sets |*out_fd| to the file descriptor currently in use by |bio|.
450
 
 * It returns one on success and zero on error. */
451
 
OPENSSL_EXPORT int BIO_get_fd(BIO *bio, int *out_fd);
452
 
 
453
 
 
454
 
/* File BIOs.
455
 
 *
456
 
 * File BIOs are wrappers around a C |FILE| object.
457
 
 *
458
 
 * |BIO_flush| on a file BIO calls |fflush| on the wrapped stream.
459
 
 *
460
 
 * |BIO_reset| attempts to seek the file pointer to the start of file using
461
 
 * |fseek|.
462
 
 *
463
 
 * |BIO_seek| sets the file pointer to the given position from the start of
464
 
 * file using |fseek|.
465
 
 *
466
 
 * |BIO_eof| calls |feof|.
467
 
 *
468
 
 * Setting the close flag causes |fclose| to be called on the stream when the
469
 
 * BIO is freed. */
470
 
 
471
 
/* BIO_s_file returns a BIO_METHOD that wraps a |FILE|. */
472
 
OPENSSL_EXPORT const BIO_METHOD *BIO_s_file(void);
473
 
 
474
 
/* BIO_new_file creates a file BIO by opening |filename| with the given mode.
475
 
 * See the |fopen| manual page for details of the mode argument. */
476
 
OPENSSL_EXPORT BIO *BIO_new_file(const char *filename, const char *mode);
477
 
 
478
 
/* BIO_new_fp creates a new file BIO that wraps the given |FILE|. If
479
 
 * |close_flag| is |BIO_CLOSE|, then |fclose| will be called on |stream| when
480
 
 * the BIO is closed. */
481
 
OPENSSL_EXPORT BIO *BIO_new_fp(FILE *stream, int close_flag);
482
 
 
483
 
/* BIO_get_fp sets |*out_file| to the current |FILE| for |bio|. It returns one
484
 
 * on success and zero otherwise. */
485
 
OPENSSL_EXPORT int BIO_get_fp(BIO *bio, FILE **out_file);
486
 
 
487
 
/* BIO_set_fp sets the |FILE| for |bio|. If |close_flag| is |BIO_CLOSE| then
488
 
 * |fclose| will be called on |file| when |bio| is closed. It returns one on
489
 
 * sucess and zero otherwise. */
490
 
OPENSSL_EXPORT int BIO_set_fp(BIO *bio, FILE *file, int close_flag);
491
 
 
492
 
/* BIO_read_filename opens |filename| for reading and sets the result as the
493
 
 * |FILE| for |bio|. It returns one on success and zero otherwise. The |FILE|
494
 
 * will be closed when |bio| is freed. */
495
 
OPENSSL_EXPORT int BIO_read_filename(BIO *bio, const char *filename);
496
 
 
497
 
/* BIO_write_filename opens |filename| for writing and sets the result as the
498
 
 * |FILE| for |bio|. It returns one on success and zero otherwise. The |FILE|
499
 
 * will be closed when |bio| is freed. */
500
 
OPENSSL_EXPORT int BIO_write_filename(BIO *bio, const char *filename);
501
 
 
502
 
/* BIO_append_filename opens |filename| for appending and sets the result as
503
 
 * the |FILE| for |bio|. It returns one on success and zero otherwise. The
504
 
 * |FILE| will be closed when |bio| is freed. */
505
 
OPENSSL_EXPORT int BIO_append_filename(BIO *bio, const char *filename);
506
 
 
507
 
/* BIO_rw_filename opens |filename| for reading and writing and sets the result
508
 
 * as the |FILE| for |bio|. It returns one on success and zero otherwise. The
509
 
 * |FILE| will be closed when |bio| is freed. */
510
 
OPENSSL_EXPORT int BIO_rw_filename(BIO *bio, const char *filename);
511
 
 
512
 
 
513
 
/* Buffer BIOs.
514
 
 *
515
 
 * Buffer BIOs are a filter-type BIO, i.e. they are designed to be used in a
516
 
 * chain of BIOs. They provide buffering to reduce the number of operations on
517
 
 * the underlying BIOs. */
518
 
 
519
 
OPENSSL_EXPORT const BIO_METHOD *BIO_f_buffer(void);
520
 
 
521
 
/* BIO_set_read_buffer_size sets the size, in bytes, of the read buffer and
522
 
 * clears it. It returns one on success and zero on failure. */
523
 
OPENSSL_EXPORT int BIO_set_read_buffer_size(BIO *bio, int buffer_size);
524
 
 
525
 
/* BIO_set_write_buffer_size sets the size, in bytes, of the write buffer and
526
 
 * clears it. It returns one on success and zero on failure. */
527
 
OPENSSL_EXPORT int BIO_set_write_buffer_size(BIO *bio, int buffer_size);
528
 
 
529
 
 
530
 
/* Socket BIOs. */
531
 
 
532
 
OPENSSL_EXPORT const BIO_METHOD *BIO_s_socket(void);
533
 
 
534
 
/* BIO_new_socket allocates and initialises a fresh BIO which will read and
535
 
 * write to the socket |fd|. If |close_flag| is |BIO_CLOSE| then closing the
536
 
 * BIO will close |fd|. It returns the fresh |BIO| or NULL on error. */
537
 
OPENSSL_EXPORT BIO *BIO_new_socket(int fd, int close_flag);
538
 
 
539
 
 
540
 
/* Connect BIOs.
541
 
 *
542
 
 * A connection BIO creates a network connection and transfers data over the
543
 
 * resulting socket. */
544
 
 
545
 
OPENSSL_EXPORT const BIO_METHOD *BIO_s_connect(void);
546
 
 
547
 
/* BIO_new_connect returns a BIO that connects to the given hostname and port.
548
 
 * The |host_and_optional_port| argument should be of the form
549
 
 * "www.example.com" or "www.example.com:443". If the port is omitted, it must
550
 
 * be provided with |BIO_set_conn_port|.
551
 
 *
552
 
 * It returns the new BIO on success, or NULL on error. */
553
 
OPENSSL_EXPORT BIO *BIO_new_connect(const char *host_and_optional_port);
554
 
 
555
 
/* BIO_set_conn_hostname sets |host_and_optional_port| as the hostname and
556
 
 * optional port that |bio| will connect to. If the port is omitted, it must be
557
 
 * provided with |BIO_set_conn_port|.
558
 
 *
559
 
 * It returns one on success and zero otherwise. */
560
 
OPENSSL_EXPORT int BIO_set_conn_hostname(BIO *bio,
561
 
                                         const char *host_and_optional_port);
562
 
 
563
 
/* BIO_set_conn_port sets |port_str| as the port or service name that |bio|
564
 
 * will connect to. It returns one on success and zero otherwise. */
565
 
OPENSSL_EXPORT int BIO_set_conn_port(BIO *bio, const char *port_str);
566
 
 
567
 
/* BIO_set_nbio sets whether |bio| will use non-blocking I/O operations. It
568
 
 * returns one on success and zero otherwise. */
569
 
OPENSSL_EXPORT int BIO_set_nbio(BIO *bio, int on);
570
 
 
571
 
 
572
 
/* Datagram BIOs.
573
 
 *
574
 
 * TODO(fork): not implemented. */
575
 
 
576
 
#define BIO_CTRL_DGRAM_QUERY_MTU 40 /* as kernel for current MTU */
577
 
 
578
 
#define BIO_CTRL_DGRAM_SET_MTU 42 /* set cached value for  MTU. want to use
579
 
                                     this if asking the kernel fails */
580
 
 
581
 
#define BIO_CTRL_DGRAM_MTU_EXCEEDED 43 /* check whether the MTU was exceed in
582
 
                                          the previous write operation. */
583
 
 
584
 
#define BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT \
585
 
  45 /* Next DTLS handshake timeout to adjust socket timeouts */
586
 
 
587
 
#define BIO_CTRL_DGRAM_GET_PEER           46
588
 
 
589
 
#define BIO_CTRL_DGRAM_GET_FALLBACK_MTU   47
590
 
 
591
 
 
592
 
/* BIO Pairs.
593
 
 *
594
 
 * BIO pairs provide a "loopback" like system: a pair of BIOs where data
595
 
 * written to one can be read from the other and vice versa. */
596
 
 
597
 
/* BIO_new_bio_pair sets |*out1| and |*out2| to two freshly created BIOs where
598
 
 * data written to one can be read from the other and vice versa. The
599
 
 * |writebuf1| argument gives the size of the buffer used in |*out1| and
600
 
 * |writebuf2| for |*out2|. It returns one on success and zero on error. */
601
 
OPENSSL_EXPORT int BIO_new_bio_pair(BIO **out1, size_t writebuf1, BIO **out2,
602
 
                                    size_t writebuf2);
603
 
 
604
 
/* BIO_new_bio_pair_external_buf is the same as |BIO_new_bio_pair| with the
605
 
 * difference that the caller keeps ownership of the write buffers
606
 
 * |ext_writebuf1_len| and |ext_writebuf2_len|. This is useful when using zero
607
 
 * copy API for read and write operations, in cases where the buffers need to
608
 
 * outlive the BIO pairs. It returns one on success and zero on error. */
609
 
OPENSSL_EXPORT int BIO_new_bio_pair_external_buf(BIO** bio1_p,
610
 
                                                 size_t writebuf1_len,
611
 
                                                 uint8_t* ext_writebuf1,
612
 
                                                 BIO** bio2_p,
613
 
                                                 size_t writebuf2_len,
614
 
                                                 uint8_t* ext_writebuf2);
615
 
 
616
 
/* BIO_ctrl_get_read_request returns the number of bytes that the other side of
617
 
 * |bio| tried (unsuccessfully) to read. */
618
 
OPENSSL_EXPORT size_t BIO_ctrl_get_read_request(BIO *bio);
619
 
 
620
 
/* BIO_ctrl_get_write_guarantee returns the number of bytes that |bio| (which
621
 
 * must have been returned by |BIO_new_bio_pair|) will accept on the next
622
 
 * |BIO_write| call. */
623
 
OPENSSL_EXPORT size_t BIO_ctrl_get_write_guarantee(BIO *bio);
624
 
 
625
 
/* BIO_shutdown_wr marks |bio| as closed, from the point of view of the other
626
 
 * side of the pair. Future |BIO_write| calls on |bio| will fail. It returns
627
 
 * one on success and zero otherwise. */
628
 
OPENSSL_EXPORT int BIO_shutdown_wr(BIO *bio);
629
 
 
630
 
 
631
 
/* Zero copy versions of BIO_read and BIO_write for BIO pairs. */
632
 
 
633
 
/* BIO_zero_copy_get_read_buf initiates a zero copy read operation.
634
 
 * |out_read_buf| is set to the internal read buffer, and |out_buf_offset| is
635
 
 * set to the current read position of |out_read_buf|. The number of bytes
636
 
 * available for read from |out_read_buf| + |out_buf_offset| is returned in
637
 
 * |out_available_bytes|. Note that this function might report fewer bytes
638
 
 * available than |BIO_pending|, if the internal ring buffer is wrapped. It
639
 
 * returns one on success. In case of error it returns zero and pushes to the
640
 
 * error stack.
641
 
 *
642
 
 * The zero copy read operation is completed by calling
643
 
 * |BIO_zero_copy_get_read_buf_done|. Neither |BIO_zero_copy_get_read_buf| nor
644
 
 * any other I/O read operation may be called while a zero copy read operation
645
 
 * is active. */
646
 
OPENSSL_EXPORT int BIO_zero_copy_get_read_buf(BIO* bio,
647
 
                                              uint8_t** out_read_buf,
648
 
                                              size_t* out_buf_offset,
649
 
                                              size_t* out_available_bytes);
650
 
 
651
 
/* BIO_zero_copy_get_read_buf_done must be called after reading from a BIO using
652
 
 * |BIO_zero_copy_get_read_buf| to finish the read operation. The |bytes_read|
653
 
 * argument is the number of bytes read.
654
 
 *
655
 
 * It returns one on success. In case of error it returns zero and pushes to the
656
 
 * error stack. */
657
 
OPENSSL_EXPORT int BIO_zero_copy_get_read_buf_done(BIO* bio, size_t bytes_read);
658
 
 
659
 
/* BIO_zero_copy_get_write_buf initiates a zero copy write operation.
660
 
 * |out_write_buf| is set to to the internal write buffer, and |out_buf_offset|
661
 
 * is set to the current write position of |out_write_buf|.
662
 
 * The number of bytes available for write from |out_write_buf| +
663
 
 * |out_buf_offset| is returned in |out_available_bytes|. Note that this
664
 
 * function might report fewer bytes available than
665
 
 * |BIO_ctrl_get_write_guarantee|, if the internal buffer is wrapped. It returns
666
 
 * one on success. In case of error it returns zero and pushes to the error
667
 
 * stack.
668
 
 *
669
 
 * The zero copy write operation is completed by calling
670
 
 * |BIO_zero_copy_get_write_buf_done|. Neither |BIO_zero_copy_get_write_buf|
671
 
 * nor any other I/O write operation may be called while a zero copy write
672
 
 * operation is active. */
673
 
OPENSSL_EXPORT int BIO_zero_copy_get_write_buf(BIO* bio,
674
 
                                               uint8_t** out_write_buf,
675
 
                                               size_t* out_buf_offset,
676
 
                                               size_t* out_available_bytes);
677
 
 
678
 
/* BIO_zero_copy_get_write_buf_done must be called after writing to a BIO using
679
 
 * |BIO_zero_copy_get_write_buf| to finish the write operation. The
680
 
 * |bytes_written| argument gives the number of bytes written.
681
 
 *
682
 
 * It returns one on success. In case of error it returns zero and pushes to the
683
 
 * error stack. */
684
 
OPENSSL_EXPORT int BIO_zero_copy_get_write_buf_done(BIO* bio,
685
 
                                                    size_t bytes_written);
686
 
 
687
 
 
688
 
/* BIO_NOCLOSE and |BIO_CLOSE| can be used as symbolic arguments when a "close
689
 
 * flag" is passed to a BIO function. */
690
 
#define BIO_NOCLOSE 0
691
 
#define BIO_CLOSE 1
692
 
 
693
 
/* These are passed to the BIO callback */
694
 
#define BIO_CB_FREE 0x01
695
 
#define BIO_CB_READ 0x02
696
 
#define BIO_CB_WRITE 0x03
697
 
#define BIO_CB_PUTS 0x04
698
 
#define BIO_CB_GETS 0x05
699
 
#define BIO_CB_CTRL 0x06
700
 
 
701
 
/* The callback is called before and after the underling operation,
702
 
 * The BIO_CB_RETURN flag indicates if it is after the call */
703
 
#define BIO_CB_RETURN 0x80
704
 
 
705
 
/* These are values of the |cmd| argument to |BIO_ctrl|. */
706
 
#define BIO_CTRL_RESET          1  /* opt - rewind/zero etc */
707
 
#define BIO_CTRL_EOF            2  /* opt - are we at the eof */
708
 
#define BIO_CTRL_INFO           3  /* opt - extra tit-bits */
709
 
#define BIO_CTRL_SET            4  /* man - set the 'IO' type */
710
 
#define BIO_CTRL_GET            5  /* man - get the 'IO' type */
711
 
#define BIO_CTRL_GET_CLOSE      8  /* man - set the 'close' on free */
712
 
#define BIO_CTRL_SET_CLOSE      9  /* man - set the 'close' on free */
713
 
#define BIO_CTRL_PENDING        10  /* opt - is their more data buffered */
714
 
#define BIO_CTRL_FLUSH          11  /* opt - 'flush' buffered output */
715
 
#define BIO_CTRL_WPENDING       13  /* opt - number of bytes still to write */
716
 
/* callback is int cb(BIO *bio,state,ret); */
717
 
#define BIO_CTRL_SET_CALLBACK   14  /* opt - set callback function */
718
 
#define BIO_CTRL_GET_CALLBACK   15  /* opt - set callback function */
719
 
#define BIO_CTRL_SET_FILENAME   30      /* BIO_s_file special */
720
 
 
721
 
 
722
 
/* Android compatibility section.
723
 
 *
724
 
 * A previous version of BoringSSL used in Android renamed ERR_print_errors_fp
725
 
 * to BIO_print_errors_fp. It has subsequently been renamed back to
726
 
 * ERR_print_errors_fp. */
727
 
#define BIO_print_errors_fp ERR_print_errors_fp
728
 
 
729
 
 
730
 
/* Private functions */
731
 
 
732
 
#define BIO_FLAGS_READ 0x01
733
 
#define BIO_FLAGS_WRITE 0x02
734
 
#define BIO_FLAGS_IO_SPECIAL 0x04
735
 
#define BIO_FLAGS_RWS (BIO_FLAGS_READ | BIO_FLAGS_WRITE | BIO_FLAGS_IO_SPECIAL)
736
 
#define BIO_FLAGS_SHOULD_RETRY 0x08
737
 
#define BIO_FLAGS_BASE64_NO_NL 0x100
738
 
/* This is used with memory BIOs: it means we shouldn't free up or change the
739
 
 * data in any way. */
740
 
#define BIO_FLAGS_MEM_RDONLY 0x200
741
 
 
742
 
/* These are the 'types' of BIOs */
743
 
#define BIO_TYPE_NONE 0
744
 
#define BIO_TYPE_MEM (1 | 0x0400)
745
 
#define BIO_TYPE_FILE (2 | 0x0400)
746
 
#define BIO_TYPE_FD (4 | 0x0400 | 0x0100)
747
 
#define BIO_TYPE_SOCKET (5 | 0x0400 | 0x0100)
748
 
#define BIO_TYPE_NULL (6 | 0x0400)
749
 
#define BIO_TYPE_SSL (7 | 0x0200)
750
 
#define BIO_TYPE_MD (8 | 0x0200)                /* passive filter */
751
 
#define BIO_TYPE_BUFFER (9 | 0x0200)            /* filter */
752
 
#define BIO_TYPE_CIPHER (10 | 0x0200)           /* filter */
753
 
#define BIO_TYPE_BASE64 (11 | 0x0200)           /* filter */
754
 
#define BIO_TYPE_CONNECT (12 | 0x0400 | 0x0100) /* socket - connect */
755
 
#define BIO_TYPE_ACCEPT (13 | 0x0400 | 0x0100)  /* socket for accept */
756
 
#define BIO_TYPE_PROXY_CLIENT (14 | 0x0200)     /* client proxy BIO */
757
 
#define BIO_TYPE_PROXY_SERVER (15 | 0x0200)     /* server proxy BIO */
758
 
#define BIO_TYPE_NBIO_TEST (16 | 0x0200)        /* server proxy BIO */
759
 
#define BIO_TYPE_NULL_FILTER (17 | 0x0200)
760
 
#define BIO_TYPE_BER (18 | 0x0200)        /* BER -> bin filter */
761
 
#define BIO_TYPE_BIO (19 | 0x0400)        /* (half a) BIO pair */
762
 
#define BIO_TYPE_LINEBUFFER (20 | 0x0200) /* filter */
763
 
#define BIO_TYPE_DGRAM (21 | 0x0400 | 0x0100)
764
 
#define BIO_TYPE_ASN1 (22 | 0x0200) /* filter */
765
 
#define BIO_TYPE_COMP (23 | 0x0200) /* filter */
766
 
 
767
 
#define BIO_TYPE_DESCRIPTOR 0x0100 /* socket, fd, connect or accept */
768
 
#define BIO_TYPE_FILTER 0x0200
769
 
#define BIO_TYPE_SOURCE_SINK 0x0400
770
 
 
771
 
struct bio_method_st {
772
 
  int type;
773
 
  const char *name;
774
 
  int (*bwrite)(BIO *, const char *, int);
775
 
  int (*bread)(BIO *, char *, int);
776
 
  /* TODO(fork): remove bputs. */
777
 
  int (*bputs)(BIO *, const char *);
778
 
  int (*bgets)(BIO *, char *, int);
779
 
  long (*ctrl)(BIO *, int, long, void *);
780
 
  int (*create)(BIO *);
781
 
  int (*destroy)(BIO *);
782
 
  long (*callback_ctrl)(BIO *, int, bio_info_cb);
783
 
};
784
 
 
785
 
struct bio_st {
786
 
  const BIO_METHOD *method;
787
 
  /* bio, mode, argp, argi, argl, ret */
788
 
  long (*callback)(struct bio_st *, int, const char *, int, long, long);
789
 
  char *cb_arg; /* first argument for the callback */
790
 
 
791
 
  /* init is non-zero if this |BIO| has been initialised. */
792
 
  int init;
793
 
  /* shutdown is often used by specific |BIO_METHOD|s to determine whether
794
 
   * they own some underlying resource. This flag can often by controlled by
795
 
   * |BIO_set_close|. For example, whether an fd BIO closes the underlying fd
796
 
   * when it, itself, is closed. */
797
 
  int shutdown;
798
 
  int flags;
799
 
  int retry_reason;
800
 
  /* num is a BIO-specific value. For example, in fd BIOs it's used to store a
801
 
   * file descriptor. */
802
 
  int num;
803
 
  CRYPTO_refcount_t references;
804
 
  void *ptr;
805
 
  /* next_bio points to the next |BIO| in a chain. This |BIO| owns a reference
806
 
   * to |next_bio|. */
807
 
  struct bio_st *next_bio; /* used by filter BIOs */
808
 
  size_t num_read, num_write;
809
 
};
810
 
 
811
 
#define BIO_C_SET_CONNECT                       100
812
 
#define BIO_C_DO_STATE_MACHINE                  101
813
 
#define BIO_C_SET_NBIO                          102
814
 
#define BIO_C_SET_PROXY_PARAM                   103
815
 
#define BIO_C_SET_FD                            104
816
 
#define BIO_C_GET_FD                            105
817
 
#define BIO_C_SET_FILE_PTR                      106
818
 
#define BIO_C_GET_FILE_PTR                      107
819
 
#define BIO_C_SET_FILENAME                      108
820
 
#define BIO_C_SET_SSL                           109
821
 
#define BIO_C_GET_SSL                           110
822
 
#define BIO_C_SET_MD                            111
823
 
#define BIO_C_GET_MD                            112
824
 
#define BIO_C_GET_CIPHER_STATUS                 113
825
 
#define BIO_C_SET_BUF_MEM                       114
826
 
#define BIO_C_GET_BUF_MEM_PTR                   115
827
 
#define BIO_C_GET_BUFF_NUM_LINES                116
828
 
#define BIO_C_SET_BUFF_SIZE                     117
829
 
#define BIO_C_SET_ACCEPT                        118
830
 
#define BIO_C_SSL_MODE                          119
831
 
#define BIO_C_GET_MD_CTX                        120
832
 
#define BIO_C_GET_PROXY_PARAM                   121
833
 
#define BIO_C_SET_BUFF_READ_DATA                122 /* data to read first */
834
 
#define BIO_C_GET_CONNECT                       123
835
 
#define BIO_C_GET_ACCEPT                        124
836
 
#define BIO_C_SET_SSL_RENEGOTIATE_BYTES         125
837
 
#define BIO_C_GET_SSL_NUM_RENEGOTIATES          126
838
 
#define BIO_C_SET_SSL_RENEGOTIATE_TIMEOUT       127
839
 
#define BIO_C_FILE_SEEK                         128
840
 
#define BIO_C_GET_CIPHER_CTX                    129
841
 
#define BIO_C_SET_BUF_MEM_EOF_RETURN            130/*return end of input value*/
842
 
#define BIO_C_SET_BIND_MODE                     131
843
 
#define BIO_C_GET_BIND_MODE                     132
844
 
#define BIO_C_FILE_TELL                         133
845
 
#define BIO_C_GET_SOCKS                         134
846
 
#define BIO_C_SET_SOCKS                         135
847
 
 
848
 
#define BIO_C_SET_WRITE_BUF_SIZE                136/* for BIO_s_bio */
849
 
#define BIO_C_GET_WRITE_BUF_SIZE                137
850
 
#define BIO_C_GET_WRITE_GUARANTEE               140
851
 
#define BIO_C_GET_READ_REQUEST                  141
852
 
#define BIO_C_SHUTDOWN_WR                       142
853
 
#define BIO_C_NREAD0                            143
854
 
#define BIO_C_NREAD                             144
855
 
#define BIO_C_NWRITE0                           145
856
 
#define BIO_C_NWRITE                            146
857
 
#define BIO_C_RESET_READ_REQUEST                147
858
 
#define BIO_C_SET_MD_CTX                        148
859
 
 
860
 
#define BIO_C_SET_PREFIX                        149
861
 
#define BIO_C_GET_PREFIX                        150
862
 
#define BIO_C_SET_SUFFIX                        151
863
 
#define BIO_C_GET_SUFFIX                        152
864
 
 
865
 
#define BIO_C_SET_EX_ARG                        153
866
 
#define BIO_C_GET_EX_ARG                        154
867
 
 
868
 
 
869
 
#if defined(__cplusplus)
870
 
}  /* extern C */
871
 
#endif
872
 
 
873
 
#define BIO_F_BIO_callback_ctrl 100
874
 
#define BIO_F_BIO_ctrl 101
875
 
#define BIO_F_BIO_new 102
876
 
#define BIO_F_BIO_new_file 103
877
 
#define BIO_F_BIO_new_mem_buf 104
878
 
#define BIO_F_BIO_zero_copy_get_read_buf 105
879
 
#define BIO_F_BIO_zero_copy_get_read_buf_done 106
880
 
#define BIO_F_BIO_zero_copy_get_write_buf 107
881
 
#define BIO_F_BIO_zero_copy_get_write_buf_done 108
882
 
#define BIO_F_bio_io 109
883
 
#define BIO_F_bio_make_pair 110
884
 
#define BIO_F_bio_write 111
885
 
#define BIO_F_buffer_ctrl 112
886
 
#define BIO_F_conn_ctrl 113
887
 
#define BIO_F_conn_state 114
888
 
#define BIO_F_file_ctrl 115
889
 
#define BIO_F_file_read 116
890
 
#define BIO_F_mem_write 117
891
 
#define BIO_F_BIO_printf 118
892
 
#define BIO_R_BAD_FOPEN_MODE 100
893
 
#define BIO_R_BROKEN_PIPE 101
894
 
#define BIO_R_CONNECT_ERROR 102
895
 
#define BIO_R_ERROR_SETTING_NBIO 103
896
 
#define BIO_R_INVALID_ARGUMENT 104
897
 
#define BIO_R_IN_USE 105
898
 
#define BIO_R_KEEPALIVE 106
899
 
#define BIO_R_NBIO_CONNECT_ERROR 107
900
 
#define BIO_R_NO_HOSTNAME_SPECIFIED 108
901
 
#define BIO_R_NO_PORT_SPECIFIED 109
902
 
#define BIO_R_NO_SUCH_FILE 110
903
 
#define BIO_R_NULL_PARAMETER 111
904
 
#define BIO_R_SYS_LIB 112
905
 
#define BIO_R_UNABLE_TO_CREATE_SOCKET 113
906
 
#define BIO_R_UNINITIALIZED 114
907
 
#define BIO_R_UNSUPPORTED_METHOD 115
908
 
#define BIO_R_WRITE_TO_READ_ONLY_BIO 116
909
 
 
910
 
#endif  /* OPENSSL_HEADER_BIO_H */