1 | /* $Id: asn1-ut-bitstring.cpp 69111 2017-10-17 14:26:02Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - ASN.1, Bit String Type.
|
---|
4 | *
|
---|
5 | * @remarks This file should remain very similar to asn1-ut-octetstring.cpp.
|
---|
6 | */
|
---|
7 |
|
---|
8 | /*
|
---|
9 | * Copyright (C) 2006-2017 Oracle Corporation
|
---|
10 | *
|
---|
11 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
12 | * available from http://www.virtualbox.org. This file is free software;
|
---|
13 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
14 | * General Public License (GPL) as published by the Free Software
|
---|
15 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
16 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
17 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
18 | *
|
---|
19 | * The contents of this file may alternatively be used under the terms
|
---|
20 | * of the Common Development and Distribution License Version 1.0
|
---|
21 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
22 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
23 | * CDDL are applicable instead of those of the GPL.
|
---|
24 | *
|
---|
25 | * You may elect to license modified versions of this file under the
|
---|
26 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
27 | */
|
---|
28 |
|
---|
29 |
|
---|
30 | /*********************************************************************************************************************************
|
---|
31 | * Header Files *
|
---|
32 | *********************************************************************************************************************************/
|
---|
33 | #include "internal/iprt.h"
|
---|
34 | #include <iprt/asn1.h>
|
---|
35 |
|
---|
36 | #include <iprt/alloca.h>
|
---|
37 | #include <iprt/bignum.h>
|
---|
38 | #include <iprt/ctype.h>
|
---|
39 | #include <iprt/err.h>
|
---|
40 | #include <iprt/string.h>
|
---|
41 | #include <iprt/uni.h>
|
---|
42 |
|
---|
43 | #include <iprt/formats/asn1.h>
|
---|
44 |
|
---|
45 |
|
---|
46 | /*********************************************************************************************************************************
|
---|
47 | * Structures and Typedefs *
|
---|
48 | *********************************************************************************************************************************/
|
---|
49 | typedef struct RTASN1BITSTRINGWRITERCTX
|
---|
50 | {
|
---|
51 | /** Pointer to the output buffer. */
|
---|
52 | uint8_t *pbBuf;
|
---|
53 | /** The current buffer offset. */
|
---|
54 | uint32_t offBuf;
|
---|
55 | /** The size of the buffer. */
|
---|
56 | uint32_t cbBuf;
|
---|
57 | } RTASN1BITSTRINGWRITERCTX;
|
---|
58 |
|
---|
59 |
|
---|
60 | /** @callback_method_impl{FNRTASN1ENCODEWRITER,
|
---|
61 | * Used to refresh the content of octet and bit strings. } */
|
---|
62 | static DECLCALLBACK(int) rtAsn1BitStringEncodeWriter(const void *pvBuf, size_t cbToWrite, void *pvUser, PRTERRINFO pErrInfo)
|
---|
63 | {
|
---|
64 | RTASN1BITSTRINGWRITERCTX *pCtx = (RTASN1BITSTRINGWRITERCTX *)pvUser;
|
---|
65 | AssertReturn(cbToWrite <= pCtx->cbBuf - pCtx->offBuf,
|
---|
66 | RTErrInfoSetF(pErrInfo, VERR_BUFFER_OVERFLOW,
|
---|
67 | "cbToWrite=%#x offBuf=%#x cbBuf=%#x", cbToWrite, pCtx->cbBuf, pCtx->offBuf));
|
---|
68 | memcpy(&pCtx->pbBuf[pCtx->offBuf], pvBuf, cbToWrite);
|
---|
69 | pCtx->offBuf += (uint32_t)cbToWrite;
|
---|
70 | return VINF_SUCCESS;
|
---|
71 | }
|
---|
72 |
|
---|
73 |
|
---|
74 | /** @callback_method_impl{FNRTASN1ENCODEWRITER,
|
---|
75 | * Used to compare the encoded raw content of an octet or bit string with the
|
---|
76 | * encapsulated object. } */
|
---|
77 | static DECLCALLBACK(int) rtAsn1BitStringEncodeCompare(const void *pvBuf, size_t cbToWrite, void *pvUser, PRTERRINFO pErrInfo)
|
---|
78 | {
|
---|
79 | RTASN1BITSTRINGWRITERCTX *pCtx = (RTASN1BITSTRINGWRITERCTX *)pvUser;
|
---|
80 | AssertReturn(cbToWrite <= pCtx->cbBuf - pCtx->offBuf, VERR_BUFFER_OVERFLOW);
|
---|
81 | if (memcmp(&pCtx->pbBuf[pCtx->offBuf], pvBuf, cbToWrite) != 0)
|
---|
82 | return VERR_NOT_EQUAL;
|
---|
83 | pCtx->offBuf += (uint32_t)cbToWrite;
|
---|
84 | RT_NOREF_PV(pErrInfo);
|
---|
85 | return VINF_SUCCESS;
|
---|
86 | }
|
---|
87 |
|
---|
88 |
|
---|
89 |
|
---|
90 | /*
|
---|
91 | * ASN.1 BIT STRING - Special Methods.
|
---|
92 | */
|
---|
93 |
|
---|
94 | RTDECL(uint64_t) RTAsn1BitString_GetAsUInt64(PCRTASN1BITSTRING pThis)
|
---|
95 | {
|
---|
96 | /*
|
---|
97 | * Extract the first 64 bits in host order.
|
---|
98 | */
|
---|
99 | uint8_t const *pb = pThis->uBits.pu8;
|
---|
100 | uint64_t uRet = 0;
|
---|
101 | uint32_t cShift = 0;
|
---|
102 | uint32_t cBits = RT_MIN(pThis->cBits, 64);
|
---|
103 | while (cBits > 0)
|
---|
104 | {
|
---|
105 | uint8_t b = *pb++;
|
---|
106 | #if 1 /* We don't have a bit-order constant... */
|
---|
107 | b = ((b & 0x01) << 7)
|
---|
108 | | ((b & 0x02) << 5)
|
---|
109 | | ((b & 0x04) << 3)
|
---|
110 | | ((b & 0x08) << 1)
|
---|
111 | | ((b & 0x10) >> 1)
|
---|
112 | | ((b & 0x20) >> 3)
|
---|
113 | | ((b & 0x40) >> 5)
|
---|
114 | | ((b & 0x80) >> 7);
|
---|
115 | #endif
|
---|
116 | if (cBits < 8)
|
---|
117 | {
|
---|
118 | b &= RT_BIT_32(cBits) - 1;
|
---|
119 | uRet |= (uint64_t)b << cShift;
|
---|
120 | break;
|
---|
121 | }
|
---|
122 | uRet |= (uint64_t)b << cShift;
|
---|
123 | cShift += 8;
|
---|
124 | cBits -= 8;
|
---|
125 | }
|
---|
126 |
|
---|
127 | return uRet;
|
---|
128 | }
|
---|
129 |
|
---|
130 |
|
---|
131 | RTDECL(int) RTAsn1BitString_RefreshContent(PRTASN1BITSTRING pThis, uint32_t fFlags,
|
---|
132 | PCRTASN1ALLOCATORVTABLE pAllocator, PRTERRINFO pErrInfo)
|
---|
133 | {
|
---|
134 | AssertReturn(pThis->pEncapsulated, VERR_INVALID_STATE);
|
---|
135 |
|
---|
136 | uint32_t cbEncoded;
|
---|
137 | int rc = RTAsn1EncodePrepare(pThis->pEncapsulated, fFlags, &cbEncoded, pErrInfo);
|
---|
138 | if (RT_SUCCESS(rc))
|
---|
139 | {
|
---|
140 | pThis->Asn1Core.cb = 1 + cbEncoded;
|
---|
141 | pThis->cBits = cbEncoded * 8;
|
---|
142 | AssertReturn(pThis->cBits / 8 == cbEncoded, RTErrInfoSetF(pErrInfo, VERR_TOO_MUCH_DATA, "cbEncoded=%#x", cbEncoded));
|
---|
143 |
|
---|
144 | rc = RTAsn1ContentReallocZ(&pThis->Asn1Core, cbEncoded + 1, pAllocator);
|
---|
145 | if (RT_SUCCESS(rc))
|
---|
146 | {
|
---|
147 | pThis->uBits.pu8 = pThis->Asn1Core.uData.pu8 + 1;
|
---|
148 |
|
---|
149 | /* Initialize the writer context and write the first byte concerning unused bits. */
|
---|
150 | RTASN1BITSTRINGWRITERCTX Ctx;
|
---|
151 | Ctx.pbBuf = (uint8_t *)pThis->Asn1Core.uData.pu8;
|
---|
152 | Ctx.cbBuf = cbEncoded + 1;
|
---|
153 | Ctx.offBuf = 1;
|
---|
154 | *Ctx.pbBuf = 0;
|
---|
155 |
|
---|
156 | rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, rtAsn1BitStringEncodeWriter, &Ctx, pErrInfo);
|
---|
157 | if (RT_SUCCESS(rc))
|
---|
158 | {
|
---|
159 | if (Ctx.offBuf == cbEncoded + 1)
|
---|
160 | return VINF_SUCCESS;
|
---|
161 |
|
---|
162 | rc = RTErrInfoSetF(pErrInfo, rc, "Expected %#x + 1 bytes, got %#x", cbEncoded, Ctx.offBuf);
|
---|
163 | }
|
---|
164 | }
|
---|
165 | else
|
---|
166 | rc = RTErrInfoSetF(pErrInfo, rc, "Error allocating %#x + 1 bytes for storing content\n", cbEncoded);
|
---|
167 | }
|
---|
168 | return rc;
|
---|
169 | }
|
---|
170 |
|
---|
171 |
|
---|
172 | RTDECL(bool) RTAsn1BitString_AreContentBitsValid(PCRTASN1BITSTRING pThis, uint32_t fFlags)
|
---|
173 | {
|
---|
174 | if (pThis->pEncapsulated)
|
---|
175 | {
|
---|
176 | if (pThis->cBits & 7)
|
---|
177 | return false;
|
---|
178 |
|
---|
179 | /* Check the encoded length of the bits. */
|
---|
180 | uint32_t cbEncoded;
|
---|
181 | int rc = RTAsn1EncodePrepare(pThis->pEncapsulated, fFlags, &cbEncoded, NULL);
|
---|
182 | if (RT_FAILURE(rc))
|
---|
183 | return false;
|
---|
184 | if (pThis->Asn1Core.cb != 1 + cbEncoded)
|
---|
185 | return false;
|
---|
186 |
|
---|
187 | /* Check the encoded bits, if there are any. */
|
---|
188 | if (cbEncoded)
|
---|
189 | {
|
---|
190 | if (!pThis->Asn1Core.uData.pv)
|
---|
191 | return false;
|
---|
192 |
|
---|
193 | /* Check the first byte, the unused bit count. */
|
---|
194 | if (*pThis->Asn1Core.uData.pu8 != 0)
|
---|
195 | return false;
|
---|
196 |
|
---|
197 | /* Check the other bytes. */
|
---|
198 | RTASN1BITSTRINGWRITERCTX Ctx;
|
---|
199 | Ctx.pbBuf = (uint8_t *)pThis->Asn1Core.uData.pu8;
|
---|
200 | Ctx.cbBuf = cbEncoded + 1;
|
---|
201 | Ctx.offBuf = 1;
|
---|
202 | rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, rtAsn1BitStringEncodeCompare, &Ctx, NULL);
|
---|
203 | if (RT_FAILURE(rc))
|
---|
204 | return false;
|
---|
205 | }
|
---|
206 | }
|
---|
207 | return true;
|
---|
208 | }
|
---|
209 |
|
---|
210 |
|
---|
211 |
|
---|
212 |
|
---|
213 | /*
|
---|
214 | * ASN.1 BIT STRING - Standard Methods.
|
---|
215 | */
|
---|
216 |
|
---|
217 | /** @interface_method_impl{FNRTASN1COREVTENCODEPREP} */
|
---|
218 | static DECLCALLBACK(int) RTAsn1BitString_EncodePrep(PRTASN1CORE pThisCore, uint32_t fFlags, PRTERRINFO pErrInfo)
|
---|
219 | {
|
---|
220 | PRTASN1BITSTRING pThis = (PRTASN1BITSTRING)pThisCore;
|
---|
221 | if (!pThis->pEncapsulated)
|
---|
222 | {
|
---|
223 | Assert(pThis->cBits == 0 || pThis->Asn1Core.uData.pv);
|
---|
224 | return VINF_SUCCESS;
|
---|
225 | }
|
---|
226 |
|
---|
227 | /* Figure out the size of the encapsulated content. */
|
---|
228 | uint32_t cbEncoded;
|
---|
229 | int rc = RTAsn1EncodePrepare(pThis->pEncapsulated, fFlags, &cbEncoded, pErrInfo);
|
---|
230 | if (RT_SUCCESS(rc))
|
---|
231 | {
|
---|
232 | /* Free the bytes if they don't match up. */
|
---|
233 | if (pThis->Asn1Core.uData.pv)
|
---|
234 | {
|
---|
235 | bool fMustFree = pThis->Asn1Core.cb != 1 + cbEncoded || (pThis->cBits & 7);
|
---|
236 | if (!fMustFree)
|
---|
237 | {
|
---|
238 | RTASN1BITSTRINGWRITERCTX Ctx;
|
---|
239 | Ctx.pbBuf = (uint8_t *)pThis->Asn1Core.uData.pu8;
|
---|
240 | Ctx.cbBuf = 1 + cbEncoded;
|
---|
241 | Ctx.offBuf = 1;
|
---|
242 | fMustFree = *Ctx.pbBuf != 0;
|
---|
243 | if (!fMustFree)
|
---|
244 | {
|
---|
245 | rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, rtAsn1BitStringEncodeCompare, &Ctx, NULL);
|
---|
246 | fMustFree = RT_FAILURE_NP(rc);
|
---|
247 | }
|
---|
248 | }
|
---|
249 | if (fMustFree)
|
---|
250 | {
|
---|
251 | pThis->uBits.pv = NULL;
|
---|
252 | RTAsn1ContentFree(&pThis->Asn1Core);
|
---|
253 | }
|
---|
254 | }
|
---|
255 | pThis->Asn1Core.cb = 1 + cbEncoded;
|
---|
256 | pThis->cBits = cbEncoded * 8;
|
---|
257 |
|
---|
258 | rc = RTAsn1EncodeRecalcHdrSize(&pThis->Asn1Core, fFlags, pErrInfo);
|
---|
259 | }
|
---|
260 | return rc;
|
---|
261 | }
|
---|
262 |
|
---|
263 |
|
---|
264 | /** @interface_method_impl{FNRTASN1COREVTENCODEWRITE} */
|
---|
265 | static DECLCALLBACK(int) RTAsn1BitString_EncodeWrite(PRTASN1CORE pThisCore, uint32_t fFlags, PFNRTASN1ENCODEWRITER pfnWriter,
|
---|
266 | void *pvUser, PRTERRINFO pErrInfo)
|
---|
267 | {
|
---|
268 | PRTASN1BITSTRING pThis = (PRTASN1BITSTRING)pThisCore;
|
---|
269 |
|
---|
270 | AssertReturn(RT_ALIGN(pThis->cBits, 8) / 8 + 1 == pThis->Asn1Core.cb, VERR_INTERNAL_ERROR_3);
|
---|
271 |
|
---|
272 | /*
|
---|
273 | * First the header.
|
---|
274 | */
|
---|
275 | int rc = RTAsn1EncodeWriteHeader(&pThis->Asn1Core, fFlags, pfnWriter, pvUser, pErrInfo);
|
---|
276 | if (RT_SUCCESS(rc) && rc != VINF_ASN1_NOT_ENCODED)
|
---|
277 | {
|
---|
278 | /*
|
---|
279 | * The content starts with an unused bit count. Calculate it in case we
|
---|
280 | * need to write it out.
|
---|
281 | */
|
---|
282 | uint8_t cUnusedBits = 0;
|
---|
283 | if ((pThis->cBits & 7) != 0)
|
---|
284 | cUnusedBits = 8 - (pThis->cBits & 7);
|
---|
285 |
|
---|
286 | /*
|
---|
287 | * If nothing is encapsulated, the core points to the content (if we have any).
|
---|
288 | */
|
---|
289 | if (!pThis->pEncapsulated)
|
---|
290 | {
|
---|
291 | if (pThis->cBits > 0)
|
---|
292 | {
|
---|
293 | Assert(pThis->Asn1Core.uData.pu8[0] == cUnusedBits);
|
---|
294 | rc = pfnWriter(pThis->Asn1Core.uData.pu8, pThis->Asn1Core.cb, pvUser, pErrInfo);
|
---|
295 | }
|
---|
296 | else
|
---|
297 | rc = pfnWriter(&cUnusedBits, sizeof(cUnusedBits), pvUser, pErrInfo);
|
---|
298 | }
|
---|
299 | /*
|
---|
300 | * Write the unused bit count and then call upon the encapsulated
|
---|
301 | * content to serialize itself.
|
---|
302 | */
|
---|
303 | else
|
---|
304 | {
|
---|
305 | rc = pfnWriter(&cUnusedBits, sizeof(cUnusedBits), pvUser, pErrInfo);
|
---|
306 | if (RT_SUCCESS(rc))
|
---|
307 | rc = RTAsn1EncodeWrite(pThis->pEncapsulated, fFlags, pfnWriter, pvUser, pErrInfo);
|
---|
308 | }
|
---|
309 | }
|
---|
310 | return rc;
|
---|
311 | }
|
---|
312 |
|
---|
313 |
|
---|
314 | RT_DECL_DATA_CONST(RTASN1COREVTABLE const) g_RTAsn1BitString_Vtable =
|
---|
315 | {
|
---|
316 | "RTAsn1BitString",
|
---|
317 | sizeof(RTASN1BITSTRING),
|
---|
318 | ASN1_TAG_BIT_STRING,
|
---|
319 | ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
|
---|
320 | 0,
|
---|
321 | (PFNRTASN1COREVTDTOR)RTAsn1BitString_Delete,
|
---|
322 | (PFNRTASN1COREVTENUM)RTAsn1BitString_Enum,
|
---|
323 | (PFNRTASN1COREVTCLONE)RTAsn1BitString_Clone,
|
---|
324 | (PFNRTASN1COREVTCOMPARE)RTAsn1BitString_Compare,
|
---|
325 | (PFNRTASN1COREVTCHECKSANITY)RTAsn1BitString_CheckSanity,
|
---|
326 | RTAsn1BitString_EncodePrep,
|
---|
327 | RTAsn1BitString_EncodeWrite
|
---|
328 | };
|
---|
329 |
|
---|
330 |
|
---|
331 | RTDECL(int) RTAsn1BitString_Init(PRTASN1BITSTRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator)
|
---|
332 | {
|
---|
333 | RT_ZERO(*pThis);
|
---|
334 |
|
---|
335 | RTAsn1Core_InitEx(&pThis->Asn1Core, ASN1_TAG_BIT_STRING, ASN1_TAGCLASS_UNIVERSAL | ASN1_TAGFLAG_PRIMITIVE,
|
---|
336 | &g_RTAsn1BitString_Vtable, RTASN1CORE_F_PRESENT | RTASN1CORE_F_PRIMITE_TAG_STRUCT);
|
---|
337 | /*pThis->cBits = 0;
|
---|
338 | pThis->cMaxBits = 0;
|
---|
339 | pThis->uBits.pv = NULL;
|
---|
340 | pThis->pEncapsulated = NULL; */
|
---|
341 | RTAsn1MemInitAllocation(&pThis->EncapsulatedAllocation, pAllocator);
|
---|
342 |
|
---|
343 | return VINF_SUCCESS;
|
---|
344 | }
|
---|
345 |
|
---|
346 |
|
---|
347 | RTDECL(int) RTAsn1BitString_Clone(PRTASN1BITSTRING pThis, PCRTASN1BITSTRING pSrc, PCRTASN1ALLOCATORVTABLE pAllocator)
|
---|
348 | {
|
---|
349 | AssertPtr(pSrc); AssertPtr(pThis); AssertPtr(pAllocator);
|
---|
350 |
|
---|
351 | RT_ZERO(*pThis);
|
---|
352 | if (RTAsn1BitString_IsPresent(pSrc))
|
---|
353 | {
|
---|
354 | AssertReturn(pSrc->Asn1Core.pOps == &g_RTAsn1BitString_Vtable, VERR_INTERNAL_ERROR_3);
|
---|
355 |
|
---|
356 | int rc;
|
---|
357 | if (!pSrc->pEncapsulated)
|
---|
358 | rc = RTAsn1Core_CloneContent(&pThis->Asn1Core, &pSrc->Asn1Core, pAllocator);
|
---|
359 | else
|
---|
360 | rc = RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
|
---|
361 | if (RT_FAILURE(rc))
|
---|
362 | return rc;
|
---|
363 |
|
---|
364 | RTAsn1MemInitAllocation(&pThis->EncapsulatedAllocation, pAllocator);
|
---|
365 | pThis->cBits = pSrc->cBits;
|
---|
366 | pThis->cMaxBits = pSrc->cMaxBits;
|
---|
367 | if (!pSrc->pEncapsulated)
|
---|
368 | pThis->uBits.pv = pThis->Asn1Core.uData.pu8 ? pThis->Asn1Core.uData.pu8 + 1 : NULL;
|
---|
369 | else
|
---|
370 | {
|
---|
371 | PCRTASN1COREVTABLE pOps = pSrc->pEncapsulated->pOps;
|
---|
372 | Assert(!pOps || pOps->pfnClone);
|
---|
373 | if (pOps && pOps->pfnClone)
|
---|
374 | {
|
---|
375 | /* We can clone the decoded encapsulated object. */
|
---|
376 | rc = RTAsn1MemAllocZ(&pThis->EncapsulatedAllocation, (void **)&pThis->pEncapsulated, pOps->cbStruct);
|
---|
377 | if (RT_SUCCESS(rc))
|
---|
378 | {
|
---|
379 | rc = pOps->pfnClone(pThis->pEncapsulated, pSrc->pEncapsulated, pAllocator);
|
---|
380 | if (RT_FAILURE(rc))
|
---|
381 | RTAsn1MemFree(&pThis->EncapsulatedAllocation, pThis->pEncapsulated);
|
---|
382 | }
|
---|
383 | }
|
---|
384 | else
|
---|
385 | {
|
---|
386 | /* Borrow the encapsulated pointer and use RTAsn1BitString_RefreshContent
|
---|
387 | to get an accurate copy of the bytes. */
|
---|
388 | pThis->pEncapsulated = pSrc->pEncapsulated;
|
---|
389 | rc = RTAsn1BitString_RefreshContent(pThis, RTASN1ENCODE_F_DER, pAllocator, NULL);
|
---|
390 | pThis->pEncapsulated = NULL;
|
---|
391 | }
|
---|
392 | if (RT_FAILURE(rc))
|
---|
393 | {
|
---|
394 | RTAsn1ContentFree(&pThis->Asn1Core);
|
---|
395 | RT_ZERO(*pThis);
|
---|
396 | return rc;
|
---|
397 | }
|
---|
398 | }
|
---|
399 | }
|
---|
400 | return VINF_SUCCESS;
|
---|
401 | }
|
---|
402 |
|
---|
403 |
|
---|
404 | RTDECL(void) RTAsn1BitString_Delete(PRTASN1BITSTRING pThis)
|
---|
405 | {
|
---|
406 | if ( pThis
|
---|
407 | && RTAsn1BitString_IsPresent(pThis))
|
---|
408 | {
|
---|
409 | Assert(pThis->Asn1Core.pOps == &g_RTAsn1BitString_Vtable);
|
---|
410 |
|
---|
411 | /* Destroy the encapsulated object. */
|
---|
412 | if (pThis->pEncapsulated)
|
---|
413 | {
|
---|
414 | RTAsn1VtDelete(pThis->pEncapsulated);
|
---|
415 | if (pThis->EncapsulatedAllocation.cbAllocated)
|
---|
416 | RTAsn1MemFree(&pThis->EncapsulatedAllocation, pThis->pEncapsulated);
|
---|
417 | }
|
---|
418 |
|
---|
419 | /* Delete content and wipe the content. */
|
---|
420 | RTAsn1ContentFree(&pThis->Asn1Core);
|
---|
421 | RT_ZERO(*pThis);
|
---|
422 | }
|
---|
423 | }
|
---|
424 |
|
---|
425 |
|
---|
426 | RTDECL(int) RTAsn1BitString_Enum(PRTASN1BITSTRING pThis, PFNRTASN1ENUMCALLBACK pfnCallback, uint32_t uDepth, void *pvUser)
|
---|
427 | {
|
---|
428 | Assert(pThis && (!RTAsn1BitString_IsPresent(pThis) || pThis->Asn1Core.pOps == &g_RTAsn1BitString_Vtable));
|
---|
429 |
|
---|
430 | /* Enumerate the encapsulated object if present. */
|
---|
431 | if (pThis->pEncapsulated)
|
---|
432 | return pfnCallback(pThis->pEncapsulated, "Encapsulated", uDepth + 1, pvUser);
|
---|
433 | return VINF_SUCCESS;
|
---|
434 | }
|
---|
435 |
|
---|
436 |
|
---|
437 | RTDECL(int) RTAsn1BitString_Compare(PCRTASN1BITSTRING pLeft, PCRTASN1BITSTRING pRight)
|
---|
438 | {
|
---|
439 | Assert(pLeft && (!RTAsn1BitString_IsPresent(pLeft) || pLeft->Asn1Core.pOps == &g_RTAsn1BitString_Vtable));
|
---|
440 | Assert(pRight && (!RTAsn1BitString_IsPresent(pRight) || pRight->Asn1Core.pOps == &g_RTAsn1BitString_Vtable));
|
---|
441 |
|
---|
442 | int iDiff;
|
---|
443 | if (RTAsn1BitString_IsPresent(pLeft))
|
---|
444 | {
|
---|
445 | if (RTAsn1BitString_IsPresent(pRight))
|
---|
446 | {
|
---|
447 | /* Since it's really hard to tell whether encapsulated objects have
|
---|
448 | been modified or not, we might have to refresh both objects
|
---|
449 | while doing this compare. We'll try our best to avoid it though. */
|
---|
450 | if (pLeft->pEncapsulated || pRight->pEncapsulated)
|
---|
451 | {
|
---|
452 | if ( pLeft->pEncapsulated
|
---|
453 | && pRight->pEncapsulated
|
---|
454 | && pLeft->pEncapsulated->pOps == pRight->pEncapsulated->pOps)
|
---|
455 | iDiff = pLeft->pEncapsulated->pOps->pfnCompare(pLeft->pEncapsulated, pRight->pEncapsulated);
|
---|
456 | else
|
---|
457 | {
|
---|
458 | /* No direct comparison of encapsulated objects possible,
|
---|
459 | make sure we've got the rigth bytes then. */
|
---|
460 | if ( pLeft->pEncapsulated
|
---|
461 | && !RTAsn1BitString_AreContentBitsValid(pLeft, RTASN1ENCODE_F_DER))
|
---|
462 | {
|
---|
463 | int rc = RTAsn1BitString_RefreshContent((PRTASN1BITSTRING)pLeft, RTASN1ENCODE_F_DER,
|
---|
464 | pLeft->EncapsulatedAllocation.pAllocator, NULL);
|
---|
465 | AssertRC(rc);
|
---|
466 | }
|
---|
467 |
|
---|
468 | if ( pRight->pEncapsulated
|
---|
469 | && !RTAsn1BitString_AreContentBitsValid(pRight, RTASN1ENCODE_F_DER))
|
---|
470 | {
|
---|
471 | int rc = RTAsn1BitString_RefreshContent((PRTASN1BITSTRING)pRight, RTASN1ENCODE_F_DER,
|
---|
472 | pRight->EncapsulatedAllocation.pAllocator, NULL);
|
---|
473 | AssertRC(rc);
|
---|
474 | }
|
---|
475 |
|
---|
476 | /* Compare the content bytes. */
|
---|
477 | iDiff = RTAsn1Core_CompareEx(&pLeft->Asn1Core, &pRight->Asn1Core, true /*fIgnoreTagAndClass*/);
|
---|
478 | }
|
---|
479 | }
|
---|
480 | /*
|
---|
481 | * No encapsulated object, just compare the raw content bytes.
|
---|
482 | */
|
---|
483 | else
|
---|
484 | iDiff = RTAsn1Core_CompareEx(&pLeft->Asn1Core, &pRight->Asn1Core, true /*fIgnoreTagAndClass*/);
|
---|
485 | }
|
---|
486 | else
|
---|
487 | iDiff = -1;
|
---|
488 | }
|
---|
489 | else
|
---|
490 | iDiff = 0 - (int)RTAsn1BitString_IsPresent(pRight);
|
---|
491 | return iDiff;
|
---|
492 | }
|
---|
493 |
|
---|
494 |
|
---|
495 | RTDECL(int) RTAsn1BitString_CheckSanity(PCRTASN1BITSTRING pThis, uint32_t fFlags, PRTERRINFO pErrInfo, const char *pszErrorTag)
|
---|
496 | {
|
---|
497 | if (RT_UNLIKELY(!RTAsn1BitString_IsPresent(pThis)))
|
---|
498 | return RTErrInfoSetF(pErrInfo, VERR_ASN1_NOT_PRESENT, "%s: Missing (BIT STRING).", pszErrorTag);
|
---|
499 |
|
---|
500 | if (pThis->cBits > pThis->cMaxBits)
|
---|
501 | return RTErrInfoSetF(pErrInfo, VERR_ASN1_BITSTRING_OUT_OF_BOUNDS, "%s: Exceeding max bits: cBits=%u cMaxBits=%u.",
|
---|
502 | pszErrorTag, pThis->cBits, pThis->cMaxBits);
|
---|
503 |
|
---|
504 | if (pThis->pEncapsulated)
|
---|
505 | return pThis->pEncapsulated->pOps->pfnCheckSanity(pThis->pEncapsulated, fFlags & RTASN1_CHECK_SANITY_F_COMMON_MASK,
|
---|
506 | pErrInfo, pszErrorTag);
|
---|
507 | return VINF_SUCCESS;
|
---|
508 | }
|
---|
509 |
|
---|
510 | /*
|
---|
511 | * Generate code for the associated collection types.
|
---|
512 | */
|
---|
513 | #define RTASN1TMPL_TEMPLATE_FILE "../common/asn1/asn1-ut-bitstring-template.h"
|
---|
514 | #include <iprt/asn1-generator-internal-header.h>
|
---|
515 | #include <iprt/asn1-generator-core.h>
|
---|
516 | #include <iprt/asn1-generator-init.h>
|
---|
517 | #include <iprt/asn1-generator-sanity.h>
|
---|
518 |
|
---|