]>
Commit | Line | Data |
---|---|---|
d7b9c76c DSH |
1 | =pod |
2 | ||
3 | =head1 NAME | |
4 | ||
8eec1389 RL |
5 | BIO_s_mem, BIO_set_mem_eof_return, BIO_get_mem_data, BIO_set_mem_buf, |
6 | BIO_get_mem_ptr, BIO_new_mem_buf - memory BIO | |
d7b9c76c DSH |
7 | |
8 | =head1 SYNOPSIS | |
9 | ||
10 | #include <openssl/bio.h> | |
11 | ||
1bc74519 RS |
12 | const BIO_METHOD * BIO_s_mem(void); |
13 | const BIO_METHOD * BIO_s_secmem(void); | |
d7b9c76c DSH |
14 | |
15 | BIO_set_mem_eof_return(BIO *b,int v) | |
16 | long BIO_get_mem_data(BIO *b, char **pp) | |
17 | BIO_set_mem_buf(BIO *b,BUF_MEM *bm,int c) | |
18 | BIO_get_mem_ptr(BIO *b,BUF_MEM **pp) | |
19 | ||
8ab31975 | 20 | BIO *BIO_new_mem_buf(const void *buf, int len); |
d7b9c76c DSH |
21 | |
22 | =head1 DESCRIPTION | |
23 | ||
1bc74519 | 24 | BIO_s_mem() return the memory BIO method function. |
d7b9c76c DSH |
25 | |
26 | A memory BIO is a source/sink BIO which uses memory for its I/O. Data | |
27 | written to a memory BIO is stored in a BUF_MEM structure which is extended | |
28 | as appropriate to accommodate the stored data. | |
29 | ||
74924dcb RS |
30 | BIO_s_secmem() is like BIO_s_mem() except that the secure heap is used |
31 | for buffer storage. | |
32 | ||
d7b9c76c DSH |
33 | Any data written to a memory BIO can be recalled by reading from it. |
34 | Unless the memory BIO is read only any data read from it is deleted from | |
35 | the BIO. | |
36 | ||
37 | Memory BIOs support BIO_gets() and BIO_puts(). | |
38 | ||
39 | If the BIO_CLOSE flag is set when a memory BIO is freed then the underlying | |
40 | BUF_MEM structure is also freed. | |
41 | ||
9fe9d046 KM |
42 | Calling BIO_reset() on a read write memory BIO clears any data in it if the |
43 | flag BIO_FLAGS_NONCLEAR_RST is not set. On a read only BIO or if the flag | |
1bc74519 | 44 | BIO_FLAGS_NONCLEAR_RST is set it restores the BIO to its original state and |
9fe9d046 | 45 | the data can be read again. |
d7b9c76c DSH |
46 | |
47 | BIO_eof() is true if no data is in the BIO. | |
48 | ||
49 | BIO_ctrl_pending() returns the number of bytes currently stored. | |
50 | ||
acb5b343 | 51 | BIO_set_mem_eof_return() sets the behaviour of memory BIO B<b> when it is |
d7b9c76c DSH |
52 | empty. If the B<v> is zero then an empty memory BIO will return EOF (that is |
53 | it will return zero and BIO_should_retry(b) will be false. If B<v> is non | |
54 | zero then it will return B<v> when it is empty and it will set the read retry | |
55 | flag (that is BIO_read_retry(b) is true). To avoid ambiguity with a normal | |
56 | positive return value B<v> should be set to a negative value, typically -1. | |
57 | ||
58 | BIO_get_mem_data() sets B<pp> to a pointer to the start of the memory BIOs data | |
59 | and returns the total amount of data available. It is implemented as a macro. | |
60 | ||
61 | BIO_set_mem_buf() sets the internal BUF_MEM structure to B<bm> and sets the | |
62 | close flag to B<c>, that is B<c> should be either BIO_CLOSE or BIO_NOCLOSE. | |
63 | It is a macro. | |
64 | ||
65 | BIO_get_mem_ptr() places the underlying BUF_MEM structure in B<pp>. It is | |
66 | a macro. | |
67 | ||
68 | BIO_new_mem_buf() creates a memory BIO using B<len> bytes of data at B<buf>, | |
8ab31975 | 69 | if B<len> is -1 then the B<buf> is assumed to be nul terminated and its |
d7b9c76c DSH |
70 | length is determined by B<strlen>. The BIO is set to a read only state and |
71 | as a result cannot be written to. This is useful when some data needs to be | |
72 | made available from a static area of memory in the form of a BIO. The | |
73 | supplied data is read directly from the supplied buffer: it is B<not> copied | |
74 | first, so the supplied area of memory must be unchanged until the BIO is freed. | |
75 | ||
76 | =head1 NOTES | |
77 | ||
78 | Writes to memory BIOs will always succeed if memory is available: that is | |
79 | their size can grow indefinitely. | |
80 | ||
81 | Every read from a read write memory BIO will remove the data just read with | |
8711efb4 | 82 | an internal copy operation, if a BIO contains a lot of data and it is |
d7b9c76c DSH |
83 | read in small chunks the operation can be very slow. The use of a read only |
84 | memory BIO avoids this problem. If the BIO must be read write then adding | |
85 | a buffering BIO to the chain will speed up the process. | |
86 | ||
74924dcb RS |
87 | Calling BIO_set_mem_buf() on a BIO created with BIO_new_secmem() will |
88 | give undefined results, including perhaps a program crash. | |
89 | ||
d7b9c76c DSH |
90 | =head1 BUGS |
91 | ||
92 | There should be an option to set the maximum size of a memory BIO. | |
93 | ||
d7b9c76c DSH |
94 | =head1 EXAMPLE |
95 | ||
96 | Create a memory BIO and write some data to it: | |
97 | ||
98 | BIO *mem = BIO_new(BIO_s_mem()); | |
1bc74519 | 99 | BIO_puts(mem, "Hello World\n"); |
d7b9c76c DSH |
100 | |
101 | Create a read only memory BIO: | |
102 | ||
103 | char data[] = "Hello World"; | |
104 | BIO *mem; | |
105 | mem = BIO_new_mem_buf(data, -1); | |
106 | ||
107 | Extract the BUF_MEM structure from a memory BIO and then free up the BIO: | |
108 | ||
109 | BUF_MEM *bptr; | |
110 | BIO_get_mem_ptr(mem, &bptr); | |
111 | BIO_set_close(mem, BIO_NOCLOSE); /* So BIO_free() leaves BUF_MEM alone */ | |
112 | BIO_free(mem); | |
1bc74519 | 113 | |
e2f92610 RS |
114 | =head1 COPYRIGHT |
115 | ||
116 | Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved. | |
117 | ||
118 | Licensed under the OpenSSL license (the "License"). You may not use | |
119 | this file except in compliance with the License. You can obtain a copy | |
120 | in the file LICENSE in the source distribution or at | |
121 | L<https://www.openssl.org/source/license.html>. | |
122 | ||
123 | =cut |