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 MI_Result Buf_App(
76 Buf* self,
77 const void* data,
78 MI_Uint32 size);
79
80 /* Pad buffer out to the next 2-byte boundary */
81 MI_INLINE MI_Result Buf_Pad16(
82 Buf* self)
83 {
84 MI_Uint32 offset = (self->size + 1) & ~1;
85 mike 1.1
86 if (offset > self->capacity)
87 {
88 if (Buf_Reserve(self, offset) != MI_RESULT_OK)
89 return MI_RESULT_FAILED;
90 }
91
92 self->size = offset;
93 return MI_RESULT_OK;
94 }
95
96 /* Pad buffer out to the next 4-byte boundary */
97 MI_INLINE MI_Result Buf_Pad32(
98 Buf* self)
99 {
100 MI_Uint32 offset = (self->size + 3) & ~3;
101
102 if (offset > self->capacity)
103 {
104 if (Buf_Reserve(self, offset) != MI_RESULT_OK)
105 return MI_RESULT_FAILED;
106 mike 1.1 }
107
108 self->size = offset;
109 return MI_RESULT_OK;
110 }
111
112 /* Pad buffer out to the next 8-byte boundary */
113 MI_INLINE MI_Result Buf_Pad64(
114 Buf* self)
115 {
116 MI_Uint32 offset = (self->size + 7) & ~7;
117
118 if (offset > self->capacity)
119 {
120 if (Buf_Reserve(self, offset) != MI_RESULT_OK)
121 return MI_RESULT_FAILED;
122 }
123
124 self->size = offset;
125 return MI_RESULT_OK;
126 }
127 mike 1.1
128 /* Align buffer on the next 2 byte boundary */
129 MI_INLINE MI_Result Buf_Align16(
130 Buf* self)
131 {
132 MI_Uint32 offset = (self->offset + 1) & ~1;
133
134 if (offset > self->size)
135 return MI_RESULT_FAILED;
136
137 self->offset = offset;
138 return MI_RESULT_OK;
139 }
140
141 /* Align buffer on the next 4 byte boundary */
142 MI_INLINE MI_Result Buf_Align32(
143 Buf* self)
144 {
145 MI_Uint32 offset = (self->offset + 3) & ~3;
146
147 if (offset > self->size)
148 mike 1.1 return MI_RESULT_FAILED;
149
150 self->offset = offset;
151 return MI_RESULT_OK;
152 }
153
154 /* Align buffer on the next 8 byte boundary */
155 MI_INLINE MI_Result Buf_Align64(
156 Buf* self)
157 {
158 MI_Uint32 offset = (self->offset + 7) & ~7;
159
160 if (offset > self->size)
161 return MI_RESULT_FAILED;
162
163 self->offset = offset;
164 return MI_RESULT_OK;
165 }
166
167 MI_INLINE MI_Result Buf_PackU8(
168 Buf* self,
169 mike 1.1 MI_Uint8 x)
170 {
171 MI_Uint32 offset = self->size;
172
173 if (offset + sizeof(x) > self->capacity)
174 {
175 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
176 return MI_RESULT_FAILED;
177 }
178
179 *((MI_Uint8*)((char*)self->data + offset)) = x;
180 self->size = offset + sizeof(x);
181 return MI_RESULT_OK;
182 }
183
184 MI_INLINE MI_Result Buf_PackU16(
185 Buf* self,
186 MI_Uint16 x)
187 {
188 MI_Uint32 offset = (self->size + 1) & ~1;
189
190 mike 1.1 if (offset + sizeof(x) > self->capacity)
191 {
192 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
193 return MI_RESULT_FAILED;
194 }
195
196 *((MI_Uint16*)((char*)self->data + offset)) = x;
197 self->size = offset + sizeof(x);
198 return MI_RESULT_OK;
199 }
200
201 MI_INLINE MI_Result Buf_PackU32(
202 Buf* self,
203 MI_Uint32 x)
204 {
205 MI_Uint32 offset = (self->size + 3) & ~3;
206
207 if (offset + sizeof(x) > self->capacity)
208 {
209 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
210 return MI_RESULT_FAILED;
211 mike 1.1 }
212
213 *((MI_Uint32*)((char*)self->data + offset)) = x;
214 self->size = offset + sizeof(x);
215 return MI_RESULT_OK;
216 }
217
218 MI_INLINE MI_Result Buf_PackU64(
219 Buf* self,
220 MI_Uint64 x)
221 {
222 MI_Uint32 offset = (self->size + 7) & ~7;
223
224 if (offset + sizeof(x) > self->capacity)
225 {
226 if (Buf_Reserve(self, offset + sizeof(x)) != MI_RESULT_OK)
227 return MI_RESULT_FAILED;
228 }
229
230 *((MI_Uint64*)((char*)self->data + offset)) = x;
231 self->size = offset + sizeof(x);
232 mike 1.1 return MI_RESULT_OK;
233 }
234
235 MI_Result Buf_PackStr(
236 Buf* self,
237 const MI_Char* x);
238
239 MI_INLINE MI_Result Buf_PackU8A(
240 Buf* self,
241 MI_Uint8* data,
242 MI_Uint32 size)
243 {
244 MI_RETURN_ERR(Buf_PackU32(self, size));
245
246 if (size)
247 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint8)));
248
249 return MI_RESULT_OK;
250 }
251
252 MI_INLINE MI_Result Buf_PackU16A(
253 mike 1.1 Buf* self,
254 MI_Uint16* data,
255 MI_Uint32 size)
256 {
257 MI_RETURN_ERR(Buf_PackU32(self, size));
258
259 if (size)
260 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint16)));
261
262 return MI_RESULT_OK;
263 }
264
265 MI_INLINE MI_Result Buf_PackU32A(
266 Buf* self,
267 MI_Uint32* data,
268 MI_Uint32 size)
269 {
270 MI_RETURN_ERR(Buf_PackU32(self, size));
271
272 if (size)
273 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint32)));
274 mike 1.1
275 return MI_RESULT_OK;
276 }
277
278 MI_INLINE MI_Result Buf_PackU64A(
279 Buf* self,
280 MI_Uint64* data,
281 MI_Uint32 size)
282 {
283 MI_RETURN_ERR(Buf_PackU32(self, size));
284
285 if (size)
286 {
287 MI_RETURN_ERR(Buf_Pad64(self));
288 MI_RETURN_ERR(Buf_App(self, data, size * sizeof(MI_Uint64)));
289 }
290
291 return MI_RESULT_OK;
292 }
293
294 MI_INLINE MI_Result Buf_UnpackU8(
295 mike 1.1 Buf* self,
296 MI_Uint8* x)
297 {
298 MI_Uint32 offset = self->offset;
299
300 if (offset + sizeof(*x) > self->size)
301 return MI_RESULT_FAILED;
302
303 *x = *((MI_Uint8*)((char*)self->data + offset));
304 self->offset = offset + sizeof(*x);
305 return MI_RESULT_OK;
306 }
307
308 MI_INLINE MI_Result Buf_UnpackU16(
309 Buf* self,
310 MI_Uint16* x)
311 {
312 MI_Uint32 offset = (self->offset + 1) & ~1;
313
314 if (offset + sizeof(*x) > self->size)
315 return MI_RESULT_FAILED;
316 mike 1.1
317 *x = *((MI_Uint16*)((char*)self->data + offset));
318 self->offset = offset + sizeof(*x);
319 return MI_RESULT_OK;
320 }
321
322 MI_INLINE MI_Result Buf_UnpackU32(
323 Buf* self,
324 MI_Uint32* x)
325 {
326 MI_Uint32 offset = (self->offset + 3) & ~3;
327
328 if (offset + sizeof(*x) > self->size)
329 return MI_RESULT_FAILED;
330
331 *x = *((MI_Uint32*)((char*)self->data + offset));
332 self->offset = offset + sizeof(*x);
333 return MI_RESULT_OK;
334 }
335
336 MI_INLINE MI_Result Buf_UnpackU64(
337 mike 1.1 Buf* self,
338 MI_Uint64* x)
339 {
340 MI_Uint32 offset = (self->offset + 7) & ~7;
341
342 if (offset + sizeof(*x) > self->size)
343 return MI_RESULT_FAILED;
344
345 *x = *((MI_Uint64*)((char*)self->data + offset));
346 self->offset = offset + sizeof(*x);
347 return MI_RESULT_OK;
348 }
349
350 MI_Result Buf_UnpackU8A(
351 Buf* self,
352 const MI_Uint8** data,
353 MI_Uint32* size);
354
355 MI_Result Buf_UnpackU16A(
356 Buf* self,
357 const MI_Uint16** data,
358 mike 1.1 MI_Uint32* size);
359
360 MI_Result Buf_UnpackU32A(
361 Buf* self,
362 const MI_Uint32** data,
363 MI_Uint32* size);
364
365 MI_Result Buf_UnpackU64A(
366 Buf* self,
367 const MI_Uint64** data,
368 MI_Uint32* size);
369
370 MI_Result Buf_UnpackStr(
371 Buf* self,
372 const MI_Char** x);
373
374 MI_Result Buf_PackStrA(
375 Buf* self,
376 const MI_Char** data,
377 MI_Uint32 size);
378
379 mike 1.1 MI_Result Buf_UnpackStrA(
380 Buf* self,
381 const MI_Char*** data,
382 MI_Uint32* size);
383
384 MI_Result Buf_PackDT(
385 Buf* self,
386 const MI_Datetime* x);
387
388 MI_Result Buf_UnpackDT(
389 Buf* self,
390 MI_Datetime* x);
391
392 MI_Result Buf_PackDTA(
393 Buf* self,
394 const MI_Datetime* data,
395 MI_Uint32 size);
396
397 MI_Result Buf_UnpackDTA(
398 Buf* self,
399 const MI_Datetime** dataPtr,
400 mike 1.1 MI_Uint32* sizePtr);
401
402 END_EXTERNC
403
404 #endif /* _omi_buf_h */
|
Return to
buf.h
CVS log
Up to [OMI] / omi / base