1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
#ifndef __SSS_IOBUF_H_
#define __SSS_IOBUF_H_
#include <talloc.h>
#include <stdint.h>
#include <errno.h>
#include "util/util_errors.h"
struct sss_iobuf;
/*
* @brief Allocate an empty IO buffer
*
* @param[in] mem_ctx The talloc context that owns the iobuf
*
* When this buffer is written into, but the capacity is exceeded, the write
* function will return an error.
*
* @param[in] mem_ctx The talloc context that owns the iobuf
* @param[in] size The size of the data buffer
* @param[in] capacity The maximum capacity the buffer can grow into.
* Use 0 for an 'unlimited' buffer that will grow
* until SIZE_MAX/2.
*
* @warning The allocated data storage will not be zeroed.
*
* @return The newly created buffer on success or NULL on an error.
*
*/
struct sss_iobuf *sss_iobuf_init_empty(TALLOC_CTX *mem_ctx,
size_t size,
size_t capacity);
/*
* @brief Allocate an IO buffer with a fixed size
*
* This function is useful for parsing an input buffer from an existing
* buffer pointed to by data.
*
* The iobuf does not assume ownership of the data buffer in talloc terms,
* but copies the data instead.
*
* @param[in] mem_ctx The talloc context that owns the iobuf
* @param[in] data The data to initialize the IO buffer with. This
* data is copied into the iobuf-owned buffer.
* @param[in] size The size of the data buffer
*
* @warning The allocated data storage will not be zeroed.
*
* @return The newly created buffer on success or NULL on an error.
*/
struct sss_iobuf *sss_iobuf_init_readonly(TALLOC_CTX *mem_ctx,
const uint8_t *data,
size_t size);
/*
* @brief Allocate an IO buffer with a fixed size, stealing input data.
*
* This function is useful for parsing an input buffer from an existing
* buffer pointed to by data.
*
* The iobuf assumes ownership of the data buffer.
*
* @param[in] mem_ctx The talloc context that owns the iobuf
* @param[in] data The data to initialize the IO buffer with.
* @param[in] size The size of the data buffer
*
* @return The newly created buffer on success or NULL on an error.
*/
struct sss_iobuf *sss_iobuf_init_steal(TALLOC_CTX *mem_ctx,
uint8_t *data,
size_t size);
/*
* @brief Reset internal cursor of the IO buffer (seek to the start)
*/
void sss_iobuf_cursor_reset(struct sss_iobuf *iobuf);
/*
* @brief Returns the number of bytes currently stored in the iobuf
*
* @return The number of bytes (the data pointer offset)
*/
size_t sss_iobuf_get_len(struct sss_iobuf *iobuf);
/*
* @brief Returns the capacity of the IO buffer
*
* @return The capacity of the IO buffer. Returns zero
* for an unlimited buffer.
*/
size_t sss_iobuf_get_capacity(struct sss_iobuf *iobuf);
/*
* @brief Returns the current size of the IO buffer
*/
size_t sss_iobuf_get_size(struct sss_iobuf *iobuf);
/*
* @brief Returns the data pointer of the IO buffer
*/
uint8_t *sss_iobuf_get_data(struct sss_iobuf *iobuf);
/*
* @brief Read from an IO buffer
*
* Read up to len bytes from an IO buffer. It is not an error to request
* more bytes than the buffer actually has - the function will succeed, but
* return the actual number of bytes read. Reading from an empty buffer just
* returns zero bytes read.
*
* @param[in] iobuf The IO buffer to read from
* @param[in] len The maximum number of bytes to read
* @param[out] _buf The buffer to read data into from iobuf
* @param[out] _read The actual number of bytes read from IO buffer.
*
* @return EOK on success, errno otherwise
*/
errno_t sss_iobuf_read(struct sss_iobuf *iobuf,
size_t len,
uint8_t *_buf,
size_t *_read);
/*
* @brief Read an exact number of bytes from an IO buffer
*
* Read exactly len bytes from an IO buffer. If the buffer contains fewer
* bytes than len, ENOBUFS is returned.
*
* @param[in] iobuf The IO buffer to read from
* @param[in] len The maximum number of bytes to read
* @param[out] _buf The buffer to read data into from iobuf
*
* @return EOK on success, errno otherwise
*/
errno_t sss_iobuf_read_len(struct sss_iobuf *iobuf,
size_t len,
uint8_t *_buf);
/*
* @brief Write into an IO buffer
*
* Attempts to write len bytes into the iobuf. If the capacity is exceeded,
* the iobuf module tries to extend the buffer up to the maximum capacity.
*
* If reallocating the internal buffer fails, the data pointers are not
* touched.
*
* @param[in] iobuf The IO buffer to write to
* @param[in] buf The data to write into the buffer
* @param[in] len The number of bytes to write
*
* @return EOK on success, errno otherwise. Notably returns ENOBUFS if
* the buffer capacity is exceeded.
*/
errno_t sss_iobuf_write_len(struct sss_iobuf *iobuf,
uint8_t *buf,
size_t len);
errno_t sss_iobuf_read_varlen(TALLOC_CTX *mem_ctx,
struct sss_iobuf *iobuf,
uint8_t **_out,
size_t *_len);
errno_t sss_iobuf_write_varlen(struct sss_iobuf *iobuf,
uint8_t *data,
size_t len);
errno_t sss_iobuf_read_iobuf(TALLOC_CTX *mem_ctx,
struct sss_iobuf *iobuf,
struct sss_iobuf **_out);
errno_t sss_iobuf_write_iobuf(struct sss_iobuf *iobuf,
struct sss_iobuf *data);
errno_t sss_iobuf_read_uint8(struct sss_iobuf *iobuf,
uint8_t *_val);
errno_t sss_iobuf_write_uint8(struct sss_iobuf *iobuf,
uint8_t val);
errno_t sss_iobuf_read_uint32(struct sss_iobuf *iobuf,
uint32_t *_val);
errno_t sss_iobuf_write_uint32(struct sss_iobuf *iobuf,
uint32_t val);
errno_t sss_iobuf_read_int32(struct sss_iobuf *iobuf,
int32_t *_val);
errno_t sss_iobuf_write_int32(struct sss_iobuf *iobuf,
int32_t val);
errno_t sss_iobuf_read_stringz(struct sss_iobuf *iobuf,
const char **_out);
errno_t sss_iobuf_write_stringz(struct sss_iobuf *iobuf,
const char *str);
#endif /* __SSS_IOBUF_H_ */
|
