asn1-basics.cpp@ 57444

Last change on this file since 57444 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 19.5 KB

Line
1	/* $Id: asn1-basics.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* IPRT - ASN.1, Basic Operations.
4	*/
5
6	/*
7	* Copyright (C) 2006-2015 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#include "internal/iprt.h"
32	#include <iprt/asn1.h>
33
34	#include <iprt/alloca.h>
35	#include <iprt/bignum.h>
36	#include <iprt/ctype.h>
37	#include <iprt/err.h>
38	#include <iprt/string.h>
39	#include <iprt/uni.h>
40
41	#include <iprt/formats/asn1.h>
42
43
44	/*********************************************************************************************************************************
45	* Structures and Typedefs *
46	*********************************************************************************************************************************/
47	/**
48	* ASN.1 content/value allocation.
49	*
50	* The currently most frequent use of the RTAsn1 module is to decode ASN.1 byte
51	* streams. In that scenario we do not allocate memory for the raw content
52	* bytes, but share it with the byte stream. Also, a great number of RTASN1CORE
53	* structures will never need to have any content bytes allocated with this.
54	*
55	* So, in order to avoid adding an extra 16 (64-bit) or 8 (32-bit) bytes to each
56	* RTASN1CORE structure just to keep track of the occational content allocation,
57	* we put the allocator tracking structure inside the allocation. During
58	* allocator operations it lives temporarily on the stack.
59	*/
60	typedef struct RTASN1MEMCONTENT
61	{
62	/** The allocation tracker. */
63	RTASN1ALLOCATION Allocation;
64	#if ARCH_BITS == 32
65	uint32_t Padding; /*< Alignment padding. /
66	#endif
67	/** The content bytes, i.e. what RTASN1CORE::uData.pv points to. Use a 64-bit
68	* type here to emphasize that it's 8-byte aligned on all platforms. */
69	uint64_t au64Content[1];
70	} RTASN1MEMCONTENT;
71	AssertCompileMemberAlignment(RTASN1MEMCONTENT, au64Content, 8);
72	/** Pointer to a ASN.1 content allocation. */
73	typedef RTASN1MEMCONTENT *PRTASN1MEMCONTENT;
74
75
76
77
78	RTDECL(int) RTAsn1MemGrowArray(PRTASN1ALLOCATION pAllocation, void **ppvArray, size_t cbEntry,
79	uint32_t cCurrent, uint32_t cNew)
80	{
81	AssertReturn(pAllocation->pAllocator != NULL, VERR_WRONG_ORDER);
82	AssertReturn(cbEntry > 0, VERR_INVALID_PARAMETER);
83	AssertReturn(cNew > cCurrent, VERR_INVALID_PARAMETER);
84	AssertReturn(cNew < _1M, VERR_OUT_OF_RANGE);
85
86	pAllocation->cReallocs++;
87
88	void pvOld = ppvArray;
89
90	/* Initial allocation? */
91	if (cCurrent == 0)
92	{
93	AssertReturn(pvOld == NULL, VERR_INVALID_PARAMETER);
94	AssertReturn(cNew != 0, VERR_INVALID_PARAMETER);
95	return pAllocation->pAllocator->pfnAlloc(pAllocation->pAllocator, pAllocation, ppvArray, cNew * cbEntry);
96	}
97
98	/* Do we need to grow the allocation or did we already allocate sufficient memory in a previous call? */
99	size_t cbNew = cNew * cbEntry;
100	if (pAllocation->cbAllocated < cbNew)
101	{
102	/* Need to grow. Adjust the new size according to how many times we've been called. */
103	if (pAllocation->cReallocs > 2)
104	{
105	if (pAllocation->cReallocs > 8)
106	cNew += 8;
107	else if (pAllocation->cReallocs < 4)
108	cNew += 2;
109	else
110	cNew += 4;
111	cbNew += cNew * cbEntry;
112	}
113
114	int rc = pAllocation->pAllocator->pfnRealloc(pAllocation->pAllocator, pAllocation, pvOld, ppvArray, cbNew);
115	if (RT_FAILURE(rc))
116	return rc;
117	Assert(pAllocation->cbAllocated >= cbNew);
118
119	/* Clear the memory. */
120	size_t cbOld = cCurrent * cbEntry;
121	RT_BZERO((uint8_t )ppvArray + cbOld, pAllocation->cbAllocated - cbOld);
122	}
123
124	return VINF_SUCCESS;
125	}
126
127
128	RTDECL(int) RTAsn1MemAllocZ(PRTASN1ALLOCATION pAllocation, void **ppvMem, size_t cbMem)
129	{
130	AssertReturn(pAllocation->pAllocator != NULL, VERR_WRONG_ORDER);
131	AssertPtr(ppvMem);
132	Assert(cbMem > 0);
133	int rc = pAllocation->pAllocator->pfnAlloc(pAllocation->pAllocator, pAllocation, ppvMem, cbMem);
134	Assert(pAllocation->cbAllocated >= cbMem \|\| RT_FAILURE_NP(rc));
135	return rc;
136	}
137
138
139	RTDECL(int) RTAsn1MemDup(PRTASN1ALLOCATION pAllocation, void *ppvMem, const void pvSrc, size_t cbMem)
140	{
141	AssertReturn(pAllocation->pAllocator != NULL, VERR_WRONG_ORDER);
142	AssertPtr(ppvMem);
143	AssertPtr(pvSrc);
144	Assert(cbMem > 0);
145	int rc = pAllocation->pAllocator->pfnAlloc(pAllocation->pAllocator, pAllocation, ppvMem, cbMem);
146	if (RT_SUCCESS(rc))
147	{
148	Assert(pAllocation->cbAllocated >= cbMem);
149	memcpy(*ppvMem, pvSrc, cbMem);
150	return VINF_SUCCESS;
151	}
152	return rc;
153	}
154
155
156	RTDECL(void) RTAsn1MemFree(PRTASN1ALLOCATION pAllocation, void *pv)
157	{
158	Assert(pAllocation->pAllocator != NULL);
159	if (pv)
160	{
161	pAllocation->pAllocator->pfnFree(pAllocation->pAllocator, pAllocation, pv);
162	Assert(pAllocation->cbAllocated == 0);
163	}
164	}
165
166
167	RTDECL(PRTASN1ALLOCATION) RTAsn1MemInitAllocation(PRTASN1ALLOCATION pAllocation, PCRTASN1ALLOCATORVTABLE pAllocator)
168	{
169	pAllocation->cbAllocated = 0;
170	pAllocation->cReallocs = 0;
171	pAllocation->uReserved0 = 0;
172	pAllocation->pAllocator = pAllocator;
173	return pAllocation;
174	}
175
176
177	RTDECL(int) RTAsn1ContentAllocZ(PRTASN1CORE pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator)
178	{
179	AssertReturn(pAllocator != NULL, VERR_WRONG_ORDER);
180	AssertReturn(cb > 0 && cb < _1G, VERR_INVALID_PARAMETER);
181	AssertPtr(pAsn1Core);
182	AssertReturn(!(pAsn1Core->fFlags & RTASN1CORE_F_ALLOCATED_CONTENT), VERR_INVALID_STATE);
183
184	/* Initialize the temporary allocation tracker. */
185	RTASN1ALLOCATION Allocation;
186	Allocation.cbAllocated = 0;
187	Allocation.cReallocs = 0;
188	Allocation.uReserved0 = 0;
189	Allocation.pAllocator = pAllocator;
190
191	/* Make the allocation. */
192	uint32_t cbAlloc = RT_OFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
193	PRTASN1MEMCONTENT pHdr;
194	int rc = pAllocator->pfnAlloc(pAllocator, &Allocation, (void **)&pHdr, cbAlloc);
195	if (RT_SUCCESS(rc))
196	{
197	Assert(Allocation.cbAllocated >= cbAlloc);
198	pHdr->Allocation = Allocation;
199	pAsn1Core->cb = (uint32_t)cb;
200	pAsn1Core->uData.pv = &pHdr->au64Content[0];
201	pAsn1Core->fFlags \|= RTASN1CORE_F_ALLOCATED_CONTENT;
202	}
203
204	return rc;
205	}
206
207
208	RTDECL(int) RTAsn1ContentDup(PRTASN1CORE pAsn1Core, void const *pvSrc, size_t cbSrc, PCRTASN1ALLOCATORVTABLE pAllocator)
209	{
210	int rc = RTAsn1ContentAllocZ(pAsn1Core, cbSrc, pAllocator);
211	if (RT_SUCCESS(rc))
212	memcpy((void *)pAsn1Core->uData.pv, pvSrc, cbSrc);
213	return rc;
214	}
215
216
217	RTDECL(int) RTAsn1ContentReallocZ(PRTASN1CORE pAsn1Core, size_t cb, PCRTASN1ALLOCATORVTABLE pAllocator)
218	{
219	/* Validate input. */
220	AssertPtr(pAsn1Core);
221	AssertReturn(cb < _1G, VERR_INVALID_PARAMETER);
222
223	if (cb > 0)
224	{
225	/*
226	* Case 1 - Initial allocation.
227	*/
228	uint32_t cbNeeded = RT_OFFSETOF(RTASN1MEMCONTENT, au64Content) + (uint32_t)cb;
229	if (!(pAsn1Core->fFlags & RTASN1CORE_F_ALLOCATED_CONTENT))
230	return RTAsn1ContentAllocZ(pAsn1Core, cb, pAllocator);
231
232	/* Locate the header. */
233	PRTASN1MEMCONTENT pHdr = RT_FROM_MEMBER(pAsn1Core->uData.pv, RTASN1MEMCONTENT, au64Content);
234
235	/*
236	* Case 2 - Reallocation using the same allocator.
237	*/
238	if ( pHdr->Allocation.pAllocator == pAllocator
239	\|\| !pAllocator)
240	{
241	pHdr->Allocation.cReallocs++;
242
243	/* Modify the allocation if necessary. */
244	if (pHdr->Allocation.cbAllocated < cbNeeded)
245	{
246	RTASN1ALLOCATION Allocation = pHdr->Allocation;
247	int rc = Allocation.pAllocator->pfnRealloc(Allocation.pAllocator, &Allocation, pHdr, (void **)&pHdr, cbNeeded);
248	if (RT_FAILURE(rc))
249	return rc;
250	Assert(Allocation.cbAllocated >= cbNeeded);
251	pAsn1Core->uData.pv = &pHdr->au64Content[0];
252	pHdr->Allocation = Allocation;
253	}
254
255	/* Clear any additional memory we're letting the user use and
256	update the content size. */
257	if (pAsn1Core->cb < cb)
258	RT_BZERO((uint8_t *)&pAsn1Core->uData.pu8[pAsn1Core->cb], cb - pAsn1Core->cb);
259	pAsn1Core->cb = (uint32_t)cb;
260	}
261	/*
262	* Case 3 - Reallocation using a different allocator.
263	*/
264	else
265	{
266	/* Initialize the temporary allocation tracker. */
267	RTASN1ALLOCATION Allocation;
268	Allocation.cbAllocated = 0;
269	Allocation.cReallocs = pHdr->Allocation.cReallocs + 1;
270	Allocation.uReserved0 = 0;
271	Allocation.pAllocator = pAllocator;
272
273	/* Make the allocation. */
274	PRTASN1MEMCONTENT pHdrNew;
275	int rc = pAllocator->pfnAlloc(pAllocator, &Allocation, (void **)&pHdrNew, cbNeeded);
276	if (RT_FAILURE(rc))
277	return rc;
278	Assert(Allocation.cbAllocated >= cbNeeded);
279
280	/* Duplicate the old content and zero any new memory we might've added. */
281	if (pAsn1Core->cb >= cb)
282	memcpy(&pHdrNew->au64Content[0], &pHdr->au64Content[0], cb);
283	else
284	{
285	memcpy(&pHdrNew->au64Content[0], &pHdr->au64Content[0], pAsn1Core->cb);
286	RT_BZERO((uint8_t *)&pHdrNew->au64Content[0] + pAsn1Core->cb, cb - pAsn1Core->cb);
287	}
288
289	/* Update the core. */
290	pHdrNew->Allocation = Allocation;
291	pAsn1Core->uData.pv = &pHdrNew->au64Content[0];
292	pAsn1Core->fFlags \|= RTASN1CORE_F_ALLOCATED_CONTENT; /* free cleared it. */
293	pAsn1Core->cb = (uint32_t)cb;
294
295	/* Free the old content. */
296	Allocation = pHdr->Allocation;
297	Allocation.pAllocator->pfnFree(Allocation.pAllocator, &Allocation, pHdr);
298	Assert(Allocation.cbAllocated == 0);
299	}
300	}
301	/*
302	* Case 4 - It's a request to free the memory.
303	*/
304	else
305	RTAsn1ContentFree(pAsn1Core);
306	return VINF_SUCCESS;
307	}
308
309
310	RTDECL(void) RTAsn1ContentFree(PRTASN1CORE pAsn1Core)
311	{
312	if (pAsn1Core)
313	{
314	pAsn1Core->cb = 0;
315	if (pAsn1Core->fFlags & RTASN1CORE_F_ALLOCATED_CONTENT)
316	{
317	pAsn1Core->fFlags &= ~RTASN1CORE_F_ALLOCATED_CONTENT;
318	AssertReturnVoid(pAsn1Core->uData.pv);
319
320	PRTASN1MEMCONTENT pHdr = RT_FROM_MEMBER(pAsn1Core->uData.pv, RTASN1MEMCONTENT, au64Content);
321	RTASN1ALLOCATION Allocation = pHdr->Allocation;
322
323	Allocation.pAllocator->pfnFree(Allocation.pAllocator, &Allocation, pHdr);
324	Assert(Allocation.cbAllocated == 0);
325	}
326	pAsn1Core->uData.pv = NULL;
327	}
328	}
329
330
331
332	/*
333	* Virtual method table based API.
334	*/
335
336	RTDECL(void) RTAsn1VtDelete(PRTASN1CORE pAsn1Core)
337	{
338	if (pAsn1Core)
339	{
340	PCRTASN1COREVTABLE pOps = pAsn1Core->pOps;
341	if (pOps)
342	pOps->pfnDtor(pAsn1Core);
343	}
344	}
345
346
347	/**
348	* Context data passed by RTAsn1VtDeepEnum to it's worker callbacks.
349	*/
350	typedef struct RTASN1DEEPENUMCTX
351	{
352	PFNRTASN1ENUMCALLBACK pfnCallback;
353	void *pvUser;
354	} RTASN1DEEPENUMCTX;
355
356
357	static DECLCALLBACK(int) rtAsn1VtDeepEnumDepthFirst(PRTASN1CORE pAsn1Core, const char pszName, uint32_t uDepth, void pvUser)
358	{
359	AssertReturn(pAsn1Core, VINF_SUCCESS);
360
361	if (pAsn1Core->pOps && pAsn1Core->pOps->pfnEnum)
362	{
363	int rc = pAsn1Core->pOps->pfnEnum(pAsn1Core, rtAsn1VtDeepEnumDepthFirst, uDepth, pvUser);
364	if (rc != VINF_SUCCESS)
365	return rc;
366	}
367
368	RTASN1DEEPENUMCTX pCtx = (RTASN1DEEPENUMCTX )pvUser;
369	return pCtx->pfnCallback(pAsn1Core, pszName, uDepth, pCtx->pvUser);
370	}
371
372
373	static DECLCALLBACK(int) rtAsn1VtDeepEnumDepthLast(PRTASN1CORE pAsn1Core, const char pszName, uint32_t uDepth, void pvUser)
374	{
375	AssertReturn(pAsn1Core, VINF_SUCCESS);
376
377	RTASN1DEEPENUMCTX pCtx = (RTASN1DEEPENUMCTX )pvUser;
378	int rc = pCtx->pfnCallback(pAsn1Core, pszName, uDepth, pCtx->pvUser);
379	if (rc == VINF_SUCCESS)
380	{
381	if (pAsn1Core->pOps && pAsn1Core->pOps->pfnEnum)
382	rc = pAsn1Core->pOps->pfnEnum(pAsn1Core, rtAsn1VtDeepEnumDepthFirst, uDepth, pvUser);
383	}
384	return rc;
385	}
386
387
388	RTDECL(int) RTAsn1VtDeepEnum(PRTASN1CORE pThisCore, bool fDepthFirst, uint32_t uDepth,
389	PFNRTASN1ENUMCALLBACK pfnCallback, void *pvUser)
390	{
391	int rc;
392	if (RTAsn1Core_IsPresent(pThisCore))
393	{
394	PCRTASN1COREVTABLE pOps = pThisCore->pOps;
395	if (pOps && pOps->pfnEnum)
396	{
397	RTASN1DEEPENUMCTX Ctx;
398	Ctx.pfnCallback = pfnCallback;
399	Ctx.pvUser = pvUser;
400	rc = pOps->pfnEnum(pThisCore, fDepthFirst ? rtAsn1VtDeepEnumDepthFirst : rtAsn1VtDeepEnumDepthLast, uDepth, &Ctx);
401	}
402	else
403	rc = VINF_SUCCESS;
404	}
405	else
406	rc = VINF_SUCCESS;
407	return rc;
408	}
409
410
411	RTDECL(int) RTAsn1VtClone(PRTASN1CORE pThisCore, PRTASN1CORE pSrcCore, PCRTASN1ALLOCATORVTABLE pAllocator)
412	{
413	AssertPtrReturn(pThisCore, VERR_INVALID_POINTER);
414	AssertPtrReturn(pSrcCore, VERR_INVALID_POINTER);
415	AssertPtrReturn(pAllocator, VERR_INVALID_POINTER);
416
417	if (RTAsn1Core_IsPresent(pSrcCore))
418	{
419	AssertPtrReturn(pSrcCore->pOps, VERR_INVALID_POINTER);
420	AssertPtr(pSrcCore->pOps->pfnClone);
421	return pSrcCore->pOps->pfnClone(pThisCore, pSrcCore, pAllocator);
422	}
423
424	RT_ZERO(*pThisCore);
425	return VINF_SUCCESS;
426	}
427
428
429	RTDECL(int) RTAsn1VtCompare(PCRTASN1CORE pLeftCore, PCRTASN1CORE pRightCore)
430	{
431	int iDiff;
432	if (RTAsn1Core_IsPresent(pLeftCore))
433	{
434	if (RTAsn1Core_IsPresent(pRightCore))
435	{
436	PCRTASN1COREVTABLE pOps = pLeftCore->pOps;
437	if (pOps == pRightCore->pOps)
438	{
439	AssertPtr(pOps->pfnCompare);
440	iDiff = pOps->pfnCompare(pLeftCore, pRightCore);
441	}
442	else
443	iDiff = (uintptr_t)pOps < (uintptr_t)pRightCore->pOps ? -1 : 1;
444	}
445	else
446	iDiff = 1;
447	}
448	else
449	iDiff = 0 - (int)RTAsn1Core_IsPresent(pRightCore);
450	return iDiff;
451	}
452
453
454	RTDECL(int) RTAsn1VtCheckSanity(PCRTASN1CORE pThisCore, uint32_t fFlags,
455	PRTERRINFO pErrInfo, const char *pszErrorTag)
456	{
457	int rc;
458	if (RTAsn1Core_IsPresent(pThisCore))
459	{
460	PCRTASN1COREVTABLE pOps = pThisCore->pOps;
461	if (pOps && pOps->pfnCheckSanity)
462	rc = pOps->pfnCheckSanity(pThisCore, fFlags, pErrInfo, pszErrorTag);
463	else if (pOps)
464	rc = RTErrInfoSetF(pErrInfo, VERR_ASN1_NO_CHECK_SANITY_METHOD,
465	"%s: Has no pfnCheckSanity function.", pszErrorTag);
466	else
467	rc = RTErrInfoSetF(pErrInfo, VERR_ASN1_NO_VTABLE, "%s: Has no Vtable function.", pszErrorTag);
468	}
469	else
470	rc = RTErrInfoSetF(pErrInfo, VERR_ASN1_NOT_PRESENT, "%s: Not present.", pszErrorTag);
471	return rc;
472	}
473
474
475
476	/*
477	* Dummy ASN.1 object.
478	*/
479
480	RTDECL(int) RTAsn1Dummy_InitEx(PRTASN1DUMMY pThis)
481	{
482	return RTAsn1Core_InitEx(&pThis->Asn1Core,
483	UINT32_MAX,
484	ASN1_TAGCLASS_PRIVATE \| ASN1_TAGFLAG_CONSTRUCTED,
485	NULL,
486	RTASN1CORE_F_DUMMY);
487	}
488
489
490	/*
491	* ASN.1 SEQUENCE OF object.
492	*/
493
494	RTDECL(int) RTAsn1SeqOfCore_Init(PRTASN1SEQOFCORE pThis, PCRTASN1COREVTABLE pVtable)
495	{
496	return RTAsn1Core_InitEx(&pThis->Asn1Core,
497	ASN1_TAG_SEQUENCE,
498	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_CONSTRUCTED,
499	pVtable,
500	RTASN1CORE_F_PRESENT);
501	}
502
503
504	RTDECL(int) RTAsn1SeqOfCore_Clone(PRTASN1SEQOFCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SEQOFCORE pSrc)
505	{
506	AssertReturn(pSrc->Asn1Core.pOps == pVtable, VERR_ASN1_INTERNAL_ERROR_5);
507	return RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
508	}
509
510
511	/*
512	* ASN.1 SET OF object.
513	*/
514
515	RTDECL(int) RTAsn1SetOfCore_Init(PRTASN1SETOFCORE pThis, PCRTASN1COREVTABLE pVtable)
516	{
517	return RTAsn1Core_InitEx(&pThis->Asn1Core,
518	ASN1_TAG_SET,
519	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_CONSTRUCTED,
520	pVtable,
521	RTASN1CORE_F_PRESENT);
522	}
523
524
525	RTDECL(int) RTAsn1SetOfCore_Clone(PRTASN1SETOFCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SETOFCORE pSrc)
526	{
527	AssertReturn(pSrc->Asn1Core.pOps == pVtable, VERR_ASN1_INTERNAL_ERROR_5);
528	return RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
529	}
530
531
532	/*
533	* ASN.1 SEQUENCE object.
534	*/
535
536	RTDECL(int) RTAsn1SequenceCore_Init(PRTASN1SEQUENCECORE pThis, PCRTASN1COREVTABLE pVtable)
537	{
538	return RTAsn1Core_InitEx(&pThis->Asn1Core,
539	ASN1_TAG_SEQUENCE,
540	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_CONSTRUCTED,
541	pVtable,
542	RTASN1CORE_F_PRESENT);
543	}
544
545
546	RTDECL(int) RTAsn1SequenceCore_Clone(PRTASN1SEQUENCECORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SEQUENCECORE pSrc)
547	{
548	AssertReturn(pSrc->Asn1Core.pOps == pVtable, VERR_ASN1_INTERNAL_ERROR_5);
549	return RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
550	}
551
552
553	/*
554	* ASN.1 SEQUENCE object - only used by SPC, so probably doing something wrong there.
555	*/
556
557	RTDECL(int) RTAsn1SetCore_Init(PRTASN1SETCORE pThis, PCRTASN1COREVTABLE pVtable)
558	{
559	return RTAsn1Core_InitEx(&pThis->Asn1Core,
560	ASN1_TAG_SET,
561	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_CONSTRUCTED,
562	pVtable,
563	RTASN1CORE_F_PRESENT);
564	}
565
566
567	RTDECL(int) RTAsn1SetCore_Clone(PRTASN1SETCORE pThis, PCRTASN1COREVTABLE pVtable, PCRTASN1SETCORE pSrc)
568	{
569	AssertReturn(pSrc->Asn1Core.pOps == pVtable, VERR_ASN1_INTERNAL_ERROR_5);
570	return RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
571	}
572
573
574	/*
575	* ASN.1 Context Tag object.
576	*/
577
578	RTDECL(int) RTAsn1ContextTagN_Init(PRTASN1CONTEXTTAG pThis, uint32_t uTag)
579	{
580	return RTAsn1Core_InitEx(&pThis->Asn1Core,
581	uTag,
582	ASN1_TAGCLASS_CONTEXT \| ASN1_TAGFLAG_CONSTRUCTED,
583	NULL,
584	RTASN1CORE_F_PRESENT);
585	}
586
587
588	RTDECL(int) RTAsn1ContextTagN_Clone(PRTASN1CONTEXTTAG pThis, PCRTASN1CONTEXTTAG pSrc, uint32_t uTag)
589	{
590	Assert(pSrc->Asn1Core.uTag == uTag \|\| !RTASN1CORE_IS_PRESENT(&pSrc->Asn1Core));
591	return RTAsn1Core_CloneNoContent(&pThis->Asn1Core, &pSrc->Asn1Core);
592	}
593

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/asn1/asn1-basics.cpp@ 57444

Download in other formats: