![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bio_reader.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / bio|
Return to bio_reader.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / bio |
1.1 misho 1: /*
2: * Copyright (C) 2012 Tobias Brunner
3: * HSR 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_reader.h"
20:
21: #include <utils/debug.h>
22:
23: typedef struct private_bio_reader_t private_bio_reader_t;
24:
25: /**
26: * Private data of an bio_reader_t object.
27: */
28: struct private_bio_reader_t {
29:
30: /**
31: * Public bio_reader_t interface.
32: */
33: bio_reader_t public;
34:
35: /**
36: * Remaining data to process
37: */
38: chunk_t buf;
39:
40: /**
41: * Optional data to free during destruction
42: */
43: chunk_t cleanup;
44: };
45:
46: METHOD(bio_reader_t, remaining, uint32_t,
47: private_bio_reader_t *this)
48: {
49: return this->buf.len;
50: }
51:
52: METHOD(bio_reader_t, peek, chunk_t,
53: private_bio_reader_t *this)
54: {
55: return this->buf;
56: }
57:
58: /**
59: * A version of chunk_skip() that supports skipping from the end (i.e. simply
60: * reducing the size)
61: */
62: static inline chunk_t chunk_skip_end(chunk_t chunk, size_t bytes, bool from_end)
63: {
64: if (chunk.len > bytes)
65: {
66: if (!from_end)
67: {
68: chunk.ptr += bytes;
69: }
70: chunk.len -= bytes;
71: return chunk;
72: }
73: return chunk_empty;
74: }
75:
76: /**
77: * Returns a pointer to the data to read, optionally from the end
78: */
79: static inline u_char *get_ptr_end(private_bio_reader_t *this, uint32_t len,
80: bool from_end)
81: {
82: return from_end ? this->buf.ptr + (this->buf.len - len) : this->buf.ptr;
83: }
84:
85: /**
86: * Read an uint8_t from the buffer, optionally from the end of the buffer
87: */
88: static bool read_uint8_internal(private_bio_reader_t *this, uint8_t *res,
89: bool from_end)
90: {
91: if (this->buf.len < 1)
92: {
93: DBG1(DBG_LIB, "%d bytes insufficient to parse u_int8 data",
94: this->buf.len);
95: return FALSE;
96: }
97: *res = *get_ptr_end(this, 1, from_end);
98: this->buf = chunk_skip_end(this->buf, 1, from_end);
99: return TRUE;
100: }
101:
102: /**
103: * Read an uint16_t from the buffer, optionally from the end
104: */
105: static bool read_uint16_internal(private_bio_reader_t *this, uint16_t *res,
106: bool from_end)
107: {
108: if (this->buf.len < 2)
109: {
110: DBG1(DBG_LIB, "%d bytes insufficient to parse u_int16 data",
111: this->buf.len);
112: return FALSE;
113: }
114: *res = untoh16(get_ptr_end(this, 2, from_end));
115: this->buf = chunk_skip_end(this->buf, 2, from_end);
116: return TRUE;
117: }
118:
119: /**
120: * Read an uint32_t (only 24-bit) from the buffer, optionally from the end
121: */
122: static bool read_uint24_internal(private_bio_reader_t *this, uint32_t *res,
123: bool from_end)
124: {
125: uint32_t tmp;
126:
127: if (this->buf.len < 3)
128: {
129: DBG1(DBG_LIB, "%d bytes insufficient to parse u_int24 data",
130: this->buf.len);
131: return FALSE;
132: }
133: memcpy(&tmp, get_ptr_end(this, 3, from_end), 3);
134: *res = ntohl(tmp) >> 8;
135: this->buf = chunk_skip_end(this->buf, 3, from_end);
136: return TRUE;
137: }
138:
139: /**
140: * Read an uint32_t from the buffer, optionally from the end
141: */
142: static bool read_uint32_internal(private_bio_reader_t *this, uint32_t *res,
143: bool from_end)
144: {
145: if (this->buf.len < 4)
146: {
147: DBG1(DBG_LIB, "%d bytes insufficient to parse u_int32 data",
148: this->buf.len);
149: return FALSE;
150: }
151: *res = untoh32(get_ptr_end(this, 4, from_end));
152: this->buf = chunk_skip_end(this->buf, 4, from_end);
153: return TRUE;
154: }
155:
156: /**
157: * Read an uint64_t from the buffer, optionally from the end
158: */
159: static bool read_uint64_internal(private_bio_reader_t *this, uint64_t *res,
160: bool from_end)
161: {
162: if (this->buf.len < 8)
163: {
164: DBG1(DBG_LIB, "%d bytes insufficient to parse u_int64 data",
165: this->buf.len);
166: return FALSE;
167: }
168: *res = untoh64(get_ptr_end(this, 8, from_end));
169: this->buf = chunk_skip_end(this->buf, 8, from_end);
170: return TRUE;
171: }
172:
173: /**
174: * Read a chunk of data from the buffer, optionally from the end
175: */
176: static bool read_data_internal(private_bio_reader_t *this, uint32_t len,
177: chunk_t *res, bool from_end)
178: {
179: if (this->buf.len < len)
180: {
181: DBG1(DBG_LIB, "%d bytes insufficient to parse %d bytes of data",
182: this->buf.len, len);
183: return FALSE;
184: }
185: *res = chunk_create(get_ptr_end(this, len, from_end), len);
186: this->buf = chunk_skip_end(this->buf, len, from_end);
187: return TRUE;
188: }
189:
190: METHOD(bio_reader_t, read_uint8, bool,
191: private_bio_reader_t *this, uint8_t *res)
192: {
193: return read_uint8_internal(this, res, FALSE);
194: }
195:
196: METHOD(bio_reader_t, read_uint16, bool,
197: private_bio_reader_t *this, uint16_t *res)
198: {
199: return read_uint16_internal(this, res, FALSE);
200: }
201:
202: METHOD(bio_reader_t, read_uint24, bool,
203: private_bio_reader_t *this, uint32_t *res)
204: {
205: return read_uint24_internal(this, res, FALSE);
206: }
207:
208: METHOD(bio_reader_t, read_uint32, bool,
209: private_bio_reader_t *this, uint32_t *res)
210: {
211: return read_uint32_internal(this, res, FALSE);
212: }
213:
214: METHOD(bio_reader_t, read_uint64, bool,
215: private_bio_reader_t *this, uint64_t *res)
216: {
217: return read_uint64_internal(this, res, FALSE);
218: }
219:
220: METHOD(bio_reader_t, read_data, bool,
221: private_bio_reader_t *this, uint32_t len, chunk_t *res)
222: {
223: return read_data_internal(this, len, res, FALSE);
224: }
225:
226: METHOD(bio_reader_t, read_uint8_end, bool,
227: private_bio_reader_t *this, uint8_t *res)
228: {
229: return read_uint8_internal(this, res, TRUE);
230: }
231:
232: METHOD(bio_reader_t, read_uint16_end, bool,
233: private_bio_reader_t *this, uint16_t *res)
234: {
235: return read_uint16_internal(this, res, TRUE);
236: }
237:
238: METHOD(bio_reader_t, read_uint24_end, bool,
239: private_bio_reader_t *this, uint32_t *res)
240: {
241: return read_uint24_internal(this, res, TRUE);
242: }
243:
244: METHOD(bio_reader_t, read_uint32_end, bool,
245: private_bio_reader_t *this, uint32_t *res)
246: {
247: return read_uint32_internal(this, res, TRUE);
248: }
249:
250: METHOD(bio_reader_t, read_uint64_end, bool,
251: private_bio_reader_t *this, uint64_t *res)
252: {
253: return read_uint64_internal(this, res, TRUE);
254: }
255:
256: METHOD(bio_reader_t, read_data_end, bool,
257: private_bio_reader_t *this, uint32_t len, chunk_t *res)
258: {
259: return read_data_internal(this, len, res, TRUE);
260: }
261:
262: METHOD(bio_reader_t, read_data8, bool,
263: private_bio_reader_t *this, chunk_t *res)
264: {
265: uint8_t len;
266:
267: if (!read_uint8(this, &len))
268: {
269: return FALSE;
270: }
271: return read_data(this, len, res);
272: }
273:
274: METHOD(bio_reader_t, read_data16, bool,
275: private_bio_reader_t *this, chunk_t *res)
276: {
277: uint16_t len;
278:
279: if (!read_uint16(this, &len))
280: {
281: return FALSE;
282: }
283: return read_data(this, len, res);
284: }
285:
286: METHOD(bio_reader_t, read_data24, bool,
287: private_bio_reader_t *this, chunk_t *res)
288: {
289: uint32_t len;
290:
291: if (!read_uint24(this, &len))
292: {
293: return FALSE;
294: }
295: return read_data(this, len, res);
296: }
297:
298: METHOD(bio_reader_t, read_data32, bool,
299: private_bio_reader_t *this, chunk_t *res)
300: {
301: uint32_t len;
302:
303: if (!read_uint32(this, &len))
304: {
305: return FALSE;
306: }
307: return read_data(this, len, res);
308: }
309:
310: METHOD(bio_reader_t, destroy, void,
311: private_bio_reader_t *this)
312: {
313: free(this->cleanup.ptr);
314: free(this);
315: }
316:
317: /**
318: * See header
319: */
320: bio_reader_t *bio_reader_create(chunk_t data)
321: {
322: private_bio_reader_t *this;
323:
324: INIT(this,
325: .public = {
326: .remaining = _remaining,
327: .peek = _peek,
328: .read_uint8 = _read_uint8,
329: .read_uint16 = _read_uint16,
330: .read_uint24 = _read_uint24,
331: .read_uint32 = _read_uint32,
332: .read_uint64 = _read_uint64,
333: .read_data = _read_data,
334: .read_uint8_end = _read_uint8_end,
335: .read_uint16_end = _read_uint16_end,
336: .read_uint24_end = _read_uint24_end,
337: .read_uint32_end = _read_uint32_end,
338: .read_uint64_end = _read_uint64_end,
339: .read_data_end = _read_data_end,
340: .read_data8 = _read_data8,
341: .read_data16 = _read_data16,
342: .read_data24 = _read_data24,
343: .read_data32 = _read_data32,
344: .destroy = _destroy,
345: },
346: .buf = data,
347: );
348:
349: return &this->public;
350: }
351:
352: /**
353: * See header
354: */
355: bio_reader_t *bio_reader_create_own(chunk_t data)
356: {
357: private_bio_reader_t *this;
358:
359: this = (private_bio_reader_t*)bio_reader_create(data);
360:
361: this->cleanup = data;
362:
363: return &this->public;
364: }