]>
Commit | Line | Data |
---|---|---|
d7b9c76c DSH |
1 | =pod |
2 | ||
3 | =head1 NAME | |
4 | ||
c952780c | 5 | BIO_s_secmem, |
8eec1389 RL |
6 | BIO_s_mem, BIO_set_mem_eof_return, BIO_get_mem_data, BIO_set_mem_buf, |
7 | BIO_get_mem_ptr, BIO_new_mem_buf - memory BIO | |
d7b9c76c DSH |
8 | |
9 | =head1 SYNOPSIS | |
10 | ||
11 | #include <openssl/bio.h> | |
12 | ||
e9b77246 BB |
13 | const BIO_METHOD *BIO_s_mem(void); |
14 | const BIO_METHOD *BIO_s_secmem(void); | |
d7b9c76c | 15 | |
aebb9aac | 16 | BIO_set_mem_eof_return(BIO *b, int v) |
d7b9c76c | 17 | long BIO_get_mem_data(BIO *b, char **pp) |
aebb9aac RS |
18 | BIO_set_mem_buf(BIO *b, BUF_MEM *bm, int c) |
19 | BIO_get_mem_ptr(BIO *b, BUF_MEM **pp) | |
d7b9c76c | 20 | |
8ab31975 | 21 | BIO *BIO_new_mem_buf(const void *buf, int len); |
d7b9c76c DSH |
22 | |
23 | =head1 DESCRIPTION | |
24 | ||
1f13ad31 | 25 | BIO_s_mem() returns the memory BIO method function. |
d7b9c76c DSH |
26 | |
27 | A memory BIO is a source/sink BIO which uses memory for its I/O. Data | |
28 | written to a memory BIO is stored in a BUF_MEM structure which is extended | |
29 | as appropriate to accommodate the stored data. | |
30 | ||
74924dcb RS |
31 | BIO_s_secmem() is like BIO_s_mem() except that the secure heap is used |
32 | for buffer storage. | |
33 | ||
d7b9c76c DSH |
34 | Any data written to a memory BIO can be recalled by reading from it. |
35 | Unless the memory BIO is read only any data read from it is deleted from | |
36 | the BIO. | |
37 | ||
38 | Memory BIOs support BIO_gets() and BIO_puts(). | |
39 | ||
40 | If the BIO_CLOSE flag is set when a memory BIO is freed then the underlying | |
41 | BUF_MEM structure is also freed. | |
42 | ||
9fe9d046 | 43 | Calling BIO_reset() on a read write memory BIO clears any data in it if the |
8b7b3292 TM |
44 | flag BIO_FLAGS_NONCLEAR_RST is not set, otherwise it just restores the read |
45 | pointer to the state it was just after the last write was performed and the | |
46 | data can be read again. On a read only BIO it similarly restores the BIO to | |
47 | its original state and the read only data can be read again. | |
d7b9c76c DSH |
48 | |
49 | BIO_eof() is true if no data is in the BIO. | |
50 | ||
51 | BIO_ctrl_pending() returns the number of bytes currently stored. | |
52 | ||
acb5b343 | 53 | BIO_set_mem_eof_return() sets the behaviour of memory BIO B<b> when it is |
d7b9c76c DSH |
54 | empty. If the B<v> is zero then an empty memory BIO will return EOF (that is |
55 | it will return zero and BIO_should_retry(b) will be false. If B<v> is non | |
56 | zero then it will return B<v> when it is empty and it will set the read retry | |
57 | flag (that is BIO_read_retry(b) is true). To avoid ambiguity with a normal | |
58 | positive return value B<v> should be set to a negative value, typically -1. | |
59 | ||
36359cec | 60 | BIO_get_mem_data() sets *B<pp> to a pointer to the start of the memory BIOs data |
d7b9c76c DSH |
61 | and returns the total amount of data available. It is implemented as a macro. |
62 | ||
63 | BIO_set_mem_buf() sets the internal BUF_MEM structure to B<bm> and sets the | |
64 | close flag to B<c>, that is B<c> should be either BIO_CLOSE or BIO_NOCLOSE. | |
65 | It is a macro. | |
66 | ||
36359cec | 67 | BIO_get_mem_ptr() places the underlying BUF_MEM structure in *B<pp>. It is |
d7b9c76c DSH |
68 | a macro. |
69 | ||
70 | BIO_new_mem_buf() creates a memory BIO using B<len> bytes of data at B<buf>, | |
8ab31975 | 71 | if B<len> is -1 then the B<buf> is assumed to be nul terminated and its |
d7b9c76c DSH |
72 | length is determined by B<strlen>. The BIO is set to a read only state and |
73 | as a result cannot be written to. This is useful when some data needs to be | |
74 | made available from a static area of memory in the form of a BIO. The | |
75 | supplied data is read directly from the supplied buffer: it is B<not> copied | |
76 | first, so the supplied area of memory must be unchanged until the BIO is freed. | |
77 | ||
78 | =head1 NOTES | |
79 | ||
80 | Writes to memory BIOs will always succeed if memory is available: that is | |
81 | their size can grow indefinitely. | |
82 | ||
8b7b3292 TM |
83 | Every write after partial read (not all data in the memory buffer was read) |
84 | to a read write memory BIO will have to move the unread data with an internal | |
85 | copy operation, if a BIO contains a lot of data and it is read in small | |
86 | chunks intertwined with writes the operation can be very slow. Adding | |
87 | a buffering BIO to the chain can speed up the process. | |
d7b9c76c | 88 | |
74924dcb RS |
89 | Calling BIO_set_mem_buf() on a BIO created with BIO_new_secmem() will |
90 | give undefined results, including perhaps a program crash. | |
91 | ||
3d42833d TM |
92 | Switching the memory BIO from read write to read only is not supported and |
93 | can give undefined results including a program crash. There are two notable | |
94 | exceptions to the rule. The first one is to assign a static memory buffer | |
95 | immediately after BIO creation and set the BIO as read only. | |
96 | ||
97 | The other supported sequence is to start with read write BIO then temporarily | |
98 | switch it to read only and call BIO_reset() on the read only BIO immediately | |
99 | before switching it back to read write. Before the BIO is freed it must be | |
100 | switched back to the read write mode. | |
101 | ||
102 | Calling BIO_get_mem_ptr() on read only BIO will return a BUF_MEM that | |
103 | contains only the remaining data to be read. If the close status of the | |
104 | BIO is set to BIO_NOCLOSE, before freeing the BUF_MEM the data pointer | |
105 | in it must be set to NULL as the data pointer does not point to an | |
106 | allocated memory. | |
107 | ||
8b7b3292 TM |
108 | Calling BIO_reset() on a read write memory BIO with BIO_FLAGS_NONCLEAR_RST |
109 | flag set can have unexpected outcome when the reads and writes to the | |
110 | BIO are intertwined. As documented above the BIO will be reset to the | |
111 | state after the last completed write operation. The effects of reads | |
c2969ff6 | 112 | preceding that write operation cannot be undone. |
8b7b3292 TM |
113 | |
114 | Calling BIO_get_mem_ptr() prior to a BIO_reset() call with | |
115 | BIO_FLAGS_NONCLEAR_RST set has the same effect as a write operation. | |
116 | ||
d7b9c76c DSH |
117 | =head1 BUGS |
118 | ||
119 | There should be an option to set the maximum size of a memory BIO. | |
120 | ||
d7b9c76c DSH |
121 | =head1 EXAMPLE |
122 | ||
123 | Create a memory BIO and write some data to it: | |
124 | ||
125 | BIO *mem = BIO_new(BIO_s_mem()); | |
e9b77246 | 126 | |
1bc74519 | 127 | BIO_puts(mem, "Hello World\n"); |
d7b9c76c DSH |
128 | |
129 | Create a read only memory BIO: | |
130 | ||
131 | char data[] = "Hello World"; | |
e9b77246 | 132 | BIO *mem = BIO_new_mem_buf(data, -1); |
d7b9c76c DSH |
133 | |
134 | Extract the BUF_MEM structure from a memory BIO and then free up the BIO: | |
135 | ||
136 | BUF_MEM *bptr; | |
e9b77246 | 137 | |
d7b9c76c DSH |
138 | BIO_get_mem_ptr(mem, &bptr); |
139 | BIO_set_close(mem, BIO_NOCLOSE); /* So BIO_free() leaves BUF_MEM alone */ | |
140 | BIO_free(mem); | |
1bc74519 | 141 | |
1f13ad31 PY |
142 | =head1 RETURN VALUES |
143 | ||
144 | BIO_s_mem() and BIO_s_secmem() return a valid memory B<BIO_METHOD> structure. | |
145 | ||
146 | BIO_set_mem_eof_return(), BIO_get_mem_data(), BIO_set_mem_buf() and BIO_get_mem_ptr() | |
147 | return 1 on success or a value which is less than or equal to 0 if an error occurred. | |
148 | ||
149 | BIO_new_mem_buf() returns a valid B<BIO> structure on success or NULL on error. | |
150 | ||
e2f92610 RS |
151 | =head1 COPYRIGHT |
152 | ||
61f805c1 | 153 | Copyright 2000-2018 The OpenSSL Project Authors. All Rights Reserved. |
e2f92610 | 154 | |
4746f25a | 155 | Licensed under the Apache License 2.0 (the "License"). You may not use |
e2f92610 RS |
156 | this file except in compliance with the License. You can obtain a copy |
157 | in the file LICENSE in the source distribution or at | |
158 | L<https://www.openssl.org/source/license.html>. | |
159 | ||
160 | =cut |