VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/asn1/asn1-ut-bitstring.cpp

Last change on this file was 100489, checked in by vboxsync, 10 months ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use