1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #ifndef _omi_buf_h
26 #define _omi_buf_h
27
28 #include "config.h"
29 #include <string.h>
30 #include <common.h>
31 #include "batch.h"
32
33 BEGIN_EXTERNC
34
35 /*
36 **==============================================================================
37 **
38 ** Buf
39 **
40 **==============================================================================
41 */
42 #define BUF_INITIALIZER { NULL, 0, 0, 0 }
43 mike 1.1
44 typedef struct _Buf
45 {
46 /* The buffer memory (preceded by Page object) */
47 void* data;
48
49 /* The current size of the buffer */
50 MI_Uint32 size;
51
52 /* The current capacity of the buffer */
53 MI_Uint32 capacity;
54
55 /* The current unpacking offset of ths buffer */
56 MI_Uint32 offset;
57 }
58 Buf;
59
60 MI_Result Buf_Init(
61 Buf* self,
62 MI_Uint32 capacity);
63
64 mike 1.1 void Buf_Destroy(
65 Buf* self);
66
67 MI_Result Buf_Reserve(
68 Buf* self,
69 MI_Uint32 capacity);
70
71 /* Steal the memory page (can be passed to Batch_Attach) */
72 Page* Buf_StealPage(
73 Buf* self);
74
|
75 krisbash 1.3 MI_Result __Buf_App(
|
76 mike 1.1 Buf* self,
77 const void* data,
78 MI_Uint32 size);
79
|
80 krisbash 1.3 INLINE MI_Result Buf_App(
81 Buf* self,
82 const void* data,
83 MI_Uint32 size)
84 {
85 if (self->size + size <= self->capacity)
86 {
87 memcpy((char*)self->data + self->size, data, size);
88 self->size += size;
89 return MI_RESULT_OK;
90 }
91
92 return __Buf_App(self, data, size);
93 }
94
|
95 mike 1.1 /* Pad buffer out to the next 2-byte boundary */
96 MI_INLINE MI_Result Buf_Pad16(
97 Buf* self)
98 {
99 MI_Uint32 offset = (self->size + 1) & ~1;
100
101 if (offset > self->capacity)
102 {
103 if (Buf_Reserve(self, offset) != MI_RESULT_OK)
104 return MI_RESULT_FAILED;
105 }
106
107 self->size = offset;
108 return MI_RESULT_OK;
109 }
110
111 /* Pad buffer out to the next 4-byte boundary */
112 MI_INLINE MI_Result Buf_Pad32(
113 Buf* self)
114 {
115 MI_Uint32 offset = (self->size + 3) & ~3;
116 mike 1.1
117 if (offset > self->capacity)
118 {
119 if (Buf_Reserve(self, offset) != MI_RESULT_OK)
120 return MI_RESULT_FAILED;
121 }
122
123 self->size = offset;
124 return MI_RESULT_OK;
125 }
126
127 /* Pad buffer out to the next 8-byte boundary */
128 MI_INLINE MI_Result Buf_Pad64(
129 Buf* self)
130 {
131 MI_Uint32 offset = (self->size + 7) & ~7;
132
133 if (offset > self->capacity)
134 {
135 if (Buf_Reserve(self, offset) != MI_RESULT_OK)
136 return MI_RESULT_FAILED;
137 mike 1.1 }
138
139 self->size = offset;
140 return MI_RESULT_OK;
141 }
142
143 /* Align buffer on the next 2 byte boundary */
144 MI_INLINE MI_Result Buf_Align16(
145 Buf* self)
146 {
147 MI_Uint32 offset = (self->offset + 1) & ~1;
148
149 if (offset > self->size)
150 return MI_RESULT_FAILED;
151
152 self->offset = offset;
153 return MI_RESULT_OK;
154 }
155
156 /* Align buffer on the next 4 byte boundary */
157 MI_INLINE MI_Result Buf_Align32(
158 mike 1.1 Buf* self)
159 {
160 MI_Uint32 offset = (self->offset + 3) & ~3;
161
162 if (offset > self->size)
163 return MI_RESULT_FAILED;
164
165 self->offset = offset;
166 return MI_RESULT_OK;
167 }
168
169 /* Align buffer on the next 8 byte boundary */
170 MI_INLINE MI_Result Buf_Align64(
171 Buf* self)
172 {
173 MI_Uint32 offset = (self->offset + 7) & ~7;
174
175 if (offset > self->size)
176 return MI_RESULT_FAILED;
177
178 self->offset = offset;
179 mike 1.1 return MI_RESULT_OK;
180 }
181
182 MI_INLINE MI_Result Buf_PackU8(
183 Buf* self,
184 MI_Uint8 x)
185 {
186 MI_Uint32 offset = self->size;
187
188 if (offset + sizeof(x) > self->capacity)
189 {
190 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
191 return MI_RESULT_FAILED;
192 }
193
194 *((MI_Uint8*)((char*)self->data + offset)) = x;
195 self->size = offset + sizeof(x);
196 return MI_RESULT_OK;
197 }
198
199 MI_INLINE MI_Result Buf_PackU16(
200 mike 1.1 Buf* self,
201 MI_Uint16 x)
202 {
203 MI_Uint32 offset = (self->size + 1) & ~1;
204
205 if (offset + sizeof(x) > self->capacity)
206 {
207 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
208 return MI_RESULT_FAILED;
209 }
210
211 *((MI_Uint16*)((char*)self->data + offset)) = x;
212 self->size = offset + sizeof(x);
213 return MI_RESULT_OK;
214 }
215
216 MI_INLINE MI_Result Buf_PackU32(
217 Buf* self,
218 MI_Uint32 x)
219 {
220 MI_Uint32 offset = (self->size + 3) & ~3;
221 mike 1.1
222 if (offset + sizeof(x) > self->capacity)
223 {
224 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
225 return MI_RESULT_FAILED;
226 }
227
228 *((MI_Uint32*)((char*)self->data + offset)) = x;
229 self->size = offset + sizeof(x);
230 return MI_RESULT_OK;
231 }
232
233 MI_INLINE MI_Result Buf_PackU64(
234 Buf* self,
235 MI_Uint64 x)
236 {
237 MI_Uint32 offset = (self->size + 7) & ~7;
238
239 if (offset + sizeof(x) > self->capacity)
240 {
241 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
242 mike 1.1 return MI_RESULT_FAILED;
243 }
244
245 *((MI_Uint64*)((char*)self->data + offset)) = x;
246 self->size = offset + sizeof(x);
247 return MI_RESULT_OK;
248 }
249
250 MI_Result Buf_PackStr(
251 Buf* self,
|
252 krisbash 1.3 const ZChar* x);
253
254 MI_Result Buf_PackStrLen(
255 Buf* self,
256 const ZChar* x,
257 MI_Uint32 size);
|
258 mike 1.1
259 MI_INLINE MI_Result Buf_PackU8A(
260 Buf* self,
261 MI_Uint8* data,
262 MI_Uint32 size)
263 {
264 MI_RETURN_ERR(Buf_PackU32(self, size));
265
266 if (size)
267 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint8)));
268
269 return MI_RESULT_OK;
270 }
271
272 MI_INLINE MI_Result Buf_PackU16A(
273 Buf* self,
274 MI_Uint16* data,
275 MI_Uint32 size)
276 {
277 MI_RETURN_ERR(Buf_PackU32(self, size));
278
279 mike 1.1 if (size)
280 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint16)));
281
282 return MI_RESULT_OK;
283 }
284
285 MI_INLINE MI_Result Buf_PackU32A(
286 Buf* self,
287 MI_Uint32* data,
288 MI_Uint32 size)
289 {
290 MI_RETURN_ERR(Buf_PackU32(self, size));
291
292 if (size)
293 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint32)));
294
295 return MI_RESULT_OK;
296 }
297
298 MI_INLINE MI_Result Buf_PackU64A(
299 Buf* self,
300 mike 1.1 MI_Uint64* data,
301 MI_Uint32 size)
302 {
303 MI_RETURN_ERR(Buf_PackU32(self, size));
304
305 if (size)
306 {
307 MI_RETURN_ERR(Buf_Pad64(self));
308 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint64)));
309 }
310
311 return MI_RESULT_OK;
312 }
313
314 MI_INLINE MI_Result Buf_UnpackU8(
315 Buf* self,
316 MI_Uint8* x)
317 {
318 MI_Uint32 offset = self->offset;
319
320 if (offset + sizeof(*x) > self->size)
321 mike 1.1 return MI_RESULT_FAILED;
322
323 *x = *((MI_Uint8*)((char*)self->data + offset));
324 self->offset = offset + sizeof(*x);
325 return MI_RESULT_OK;
326 }
327
328 MI_INLINE MI_Result Buf_UnpackU16(
329 Buf* self,
330 MI_Uint16* x)
331 {
332 MI_Uint32 offset = (self->offset + 1) & ~1;
333
334 if (offset + sizeof(*x) > self->size)
335 return MI_RESULT_FAILED;
336
337 *x = *((MI_Uint16*)((char*)self->data + offset));
338 self->offset = offset + sizeof(*x);
339 return MI_RESULT_OK;
340 }
341
342 mike 1.1 MI_INLINE MI_Result Buf_UnpackU32(
343 Buf* self,
344 MI_Uint32* x)
345 {
346 MI_Uint32 offset = (self->offset + 3) & ~3;
347
348 if (offset + sizeof(*x) > self->size)
349 return MI_RESULT_FAILED;
350
351 *x = *((MI_Uint32*)((char*)self->data + offset));
352 self->offset = offset + sizeof(*x);
353 return MI_RESULT_OK;
354 }
355
356 MI_INLINE MI_Result Buf_UnpackU64(
357 Buf* self,
358 MI_Uint64* x)
359 {
360 MI_Uint32 offset = (self->offset + 7) & ~7;
361
362 if (offset + sizeof(*x) > self->size)
363 mike 1.1 return MI_RESULT_FAILED;
364
365 *x = *((MI_Uint64*)((char*)self->data + offset));
366 self->offset = offset + sizeof(*x);
367 return MI_RESULT_OK;
368 }
369
|
370 krisbash 1.3 MI_Result Buf_PackPtrdiff_t (
371 Buf* self,
372 ptrdiff_t data);
373
374 MI_Result Buf_UnpackPtrdiff_t (
375 Buf* self,
376 ptrdiff_t* x);
377
|
378 mike 1.1 MI_Result Buf_UnpackU8A(
379 Buf* self,
380 const MI_Uint8** data,
381 MI_Uint32* size);
382
383 MI_Result Buf_UnpackU16A(
384 Buf* self,
385 const MI_Uint16** data,
386 MI_Uint32* size);
387
388 MI_Result Buf_UnpackU32A(
389 Buf* self,
390 const MI_Uint32** data,
391 MI_Uint32* size);
392
393 MI_Result Buf_UnpackU64A(
394 Buf* self,
395 const MI_Uint64** data,
396 MI_Uint32* size);
397
398 MI_Result Buf_UnpackStr(
399 mike 1.1 Buf* self,
|
400 krisbash 1.3 const ZChar** x);
|
401 mike 1.1
402 MI_Result Buf_PackStrA(
403 Buf* self,
|
404 krisbash 1.3 const ZChar** data,
|
405 mike 1.1 MI_Uint32 size);
406
407 MI_Result Buf_UnpackStrA(
408 Buf* self,
|
409 krisbash 1.3 const ZChar*** data,
|
410 mike 1.1 MI_Uint32* size);
411
412 MI_Result Buf_PackDT(
413 Buf* self,
414 const MI_Datetime* x);
415
416 MI_Result Buf_UnpackDT(
417 Buf* self,
418 MI_Datetime* x);
419
420 MI_Result Buf_PackDTA(
421 Buf* self,
422 const MI_Datetime* data,
423 MI_Uint32 size);
424
425 MI_Result Buf_UnpackDTA(
426 Buf* self,
427 const MI_Datetime** dataPtr,
428 MI_Uint32* sizePtr);
429
|
430 krisbash 1.3 MI_Result Buf_AppStr(
431 Buf* self,
432 const ZChar* str);
433
434 MI_Result Buf_AppStrN(
435 Buf* self,
436 const ZChar* str,
437 size_t size);
438
|
439 mike 1.1 END_EXTERNC
440
441 #endif /* _omi_buf_h */
|
Return to
buf.h
CVS log
Up to [OMI] / omi / base