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
|
/*
* Copyright (C) 2009-2012 Free Software Foundation, Inc.
*
* Author: Jonathan Bastien-Filiatrault
*
* This file is part of GNUTLS.
*
* The GNUTLS library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>
*
*/
#ifndef GNUTLS_LIB_MBUFFERS_H
#define GNUTLS_LIB_MBUFFERS_H
#include "gnutls_int.h"
#include "errors.h"
#include <assert.h>
void _mbuffer_head_init(mbuffer_head_st *buf);
void _mbuffer_head_clear(mbuffer_head_st *buf);
void _mbuffer_enqueue(mbuffer_head_st *buf, mbuffer_st *bufel);
mbuffer_st *_mbuffer_dequeue(mbuffer_head_st *buf, mbuffer_st *bufel);
int _mbuffer_head_remove_bytes(mbuffer_head_st *buf, size_t bytes);
mbuffer_st *_mbuffer_alloc(size_t maximum_size);
int _mbuffer_linearize(mbuffer_head_st *buf);
mbuffer_st *_mbuffer_head_get_first(mbuffer_head_st *buf, gnutls_datum_t *msg);
mbuffer_st *_mbuffer_head_get_next(mbuffer_st *cur, gnutls_datum_t *msg);
void _mbuffer_head_push_first(mbuffer_head_st *buf, mbuffer_st *bufel);
mbuffer_st *_mbuffer_head_pop_first(mbuffer_head_st *buf);
/* This is dangerous since it will replace bufel with a new
* one.
*/
int _mbuffer_append_data(mbuffer_st *bufel, void *newdata, size_t newdata_size);
/* For "user" use. One can have buffer data and header.
*/
inline static void *_mbuffer_get_uhead_ptr(mbuffer_st *bufel)
{
return bufel->msg.data + bufel->mark;
}
inline static void *_mbuffer_get_udata_ptr(mbuffer_st *bufel)
{
return bufel->msg.data + bufel->uhead_mark + bufel->mark;
}
inline static void _mbuffer_set_udata_size(mbuffer_st *bufel, size_t size)
{
bufel->msg.size = size + bufel->uhead_mark + bufel->mark;
}
inline static void _mbuffer_set_udata(mbuffer_st *bufel, void *data,
size_t data_size)
{
memcpy(_mbuffer_get_udata_ptr(bufel), data, data_size);
_mbuffer_set_udata_size(bufel, data_size);
}
inline static size_t _mbuffer_get_udata_size(mbuffer_st *bufel)
{
return bufel->msg.size - bufel->uhead_mark - bufel->mark;
}
/* discards size bytes from the begging of the buffer */
inline static void _mbuffer_consume(mbuffer_head_st *buf, mbuffer_st *bufel,
size_t size)
{
bufel->uhead_mark = 0;
if (bufel->mark + size < bufel->msg.size)
bufel->mark += size;
else
bufel->mark = bufel->msg.size;
buf->byte_length -= size;
}
inline static size_t _mbuffer_get_uhead_size(mbuffer_st *bufel)
{
return bufel->uhead_mark;
}
inline static void _mbuffer_set_uhead_size(mbuffer_st *bufel, size_t size)
{
bufel->uhead_mark = size;
}
inline static void _mbuffer_init(mbuffer_st *bufel, size_t max)
{
memset(bufel, 0, sizeof(*bufel));
bufel->maximum_size = max;
/* payload points after the mbuffer_st structure */
bufel->msg.data = (uint8_t *)bufel + sizeof(mbuffer_st);
}
/* Helper functions to utilize a gnutls_buffer_st in order
* to generate a gnutls_mbuffer_st, without multiple allocations.
*/
inline static int _gnutls_buffer_init_mbuffer(gnutls_buffer_st *buf,
size_t header_size)
{
int ret;
mbuffer_st *bufel;
_gnutls_buffer_init(buf);
ret = _gnutls_buffer_resize(buf, sizeof(mbuffer_st) + header_size);
if (ret < 0)
return gnutls_assert_val(ret);
/* we store the uhead size on the uninitialized bufel, only to read
* it back on _gnutls_buffer_to_mbuffer(). */
bufel = (void *)buf->data;
_mbuffer_set_uhead_size(bufel, header_size);
buf->length = sizeof(mbuffer_st) + header_size;
return 0;
}
#define _gnutls_buffer_init_handshake_mbuffer(b) \
_gnutls_buffer_init_mbuffer(b, HANDSHAKE_HEADER_SIZE(session))
/* Cannot fail */
inline static mbuffer_st *_gnutls_buffer_to_mbuffer(gnutls_buffer_st *buf)
{
mbuffer_st *bufel;
unsigned header_size;
bufel = (void *)buf->data;
header_size = _mbuffer_get_uhead_size(bufel);
assert(buf->length >= sizeof(mbuffer_st) + header_size);
_mbuffer_init(bufel, buf->length - sizeof(mbuffer_st));
_mbuffer_set_udata_size(bufel, buf->length - sizeof(mbuffer_st));
_mbuffer_set_uhead_size(bufel, header_size);
_gnutls_buffer_init(buf); /* avoid double frees */
return bufel;
}
inline static mbuffer_st *_gnutls_handshake_alloc(gnutls_session_t session,
size_t maximum)
{
mbuffer_st *bufel =
_mbuffer_alloc(HANDSHAKE_HEADER_SIZE(session) + maximum);
if (!bufel)
return NULL;
_mbuffer_set_uhead_size(bufel, HANDSHAKE_HEADER_SIZE(session));
_mbuffer_set_udata_size(bufel, maximum);
return bufel;
}
/* Free a segment, if the pointer is not NULL
*
* We take a ** to detect and fix double free bugs (the dangling
* pointer case). It also makes sure the pointer has a known value
* after freeing.
*/
inline static void _mbuffer_xfree(mbuffer_st **bufel)
{
if (*bufel)
gnutls_free(*bufel);
*bufel = NULL;
}
#ifdef ENABLE_ALIGN16
mbuffer_st *_mbuffer_alloc_align16(size_t maximum_size, unsigned align_pos);
int _mbuffer_linearize_align16(mbuffer_head_st *buf, unsigned align_pos);
#else
#define _mbuffer_alloc_align16(x, y) _mbuffer_alloc(x)
#define _mbuffer_linearize_align16(x, y) _mbuffer_linearize(x)
#endif
#endif /* GNUTLS_LIB_MBUFFERS_H */
|
