child-rekey: Don't change state to INSTALLED if it was already REKEYING
[strongswan.git] / src / libstrongswan / bio / bio_writer.c
1 /*
2 * Copyright (C) 2012-2013 Tobias Brunner
3 * Hochschule fuer Technik Rapperswil
4 *
5 * Copyright (C) 2010 Martin Willi
6 * Copyright (C) 2010 revosec AG
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * for more details.
17 */
18
19 #include "bio_writer.h"
20
21 typedef struct private_bio_writer_t private_bio_writer_t;
22
23 /**
24 * Private data of an bio_writer_t object.
25 */
26 struct private_bio_writer_t {
27
28 /**
29 * Public bio_writer_t interface.
30 */
31 bio_writer_t public;
32
33 /**
34 * Allocated buffer
35 */
36 chunk_t buf;
37
38 /**
39 * Used bytes in buffer
40 */
41 size_t used;
42
43 /**
44 * Number of bytes to increase buffer size
45 */
46 size_t increase;
47 };
48
49 /**
50 * Increase buffer size, if required
51 */
52 static inline void increase(private_bio_writer_t *this, size_t required)
53 {
54 bool inc = FALSE;
55
56 while (this->used + required > this->buf.len)
57 {
58 this->buf.len += this->increase;
59 inc = TRUE;
60 }
61 if (inc)
62 {
63 this->buf.ptr = realloc(this->buf.ptr, this->buf.len);
64 }
65 }
66
67 METHOD(bio_writer_t, write_uint8, void,
68 private_bio_writer_t *this, uint8_t value)
69 {
70 increase(this, 1);
71 this->buf.ptr[this->used] = value;
72 this->used += 1;
73 }
74
75 METHOD(bio_writer_t, write_uint16, void,
76 private_bio_writer_t *this, uint16_t value)
77 {
78 increase(this, 2);
79 htoun16(this->buf.ptr + this->used, value);
80 this->used += 2;
81 }
82
83 METHOD(bio_writer_t, write_uint24, void,
84 private_bio_writer_t *this, uint32_t value)
85 {
86 increase(this, 3);
87 value = htonl(value);
88 memcpy(this->buf.ptr + this->used, ((char*)&value) + 1, 3);
89 this->used += 3;
90 }
91
92 METHOD(bio_writer_t, write_uint32, void,
93 private_bio_writer_t *this, uint32_t value)
94 {
95 increase(this, 4);
96 htoun32(this->buf.ptr + this->used, value);
97 this->used += 4;
98 }
99
100 METHOD(bio_writer_t, write_uint64, void,
101 private_bio_writer_t *this, uint64_t value)
102 {
103 increase(this, 8);
104 htoun64(this->buf.ptr + this->used, value);
105 this->used += 8;
106 }
107
108 METHOD(bio_writer_t, write_data, void,
109 private_bio_writer_t *this, chunk_t value)
110 {
111 increase(this, value.len);
112 memcpy(this->buf.ptr + this->used, value.ptr, value.len);
113 this->used += value.len;
114 }
115
116 METHOD(bio_writer_t, write_data8, void,
117 private_bio_writer_t *this, chunk_t value)
118 {
119 increase(this, 1 + value.len);
120 write_uint8(this, value.len);
121 write_data(this, value);
122 }
123
124 METHOD(bio_writer_t, write_data16, void,
125 private_bio_writer_t *this, chunk_t value)
126 {
127 increase(this, 2 + value.len);
128 write_uint16(this, value.len);
129 write_data(this, value);
130 }
131
132 METHOD(bio_writer_t, write_data24, void,
133 private_bio_writer_t *this, chunk_t value)
134 {
135 increase(this, 3 + value.len);
136 write_uint24(this, value.len);
137 write_data(this, value);
138 }
139
140 METHOD(bio_writer_t, write_data32, void,
141 private_bio_writer_t *this, chunk_t value)
142 {
143 increase(this, 4 + value.len);
144 write_uint32(this, value.len);
145 write_data(this, value);
146 }
147
148 METHOD(bio_writer_t, wrap8, void,
149 private_bio_writer_t *this)
150 {
151 increase(this, 1);
152 memmove(this->buf.ptr + 1, this->buf.ptr, this->used);
153 this->buf.ptr[0] = this->used;
154 this->used += 1;
155 }
156
157 METHOD(bio_writer_t, wrap16, void,
158 private_bio_writer_t *this)
159 {
160 increase(this, 2);
161 memmove(this->buf.ptr + 2, this->buf.ptr, this->used);
162 htoun16(this->buf.ptr, this->used);
163 this->used += 2;
164 }
165
166 METHOD(bio_writer_t, wrap24, void,
167 private_bio_writer_t *this)
168 {
169 uint32_t len;
170
171 increase(this, 3);
172 memmove(this->buf.ptr + 3, this->buf.ptr, this->used);
173
174 len = htonl(this->used);
175 memcpy(this->buf.ptr, ((char*)&len) + 1, 3);
176 this->used += 3;
177 }
178
179 METHOD(bio_writer_t, wrap32, void,
180 private_bio_writer_t *this)
181 {
182 increase(this, 4);
183 memmove(this->buf.ptr + 4, this->buf.ptr, this->used);
184 htoun32(this->buf.ptr, this->used);
185 this->used += 4;
186 }
187
188 METHOD(bio_writer_t, skip, chunk_t,
189 private_bio_writer_t *this, size_t len)
190 {
191 chunk_t skipped;
192
193 increase(this, len);
194 skipped = chunk_create(this->buf.ptr + this->used, len);
195 this->used += len;
196 return skipped;
197 }
198
199 METHOD(bio_writer_t, get_buf, chunk_t,
200 private_bio_writer_t *this)
201 {
202 return chunk_create(this->buf.ptr, this->used);
203 }
204
205 METHOD(bio_writer_t, extract_buf, chunk_t,
206 private_bio_writer_t *this)
207 {
208 chunk_t buf = get_buf(this);
209 this->buf = chunk_empty;
210 this->used = 0;
211 return buf;
212 }
213
214 METHOD(bio_writer_t, destroy, void,
215 private_bio_writer_t *this)
216 {
217 free(this->buf.ptr);
218 free(this);
219 }
220
221 /**
222 * See header
223 */
224 bio_writer_t *bio_writer_create(uint32_t bufsize)
225 {
226 private_bio_writer_t *this;
227
228 INIT(this,
229 .public = {
230 .write_uint8 = _write_uint8,
231 .write_uint16 = _write_uint16,
232 .write_uint24 = _write_uint24,
233 .write_uint32 = _write_uint32,
234 .write_uint64 = _write_uint64,
235 .write_data = _write_data,
236 .write_data8 = _write_data8,
237 .write_data16 = _write_data16,
238 .write_data24 = _write_data24,
239 .write_data32 = _write_data32,
240 .wrap8 = _wrap8,
241 .wrap16 = _wrap16,
242 .wrap24 = _wrap24,
243 .wrap32 = _wrap32,
244 .skip = _skip,
245 .get_buf = _get_buf,
246 .extract_buf = _extract_buf,
247 .destroy = _destroy,
248 },
249 .increase = bufsize ? max(bufsize, 4) : 32,
250 );
251 if (bufsize)
252 {
253 this->buf = chunk_alloc(bufsize);
254 }
255
256 return &this->public;
257 }