asn1-ut-string.cpp

Last change on this file was 106061, checked in by vboxsync, 6 weeks ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 69.1 KB

Line
1	/* $Id: asn1-ut-string.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2	/** @file
3	* IPRT - ASN.1, XXX STRING Types.
4	*/
5
6	/*
7	* Copyright (C) 2006-2024 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include "internal/iprt.h"
42	#include <iprt/asn1.h>
43
44	#include <iprt/ctype.h>
45	#include <iprt/err.h>
46	#include <iprt/string.h>
47	#include <iprt/uni.h>
48
49	#include <iprt/formats/asn1.h>
50
51
52	/*********************************************************************************************************************************
53	* Global Variables *
54	*********************************************************************************************************************************/
55	static uint8_t const g_acbStringTags[] =
56	{
57	/* [ASN1_TAG_EOC] = */ 0,
58	/* [ASN1_TAG_BOOLEAN] = */ 0,
59	/* [ASN1_TAG_INTEGER] = */ 0,
60	/* [ASN1_TAG_BIT_STRING] = */ 0,
61	/* [ASN1_TAG_OCTET_STRING] = */ 0,
62	/* [ASN1_TAG_NULL] = */ 0,
63	/* [ASN1_TAG_OID] = */ 0,
64	/* [ASN1_TAG_OBJECT_DESCRIPTOR] = */ 0,
65	/* [ASN1_TAG_EXTERNAL] = */ 0,
66	/* [ASN1_TAG_REAL] = */ 0,
67	/* [ASN1_TAG_ENUMERATED] = */ 0,
68	/* [ASN1_TAG_EMBEDDED_PDV] = */ 0,
69	/* [ASN1_TAG_UTF8_STRING] = */ 1,
70	/* [ASN1_TAG_RELATIVE_OID] = */ 0,
71	/* [ASN1_TAG_RESERVED_14] = */ 0,
72	/* [ASN1_TAG_RESERVED_15] = */ 0,
73	/* [ASN1_TAG_SEQUENCE] = */ 0,
74	/* [ASN1_TAG_SET] = */ 0,
75	/* [ASN1_TAG_NUMERIC_STRING] = */ 1,
76	/* [ASN1_TAG_PRINTABLE_STRING] = */ 1,
77	/* [ASN1_TAG_T61_STRING] = */ 1,
78	/* [ASN1_TAG_VIDEOTEX_STRING] = */ 1,
79	/* [ASN1_TAG_IA5_STRING] = */ 1,
80	/* [ASN1_TAG_UTC_TIME] = */ 0,
81	/* [ASN1_TAG_GENERALIZED_TIME] = */ 0,
82	/* [ASN1_TAG_GRAPHIC_STRING] = */ 1,
83	/* [ASN1_TAG_VISIBLE_STRING] = */ 1,
84	/* [ASN1_TAG_GENERAL_STRING] = */ 1,
85	/* [ASN1_TAG_UNIVERSAL_STRING] = */ 4,
86	/* [ASN1_TAG_CHARACTER_STRING] = */ 1,
87	/* [ASN1_TAG_BMP_STRING] = */ 2,
88	};
89
90
91
92
93	/*
94	* ISO/IEC-2022 + TeletexString mess.
95	*/
96
97	/**
98	* ISO-2022 codepoint mappings.
99	*/
100	typedef struct RTISO2022MAP
101	{
102	/** The number of bytes per character. */
103	uint8_t cb;
104	/** The registration number. */
105	uint16_t uRegistration;
106	/** The size of the pauToUni table. */
107	uint16_t cToUni;
108	/** Pointer to the convertion table from ISO-2022 to Unicode.
109	* ASSUMES that unicode chars above 0xffff won't be required. */
110	uint16_t const *pauToUni;
111
112	/** Escape sequence for loading into G0 or C0 or C1 depending on the type (sans
113	* ESC). */
114	uint8_t abEscLoadXX[6];
115	/** Escape sequence for loading into G1 (sans ESC). */
116	uint8_t abEscLoadG1[6];
117	/** Escape sequence for loading into G2 (sans ESC). */
118	uint8_t abEscLoadG2[6];
119	/** Escape sequence for loading into G3 (sans ESC). */
120	uint8_t abEscLoadG3[6];
121	} RTISO2022MAP;
122	/** Pointer to const ISO-2022 mappings. */
123	typedef RTISO2022MAP const *PCRTISO2022MAP;
124
125	/** Unused codepoint value. */
126	#define RTISO2022_UNUSED UINT16_C(0xffff)
127
128
129	/** Dummy mappings to avoid dealing with NULL pointers in the decoder
130	* registers. */
131	static const RTISO2022MAP g_DummyMap =
132	{
133	1, UINT16_MAX, 0, NULL,
134	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* No escape into G0 */,
135	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* No escape into G1 */,
136	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* No escape into G2 */,
137	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* No escape into G3 */
138	};
139
140
141	/** GL mappings for ISO-IR-168 (Japanese, update of #87), with space and
142	* delete. */
143	static const RTISO2022MAP g_IsoIr168Map =
144	{
145	//2, 168, RT_ELEMENTS(g_awcIsoIr168Decode), g_awcIsoIr168Decode,
146	2, 168, 0, NULL,
147	{ 0x26, 0x40, 0x2b, 0x24, 0x42, 0xff } /* Esc into G0 */,
148	{ 0x26, 0x40, 0x2b, 0x24, 0x29, 0x42 } /* Esc into G1 */,
149	{ 0x26, 0x40, 0x2b, 0x24, 0x2a, 0x42 } /* Esc into G2 */,
150	{ 0x26, 0x40, 0x2b, 0x24, 0x2b, 0x42 } /* Esc into G3 */,
151	};
152
153
154	/** GL mappings for ISO-IR-165 (Chinese), with space and delete. */
155	static const RTISO2022MAP g_IsoIr165Map =
156	{
157	//2, 165, RT_ELEMENTS(g_awcIsoIr165Decode), g_awcIsoIr165Decode,
158	2, 165, 0, NULL,
159	{ 0x24, 0x28, 0x45, 0xff, 0xff, 0xff } /* Esc into G0 */,
160	{ 0x24, 0x29, 0x45, 0xff, 0xff, 0xff } /* Esc into G1 */,
161	{ 0x24, 0x2a, 0x45, 0xff, 0xff, 0xff } /* Esc into G2 */,
162	{ 0x24, 0x2b, 0x45, 0xff, 0xff, 0xff } /* Esc into G3 */,
163	};
164
165
166	/** GL mappings for ISO-IR-150 (Greek), with space and delete. */
167	static const RTISO2022MAP g_IsoIr150Map =
168	{
169	//1, 150, RT_ELEMENTS(g_awcIsoIr150Decode), g_awcIsoIr150Decode,
170	1, 150, 0, NULL,
171	{ 0x28, 0x21, 0x40, 0xff, 0xff, 0xff } /* Esc into G0 */,
172	{ 0x29, 0x21, 0x40, 0xff, 0xff, 0xff } /* Esc into G1 */,
173	{ 0x2a, 0x21, 0x40, 0xff, 0xff, 0xff } /* Esc into G2 */,
174	{ 0x2b, 0x21, 0x40, 0xff, 0xff, 0xff } /* Esc into G3 */,
175	};
176
177
178	/** GL mappings for ISO-IR-103 (Teletex supplementary), with space and
179	* delete. */
180	static const RTISO2022MAP g_IsoIr103Map =
181	{
182	//1, 103, RT_ELEMENTS(g_awcIsoIr103Decode), g_awcIsoIr103Decode,
183	1, 103, 0, NULL,
184	{ 0x28, 0x76, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
185	{ 0x29, 0x76, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
186	{ 0x2a, 0x76, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
187	{ 0x2b, 0x76, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
188	};
189
190
191	/**
192	* GL mapping from ISO-IR-102 (Teletex primary) to unicode, with space and
193	* delete.
194	*
195	* Mostly 1:1, except that (a) what would be dollar is currency sign, (b)
196	* positions 0x5c, 0x5e, 0x7b, 0x7d and 0x7e are defined not to be used.
197	*/
198	static uint16_t const g_awcIsoIr102Decode[0x60] =
199	{
200	0x0020, 0x0021, 0x0022, 0x0023, 0x00A4, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
201	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
202	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
203	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0xffff, 0x005d, 0xffff, 0x005f,
204	0xffff, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
205	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0xffff, 0x007c, 0xffff, 0xffff, 0x007f,
206	};
207
208	/** GL mappings for ISO-IR-102, with space and delete. */
209	static const RTISO2022MAP g_IsoIr102Map =
210	{
211	1, 102, RT_ELEMENTS(g_awcIsoIr102Decode), g_awcIsoIr102Decode,
212	{ 0x28, 0x75, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
213	{ 0x29, 0x75, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
214	{ 0x2a, 0x75, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
215	{ 0x2b, 0x75, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
216	};
217
218
219	#if 0 /* unused */
220	/** GL mappings for ISO-IR-87 (Japanese), with space and delete. */
221	static const RTISO2022MAP g_IsoIr87Map =
222	{
223	//1, 87, RT_ELEMENTS(g_awcIsoIr87Decode), g_awcIsoIr97Decode,
224	1, 87, 0, NULL,
225	{ 0x24, 0x42, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
226	{ 0x24, 0x29, 0x42, 0xff, 0xff, 0xff } /* Esc into G1 */,
227	{ 0x24, 0x2a, 0x42, 0xff, 0xff, 0xff } /* Esc into G2 */,
228	{ 0x24, 0x2b, 0x42, 0xff, 0xff, 0xff } /* Esc into G3 */,
229	};
230	#endif
231
232
233	/**
234	* GL mapping from ISO-IR-6 (ASCII) to unicode, with space and delete.
235	*
236	* Completely 1:1.
237	*/
238	static uint16_t const g_awcIsoIr6Decode[0x60] =
239	{
240	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
241	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
242	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
243	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
244	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
245	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x006b, 0x007c, 0x007d, 0x007e, 0x007f,
246	};
247
248	/** GL mappings for ISO-IR-6 (ASCII), with space and delete. */
249	static const RTISO2022MAP g_IsoIr6Map =
250	{
251	1, 6, RT_ELEMENTS(g_awcIsoIr6Decode), g_awcIsoIr6Decode,
252	{ 0x28, 0x42, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
253	{ 0x29, 0x42, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
254	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
255	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
256	};
257
258
259	/** GL maps. */
260	static PCRTISO2022MAP g_paGLMaps[] =
261	{
262	&g_IsoIr6Map,
263	&g_IsoIr102Map,
264	&g_IsoIr103Map,
265	&g_IsoIr150Map,
266	&g_IsoIr165Map,
267	&g_IsoIr168Map,
268	};
269
270
271
272	/** GR mappings for ISO-IR-164 (Hebrew supplementary). */
273	static const RTISO2022MAP g_IsoIr164Map =
274	{
275	//1, 164, RT_ELEMENTS(g_awcIsoIr164Decode), g_awcIsoIr164Decode
276	1, 164, 0, NULL,
277	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
278	{ 0x2d, 0x53, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
279	{ 0x2e, 0x53, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
280	{ 0x2f, 0x53, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
281	};
282
283
284	/** GR mappings for ISO-IR-156 (Supplementary for ASCII (#6)). */
285	static const RTISO2022MAP g_IsoIr156Map =
286	{
287	//1, 156, RT_ELEMENTS(g_awcIsoIr156Decode), g_awcIsoIr156Decode
288	1, 156, 0, NULL,
289	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
290	{ 0x2d, 0x52, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
291	{ 0x2e, 0x52, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
292	{ 0x2f, 0x52, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
293	};
294
295
296	/** GR mappings for ISO-IR-153 (Basic Cyrillic). */
297	static const RTISO2022MAP g_IsoIr153Map =
298	{
299	//1, 153, RT_ELEMENTS(g_awcIsoIr153Decode), g_awcIsoIr153Decode
300	1, 153, 0, NULL,
301	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
302	{ 0x2d, 0x4f, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
303	{ 0x2e, 0x4f, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
304	{ 0x2f, 0x4f, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
305	};
306
307
308	/** GR mappings for ISO-IR-144 (Cryllic part of Latin/Cyrillic). */
309	static const RTISO2022MAP g_IsoIr144Map =
310	{
311	//1, 144, RT_ELEMENTS(g_awcIsoIr144Decode), g_awcIsoIr144Decode
312	1, 144, 0, NULL,
313	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
314	{ 0x2d, 0x4f, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
315	{ 0x2e, 0x4f, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
316	{ 0x2f, 0x4f, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
317	};
318
319
320	/** GR mappings for ISO-IR-126 (Latin/Greek). */
321	static const RTISO2022MAP g_IsoIr126Map =
322	{
323	//1, 126, RT_ELEMENTS(g_awcIsoIr126Decode), g_awcIsoIr126Decode
324	1, 126, 0, NULL,
325	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* Esc into G0 */,
326	{ 0x2d, 0x46, 0xff, 0xff, 0xff, 0xff } /* Esc into G1 */,
327	{ 0x2e, 0x46, 0xff, 0xff, 0xff, 0xff } /* Esc into G2 */,
328	{ 0x2f, 0x46, 0xff, 0xff, 0xff, 0xff } /* Esc into G3 */,
329	};
330
331
332	/** GR maps. */
333	static PCRTISO2022MAP g_paGRMaps[] =
334	{
335	&g_IsoIr126Map,
336	&g_IsoIr144Map,
337	&g_IsoIr153Map,
338	&g_IsoIr156Map,
339	&g_IsoIr164Map,
340	};
341
342
343
344	/** C0 mapping from ISO-IR-106 to unicode. */
345	static uint16_t g_awcIsoIr106Decode[0x20] =
346	{
347	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x0008, 0xffff, 0x000a, 0xffff, 0x000c, 0x000d, 0x000e, 0x000f,
348	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x008e, 0x000a, 0x001b, 0xffff, 0x008f, 0xffff, 0xffff,
349	};
350
351	/** C0 mappings for ISO-IR-106. */
352	static const RTISO2022MAP g_IsoIr106Map =
353	{
354	1, 106, RT_ELEMENTS(g_awcIsoIr106Decode), g_awcIsoIr106Decode,
355	{ 0x21, 0x45, 0xff, 0xff, 0xff, 0xff } /* Esc into C0 */,
356	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* N/A */,
357	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* N/A */,
358	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* N/A */,
359	};
360
361	/** C0 maps. */
362	static PCRTISO2022MAP g_paC0Maps[] =
363	{
364	&g_IsoIr106Map,
365	};
366
367
368
369	/** C1 mapping from ISO-IR-107 to unicode. */
370	static uint16_t g_awcIsoIr107Decode[0x20] =
371	{
372	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x008b, 0x008c, 0xffff, 0xffff, 0xffff,
373	0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0x009b, 0xffff, 0xffff, 0xffff, 0xffff,
374	};
375
376	/** C1 mappings for ISO-IR-107. */
377	static const RTISO2022MAP g_IsoIr107Map =
378	{
379	1, 107, RT_ELEMENTS(g_awcIsoIr107Decode), g_awcIsoIr107Decode,
380	{ 0x22, 0x48, 0xff, 0xff, 0xff, 0xff } /* Esc into C1 */,
381	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* N/A */,
382	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* N/A */,
383	{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } /* N/A */,
384	};
385
386	/** C1 maps. */
387	static PCRTISO2022MAP g_paC1Maps[] =
388	{
389	&g_IsoIr107Map,
390	};
391
392
393	static int rtIso2022Decoder_LookupAndSet(PCRTISO2022MAP ppMapRet, uint16_t uRegistration, PCRTISO2022MAP papMaps, uint32_t cMaps)
394	{
395	uint32_t i = cMaps;
396	while (i-- > 0)
397	if (papMaps[i]->uRegistration == uRegistration)
398	{
399	/** @todo skip non-Teletex codesets if we ever add more than we need for it. */
400	*ppMapRet = papMaps[i];
401	return VINF_SUCCESS;
402	}
403	return VERR_ASN1_INVALID_T61_STRING_ENCODING;
404	}
405
406
407	/**
408	* ISO-2022 decoder state.
409	*/
410	typedef struct RTISO2022DECODERSTATE
411	{
412	/** Pointer to the string */
413	uint8_t const *pabString;
414	/** The string size. */
415	uint32_t cbString;
416	/** The current string position. */
417	uint32_t offString;
418
419	/** The GL mapping. */
420	PCRTISO2022MAP pMapGL;
421	/** The GR mapping. */
422	PCRTISO2022MAP pMapGR;
423	/** The lower control set (C0) mapping. */
424	PCRTISO2022MAP pMapC0;
425	/** The higher control set (C1) mapping. */
426	PCRTISO2022MAP pMapC1;
427	/** The G0, G1, G2, and G3 mappings. */
428	PCRTISO2022MAP apMapGn[4];
429	/** Used by SS2 & SS3 to store the orignal GL value that is to be restored. */
430	PCRTISO2022MAP pRestoreGL;
431	/** Pointer to extended error info buffer, optional. */
432	PRTERRINFO pErrInfo;
433	} RTISO2022DECODERSTATE;
434	/** Pointer to a const ISO-2022 decoder state. */
435	typedef RTISO2022DECODERSTATE *PRTISO2022DECODERSTATE;
436
437
438	static int rtIso2022Decoder_SetGL(PRTISO2022DECODERSTATE pThis, PCRTISO2022MAP pNewMap)
439	{
440	pThis->pMapGL = pNewMap;
441	return VINF_SUCCESS;
442	}
443
444
445	static int rtIso2022Decoder_SetGR(PRTISO2022DECODERSTATE pThis, PCRTISO2022MAP pNewMap)
446	{
447	pThis->pMapGR = pNewMap;
448	return VINF_SUCCESS;
449	}
450
451
452	static int rtIso2022Decoder_SetGLForOneChar(PRTISO2022DECODERSTATE pThis, PCRTISO2022MAP pTmpMap)
453	{
454	pThis->pRestoreGL = pThis->pMapGL;
455	pThis->pMapGL = pTmpMap;
456	return VINF_SUCCESS;
457	}
458
459
460	static int rtIso2022Decoder_SetC0(PRTISO2022DECODERSTATE pThis, uint16_t uRegistration)
461	{
462	return rtIso2022Decoder_LookupAndSet(&pThis->pMapC0, uRegistration, g_paC0Maps, RT_ELEMENTS(g_paC0Maps));
463	}
464
465
466	static int rtIso2022Decoder_SetC1(PRTISO2022DECODERSTATE pThis, uint16_t uRegistration)
467	{
468	return rtIso2022Decoder_LookupAndSet(&pThis->pMapC1, uRegistration, g_paC1Maps, RT_ELEMENTS(g_paC1Maps));
469	}
470
471
472	/**
473	* Worker for rtIso2022Decoder_FindEscAndSet.
474	*
475	* @returns true if match, false if not.
476	* @param pabLeft Pointer to the first string byte after the ESC.
477	* @param cbLeft The number of bytes left in the string.
478	* @param pabRight Pointer to the abEscLoad* byte array to match with.
479	* @param cbRight Size of the mapping sequence (fixed).
480	* @param pcchMatch Where to return the length of the escape sequence (sans
481	* ESC) on success.
482	*/
483	static bool rtIso2022Decoder_MatchEscSeqFrom2ndByte(uint8_t const *pabLeft, uint32_t cbLeft,
484	uint8_t const *pabRight, uint32_t cbRight,
485	uint32_t *pcchMatch)
486	{
487	Assert(cbRight == 6);
488	uint32_t i = 1;
489	while (i < cbRight)
490	{
491	if (pabRight[i] == 0xff)
492	break;
493	if (cbLeft <= i \|\| pabLeft[i] != pabRight[i])
494	return false;
495	i++;
496	}
497	*pcchMatch = i;
498	return true;
499	}
500
501
502	/**
503	* Finds a the set with a matching abEscLoad* escape sequence and loads it into
504	* the designated register.
505	*
506	* @returns The length of the sequence on success, negative error status code on
507	* failure.
508	* @param pThis The decoder instance.
509	* @param ppMapRet Used to specify C0 or C1 maps when processing
510	* escape sequences for loading these. Only the
511	* abEscLoadXX arrays will be searched if this is
512	* not NULL. For loading {G0,...,G3} pass NULL.
513	* @param pb Pointer to the start of the escape sequence.
514	* @param cb The number of bytes remaining in the string.
515	* @param papMaps The maps to search.
516	* @param cMaps The number of maps @a papMaps points to.
517	*/
518	static int rtIso2022Decoder_FindEscAndSet(PRTISO2022DECODERSTATE pThis,
519	PCRTISO2022MAP ppMapRet, PCRTISO2022MAP papMaps, uint32_t cMaps)
520	{
521	/* Skip the ESC.*/
522	uint8_t const *pb = &pThis->pabString[pThis->offString + 1];
523	uint32_t cb = pThis->cbString - (pThis->offString + 1);
524
525	/* Cache the first char. */
526	uint8_t const b0 = pb[0];
527
528	/* Scan the array of maps for matching sequences. */
529	uint32_t i = cMaps;
530	while (i-- > 0)
531	{
532	uint32_t cchMatch = 0; /* (MSC maybe used uninitialized) */
533	PCRTISO2022MAP pMap = papMaps[i];
534	/** @todo skip non-Teletex codesets if we ever add more than we need for it. */
535	if ( pMap->abEscLoadXX[0] == b0
536	&& rtIso2022Decoder_MatchEscSeqFrom2ndByte(pb, cb, pMap->abEscLoadXX, sizeof(pMap->abEscLoadXX), &cchMatch) )
537	{
538	if (ppMapRet)
539	*ppMapRet = pMap;
540	else
541	pThis->apMapGn[0] = pMap;
542	return cchMatch + 1;
543	}
544
545	if (!ppMapRet) /* ppMapRet is NULL if Gn. */
546	{
547	uint32_t iGn;
548	if ( pMap->abEscLoadG1[0] == b0
549	&& rtIso2022Decoder_MatchEscSeqFrom2ndByte(pb, cb, pMap->abEscLoadG1, sizeof(pMap->abEscLoadG1), &cchMatch))
550	iGn = 1;
551	else if ( pMap->abEscLoadG2[0] == b0
552	&& rtIso2022Decoder_MatchEscSeqFrom2ndByte(pb, cb, pMap->abEscLoadG2, sizeof(pMap->abEscLoadG2), &cchMatch))
553	iGn = 2;
554	else if ( pMap->abEscLoadG3[0] == b0
555	&& rtIso2022Decoder_MatchEscSeqFrom2ndByte(pb, cb, pMap->abEscLoadG3, sizeof(pMap->abEscLoadG3), &cchMatch))
556	iGn = 3;
557	else
558	iGn = UINT32_MAX;
559	if (iGn != UINT32_MAX)
560	{
561	pThis->apMapGn[iGn] = pMap;
562	return cchMatch + 1;
563	}
564	}
565	}
566	return VERR_ASN1_TELETEX_UNSUPPORTED_CHARSET;
567	}
568
569
570	/**
571	* Interprets an escape sequence.
572	*
573	* @returns The length of the sequence on success, negative error status code on
574	* failure.
575	* @param pThis The decoder instance. The offString must be
576	* pointing to the escape byte.
577	*/
578	static int rtIso2022Decoder_InterpretEsc(PRTISO2022DECODERSTATE pThis)
579	{
580	/* the first escape byte. */
581	uint32_t offString = pThis->offString;
582	if (offString + 1 >= pThis->cbString)
583	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
584	"@%u: Unexpected EOS parsing ESC...", offString);
585	int rc;
586	switch (pThis->pabString[offString + 1])
587	{
588	/*
589	* GL selection:
590	*/
591	case 0x6e: /* Lock shift two: G2 -> GL */
592	rc = rtIso2022Decoder_SetGL(pThis, pThis->apMapGn[2]);
593	break;
594	case 0x6f: /* Lock shift three: G3 -> GL */
595	rc = rtIso2022Decoder_SetGL(pThis, pThis->apMapGn[3]);
596	break;
597	case 0x4e: /* Single shift two: G2 -> GL for one char. */
598	rc = rtIso2022Decoder_SetGLForOneChar(pThis, pThis->apMapGn[2]);
599	break;
600	case 0x4f: /* Single shift three: G3 -> GL for one char. */
601	rc = rtIso2022Decoder_SetGLForOneChar(pThis, pThis->apMapGn[3]);
602	break;
603
604	/*
605	* GR selection:
606	*/
607	case 0x7e: /* Locking shift one right: G1 -> GR. */
608	rc = rtIso2022Decoder_SetGR(pThis, pThis->apMapGn[1]);
609	break;
610	case 0x7d: /* Locking shift two right: G2 -> GR. */
611	rc = rtIso2022Decoder_SetGR(pThis, pThis->apMapGn[2]);
612	break;
613	case 0x7c: /* Locking shift three right: G3 -> GR. */
614	rc = rtIso2022Decoder_SetGR(pThis, pThis->apMapGn[3]);
615	break;
616
617	/*
618	* Cx selection:
619	*/
620	case 0x21: /* C0-designate */
621	return rtIso2022Decoder_FindEscAndSet(pThis, &pThis->pMapC0, g_paC0Maps, RT_ELEMENTS(g_paC0Maps));
622	case 0x22: /* C1-designate */
623	return rtIso2022Decoder_FindEscAndSet(pThis, &pThis->pMapC1, g_paC1Maps, RT_ELEMENTS(g_paC1Maps));
624
625	/*
626	* Single-byte character set selection.
627	*/
628	case 0x28: /* G0-designate, 94 chars. */
629	case 0x29: /* G1-designate, 94 chars. */
630	case 0x2a: /* G2-designate, 94 chars. */
631	case 0x2b: /* G3-designate, 94 chars. */
632	return rtIso2022Decoder_FindEscAndSet(pThis, NULL, g_paGLMaps, RT_ELEMENTS(g_paGLMaps));
633
634	case 0x2c: /* G0-designate, 96 chars. */
635	case 0x2d: /* G1-designate, 96 chars. */
636	case 0x2e: /* G2-designate, 96 chars. */
637	case 0x2f: /* G3-designate, 96 chars. */
638	return rtIso2022Decoder_FindEscAndSet(pThis, NULL, g_paGRMaps, RT_ELEMENTS(g_paGRMaps));
639
640	/*
641	* Multibyte character set selection.
642	*/
643	case 0x24:
644	if (offString + 2 >= pThis->cbString)
645	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
646	"@%u: Unexpected EOS parsing ESC %#x...", offString, pThis->pabString[offString + 1]);
647	switch (pThis->pabString[offString + 2])
648	{
649	case 0x28: /* G0-designate, 94^n chars. */
650	case 0x29: /* G1-designate, 94^n chars. */
651	case 0x2a: /* G2-designate, 94^n chars. */
652	case 0x2b: /* G3-designate, 94^n chars. */
653	default: /* G0-designate that skips the 0x28? (See japanese ones.) */
654	return rtIso2022Decoder_FindEscAndSet(pThis, NULL, g_paGLMaps, RT_ELEMENTS(g_paGLMaps));
655
656	case 0x2c: /* G0-designate, 96^n chars. */
657	case 0x2d: /* G1-designate, 96^n chars. */
658	case 0x2e: /* G2-designate, 96^n chars. */
659	case 0x2f: /* G3-designate, 96^n chars. */
660	return rtIso2022Decoder_FindEscAndSet(pThis, NULL, g_paGRMaps, RT_ELEMENTS(g_paGRMaps));
661	} \
662	break;
663
664	case 0x26: /* Special escape prefix for #168. */
665	return rtIso2022Decoder_FindEscAndSet(pThis, NULL, g_paGLMaps, RT_ELEMENTS(g_paGLMaps));
666
667	/*
668	* Unknown/unsupported/unimplemented.
669	*/
670	case 0x25: /* Designate other coding system. */
671	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_TELETEX_UNSUPPORTED_ESC_SEQ,
672	"@%u: ESC DOCS not supported\n", offString);
673	default:
674	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_TELETEX_UNKNOWN_ESC_SEQ,
675	"@%u: Unknown escape sequence: ESC %#x...\n", offString, pThis->pabString[offString + 1]);
676	}
677
678	/* Only single byte escapes sequences for shifting ends up here. */
679	if (RT_SUCCESS(rc))
680	return 1;
681	return rc;
682	}
683
684
685	static int rtIso2022Decoder_ControlCharHook(PRTISO2022DECODERSTATE pThis, uint16_t wcControl)
686	{
687	int rc;
688	switch (wcControl)
689	{
690	case 0x000e: /* Locking shift zero: G0 -> GL. */
691	rc = rtIso2022Decoder_SetGL(pThis, pThis->apMapGn[0]);
692	break;
693
694	case 0x000f: /* Locking shift one: G1 -> GL. */
695	rc = rtIso2022Decoder_SetGL(pThis, pThis->apMapGn[1]);
696	break;
697
698	case 0x008e: /* Single shift two: G2 -> GL for one char. */
699	rc = rtIso2022Decoder_SetGLForOneChar(pThis, pThis->apMapGn[2]);
700	break;
701
702	case 0x008f: /* Single shift three: G3 -> GL for one char. */
703	rc = rtIso2022Decoder_SetGLForOneChar(pThis, pThis->apMapGn[3]);
704	break;
705
706	case 0x002b: /* Escape should be handled by the caller. */
707	rc = rtIso2022Decoder_InterpretEsc(pThis);
708	break;
709
710	default:
711	return 0;
712	}
713
714	return RT_SUCCESS(rc) ? 1 : rc;
715	}
716
717
718	static int rtIso2022Decoder_Init(PRTISO2022DECODERSTATE pThis, const char *pchString, uint32_t cchString,
719	uint32_t uGL, uint32_t uC0, uint32_t uC1, uint32_t uG0,
720	PRTERRINFO pErrInfo)
721	{
722	pThis->pabString = (uint8_t const *)pchString;
723	pThis->cbString = cchString;
724	pThis->offString = 0;
725
726	pThis->pMapGL = &g_DummyMap;
727	pThis->pMapGR = &g_DummyMap;
728	pThis->pMapC0 = &g_DummyMap;
729	pThis->pMapC1 = &g_DummyMap;
730	pThis->pRestoreGL = NULL;
731	pThis->apMapGn[0] = &g_DummyMap;
732	pThis->apMapGn[1] = &g_DummyMap;
733	pThis->apMapGn[2] = &g_DummyMap;
734	pThis->apMapGn[3] = &g_DummyMap;
735	pThis->pErrInfo = pErrInfo;
736
737	int rc = VINF_SUCCESS;
738	if (uGL != UINT32_MAX)
739	rc = rtIso2022Decoder_LookupAndSet(&pThis->pMapGL, uGL, g_paGLMaps, RT_ELEMENTS(g_paGLMaps));
740	if (RT_SUCCESS(rc) && uG0 != UINT32_MAX)
741	rc = rtIso2022Decoder_LookupAndSet(&pThis->apMapGn[0], uG0, g_paGLMaps, RT_ELEMENTS(g_paGLMaps));
742	if (RT_SUCCESS(rc) && uC0 != UINT32_MAX)
743	rc = rtIso2022Decoder_SetC0(pThis, uC0);
744	if (RT_SUCCESS(rc) && uC1 != UINT32_MAX)
745	rc = rtIso2022Decoder_SetC1(pThis, uC1);
746	return rc;
747	}
748
749
750	static int rtIso2022Decoder_GetNextUniCpSlow(PRTISO2022DECODERSTATE pThis, PRTUNICP pUniCp)
751	{
752	while (pThis->offString < pThis->cbString)
753	{
754	uint8_t b = pThis->pabString[pThis->offString];
755	if (!(b & 0x80))
756	{
757	if (b >= 0x20)
758	{
759	/*
760	* GL range.
761	*/
762	b -= 0x20;
763	PCRTISO2022MAP pMap = pThis->pMapGL;
764
765	/* Single byte character map. */
766	if (pMap->cb == 1)
767	{
768	if (RT_LIKELY(b < pMap->cToUni))
769	{
770	uint16_t wc = pMap->pauToUni[b];
771	if (RT_LIKELY(wc != RTISO2022_UNUSED))
772	{
773	*pUniCp = wc;
774	pThis->offString += 1;
775	return VINF_SUCCESS;
776	}
777	*pUniCp = RTUNICP_INVALID;
778	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
779	"@%u: GL b=%#x is marked unused in map #%u range %u.",
780	pThis->offString, b + 0x20, pMap->uRegistration, pMap->cToUni);
781	}
782	*pUniCp = RTUNICP_INVALID;
783	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
784	"@%u: GL b=%#x is outside map #%u range %u.",
785	pThis->offString, b + 0x20, pMap->uRegistration, pMap->cToUni);
786	}
787
788	/* Double byte character set. */
789	Assert(pMap->cb == 2);
790	if (pThis->offString + 1 < pThis->cbString)
791	{
792	uint8_t b2 = pThis->pabString[pThis->offString + 1];
793	b2 -= 0x20;
794	if (RT_LIKELY(b2 < 0x60))
795	{
796	uint16_t u16 = ((uint16_t)b << 8) \| b2;
797	if (RT_LIKELY(u16 < pMap->cToUni))
798	{
799	uint16_t wc = pMap->pauToUni[b];
800	if (RT_LIKELY(wc != RTISO2022_UNUSED))
801	{
802	*pUniCp = wc;
803	pThis->offString += 2;
804	return VINF_SUCCESS;
805	}
806	*pUniCp = RTUNICP_INVALID;
807	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
808	"@%u: GL b=%#x is marked unused in map #%u.",
809	pThis->offString, b + 0x20, pMap->uRegistration);
810	}
811	if (u16 >= 0x7f00)
812	{
813	pUniCp = 0x7f; / delete */
814	pThis->offString += 2;
815	return VINF_SUCCESS;
816	}
817	*pUniCp = RTUNICP_INVALID;
818	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
819	"@%u: GL u16=%#x (b0=%#x b1=%#x) is outside map #%u range %u.",
820	pThis->offString, u16, b + 0x20, b2 + 0x20, pMap->uRegistration, pMap->cToUni);
821	}
822	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
823	"@%u: 2nd GL byte outside GL range: b0=%#x b1=%#x (map #%u)",
824	pThis->offString, b + 0x20, b2 + 0x20, pMap->uRegistration);
825
826	}
827	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
828	"@%u: EOS reading 2nd byte for GL b=%#x (map #%u).",
829	pThis->offString, b + 0x20, pMap->uRegistration);
830	}
831	else
832	{
833	/*
834	* C0 range.
835	*/
836	Assert(pThis->pMapC0->cb == 0x20);
837	uint16_t wc = pThis->pMapC0->pauToUni[b];
838	if (wc != RTISO2022_UNUSED)
839	{
840	int rc;
841	if (b == 0x1b \|\| wc == 0x1b) /* ESC is hardcoded, or so they say. */
842	rc = rtIso2022Decoder_InterpretEsc(pThis);
843	else
844	rc = rtIso2022Decoder_ControlCharHook(pThis, wc);
845	if (RT_SUCCESS(rc))
846	{
847	if (rc == 0)
848	{
849	pThis->offString += 1;
850	*pUniCp = wc;
851	return VINF_SUCCESS;
852	}
853	pThis->offString += rc;
854	}
855	else
856	return rc;
857	}
858	else
859	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
860	"@%u: C0 b=%#x is marked unused in map #%u.",
861	pThis->offString, b, pThis->pMapC0->uRegistration);
862	}
863	}
864	else
865	{
866	if (b >= 0xa0)
867	{
868	/*
869	* GR range.
870	*/
871	b -= 0xa0;
872	PCRTISO2022MAP pMap = pThis->pMapGR;
873
874	/* Single byte character map. */
875	if (pMap->cb == 1)
876	{
877	/** @todo 0xa0 = SPACE and 0xff = DELETE if it's a 94 charater map... */
878	if (RT_LIKELY(b < pMap->cToUni))
879	{
880	uint16_t wc = pMap->pauToUni[b];
881	if (RT_LIKELY(wc != RTISO2022_UNUSED))
882	{
883	*pUniCp = wc;
884	pThis->offString += 1;
885	return VINF_SUCCESS;
886	}
887
888	*pUniCp = RTUNICP_INVALID;
889	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
890	"@%u: GR b=%#x is marked unused in map #%u.",
891	pThis->offString, b + 0xa0, pMap->uRegistration);
892	}
893	*pUniCp = RTUNICP_INVALID;
894	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
895	"@%u: GR b=%#x is outside map #%u range %u",
896	pThis->offString, b + 0xa0, pMap->uRegistration, pMap->cToUni);
897	}
898
899	/* Double byte character set. */
900	Assert(pMap->cb == 2);
901	if (pThis->offString + 1 < pThis->cbString)
902	{
903	uint8_t b2 = pThis->pabString[pThis->offString + 1];
904	b2 -= 0xa0;
905	if (RT_LIKELY(b2 < 0x60))
906	{
907	uint16_t u16 = ((uint16_t)b << 8) \| b2;
908	if (RT_LIKELY(u16 < pMap->cToUni))
909	{
910	uint16_t wc = pMap->pauToUni[b];
911	if (RT_LIKELY(wc != RTISO2022_UNUSED))
912	{
913	*pUniCp = wc;
914	pThis->offString += 2;
915	return VINF_SUCCESS;
916	}
917
918	*pUniCp = RTUNICP_INVALID;
919	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
920	"@%u: GR b=%#x is marked unused in map #%u.",
921	pThis->offString, b + 0xa0, pMap->uRegistration);
922	}
923	*pUniCp = RTUNICP_INVALID;
924	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
925	"@%u: GR u16=%#x (b0=%#x b1=%#x) is outside map #%u range %u.",
926	pThis->offString, u16, b + 0xa0, b2 + 0xa0, pMap->uRegistration, pMap->cToUni);
927	}
928	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
929	"@%u: 2nd GR byte outside GR range: b0=%#x b1=%#x (map #%u).",
930	pThis->offString, b + 0xa0, b2 + 0xa0, pMap->uRegistration);
931
932	}
933	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
934	"@%u: EOS reading 2nd byte for GR b=%#x (map #%u).",
935	pThis->offString, b + 0xa0, pMap->uRegistration);
936	}
937	else
938	{
939	/*
940	* C2 range.
941	*/
942	Assert(pThis->pMapC1->cb == 0x20);
943	b -= 0x80;
944	uint16_t wc = pThis->pMapC1->pauToUni[b];
945	if (wc != RTISO2022_UNUSED)
946	{
947	int rc = rtIso2022Decoder_ControlCharHook(pThis, wc);
948	if (RT_SUCCESS(rc))
949	{
950	if (rc == 0)
951	{
952	pThis->offString += 1;
953	*pUniCp = wc;
954	return VINF_SUCCESS;
955	}
956	pThis->offString += rc;
957	}
958	else
959	return rc;
960	}
961	else
962	return RTErrInfoSetF(pThis->pErrInfo, VERR_ASN1_INVALID_T61_STRING_ENCODING,
963	"@%u: C1 b=%#x is marked unused in map #%u.",
964	pThis->offString, b + 0x80, pThis->pMapC1->uRegistration);
965	}
966	}
967	}
968
969	/* End of string. */
970	*pUniCp = RTUNICP_INVALID;
971	return VERR_END_OF_STRING;
972	}
973
974	DECLINLINE(int) rtIso2022Decoder_GetNextUniCp(PRTISO2022DECODERSTATE pThis, PRTUNICP pUniCp)
975	{
976	/*
977	* Deal with single byte GL.
978	*/
979	uint32_t const offString = pThis->offString;
980	if (pThis->offString < pThis->cbString)
981	{
982	PCRTISO2022MAP const pMapGL = pThis->pMapGL;
983	if (pMapGL->cb == 1)
984	{
985	uint8_t const b = pThis->pabString[offString] - (uint8_t)0x20;
986	if (b < pMapGL->cToUni)
987	{
988	uint16_t wc = pMapGL->pauToUni[b];
989	if (wc != RTISO2022_UNUSED)
990	{
991	pThis->offString = offString + 1;
992	*pUniCp = wc;
993	return VINF_SUCCESS;
994	}
995	}
996	}
997
998	/*
999	* Deal with complications in the non-inline function.
1000	*/
1001	return rtIso2022Decoder_GetNextUniCpSlow(pThis, pUniCp);
1002	}
1003
1004	*pUniCp = RTUNICP_INVALID;
1005	return VERR_END_OF_STRING;
1006	}
1007
1008
1009	static int rtIso2022ValidateString(uint32_t uProfile, const char pch, uint32_t cch, size_t pcchUtf8, PRTERRINFO pErrInfo)
1010	{
1011	AssertReturn(uProfile == ASN1_TAG_T61_STRING, VERR_INVALID_PARAMETER); /* just a place holder for now. */
1012
1013	RTISO2022DECODERSTATE Decoder;
1014	int rc = rtIso2022Decoder_Init(&Decoder, pch, cch, 102, 106, 107, 102, pErrInfo);
1015	if (RT_SUCCESS(rc))
1016	{
1017	size_t cchUtf8 = 0;
1018	for (;;)
1019	{
1020	RTUNICP uc;
1021	rc = rtIso2022Decoder_GetNextUniCp(&Decoder, &uc);
1022	if (RT_SUCCESS(rc))
1023	cchUtf8 += RTStrCpSize(uc);
1024	else
1025	{
1026	if (RT_LIKELY(rc == VERR_END_OF_STRING))
1027	{
1028	*pcchUtf8 = cchUtf8;
1029	return VINF_SUCCESS;
1030	}
1031	return rc;
1032	}
1033	}
1034	}
1035	return rc;
1036	}
1037
1038
1039	static int rtIso2022RecodeAsUtf8(uint32_t uProfile, const char pchSrc, uint32_t cchSrc, char pszDst, size_t cbDst)
1040	{
1041	AssertReturn(uProfile == ASN1_TAG_T61_STRING, VERR_INVALID_PARAMETER); /* just a place holder for now. */
1042	AssertReturn(cbDst > 0, VERR_INVALID_PARAMETER);
1043
1044	RTISO2022DECODERSTATE Decoder;
1045	int rc = rtIso2022Decoder_Init(&Decoder, pchSrc, cchSrc, 102, 106, 107, 102, NULL /pErrInfo/);
1046	if (RT_SUCCESS(rc))
1047	{
1048	for (;;)
1049	{
1050	RTUNICP uc;
1051	rc = rtIso2022Decoder_GetNextUniCp(&Decoder, &uc);
1052	if (RT_SUCCESS(rc))
1053	{
1054	if (uc < 0x80 && cbDst > 1)
1055	{
1056	*pszDst++ = (char)uc;
1057	cbDst--;
1058	}
1059	else
1060	{
1061	size_t cchUniCp = RTStrCpSize(uc);
1062	if (cbDst > cchUniCp)
1063	{
1064	cbDst -= cchUniCp;
1065	pszDst = RTStrPutCp(pszDst, uc);
1066	}
1067	else
1068	{
1069	*pszDst = '\0';
1070	return VERR_BUFFER_OVERFLOW;
1071	}
1072	}
1073	}
1074	else if (RT_LIKELY(rc == VERR_END_OF_STRING))
1075	{
1076	*pszDst = '\0';
1077	return VINF_SUCCESS;
1078	}
1079	else
1080	return rc;
1081	}
1082	}
1083	return rc;
1084	}
1085
1086
1087
1088	/** The unicode mapping of the C1 area of windows codepage 1252.
1089	* The rest of the code page is 1:1 with unicode. */
1090	static uint16_t g_awcWin1252_C1[0x20] =
1091	{
1092	0x20ac, 0x0081, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008d, 0x017d, 0x008f,
1093	0x0090, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x009d, 0x017e, 0x0178,
1094	};
1095
1096
1097	static size_t rtWin1252CalcUtf8Length(const char *pch, uint32_t cch)
1098	{
1099	size_t cchUtf8 = 0;
1100	while (cch-- > 0)
1101	{
1102	uint8_t const b = *pch++;
1103	if (b < 0x80)
1104	cchUtf8 += 1;
1105	else if (b >= 0xa0)
1106	cchUtf8 += 2;
1107	else
1108	{
1109	uint16_t const wc = g_awcWin1252_C1[b - 0x80];
1110	cchUtf8 += RTStrCpSize(wc);
1111	}
1112	}
1113	return cchUtf8;
1114	}
1115
1116
1117	static int rtWin1252RecodeAsUtf8(const char pchSrc, uint32_t cchSrc, char pszDst, size_t cbDst)
1118	{
1119	while (cchSrc-- > 0)
1120	{
1121	uint8_t b = *pchSrc++;
1122	if (b < 0x80)
1123	{
1124	if (cbDst <= 1)
1125	return VERR_BUFFER_OVERFLOW;
1126	*pszDst++ = (char)b;
1127	}
1128	else
1129	{
1130	uint16_t const wc = b >= 0xa0 ? b : g_awcWin1252_C1[b - 0x80];
1131	size_t cchCp = RTStrCpSize(wc);
1132	if (cbDst <= cchCp)
1133	return VERR_BUFFER_OVERFLOW;
1134	pszDst = RTStrPutCp(pszDst, wc);
1135	}
1136	}
1137
1138	if (!cbDst)
1139	return VERR_BUFFER_OVERFLOW;
1140	*pszDst = '\0';
1141	return VINF_SUCCESS;
1142	}
1143
1144
1145
1146	/*
1147	* ASN.1 STRING - Specific Methods.
1148	*/
1149
1150	/** rtAsn1String_IsTeletexLatin1 results. */
1151	typedef enum RTASN1TELETEXVARIANT
1152	{
1153	/** Couldn't find hard evidence of either. */
1154	RTASN1TELETEXVARIANT_UNDECIDED = 1,
1155	/** Pretty certain that it's real teletex. */
1156	RTASN1TELETEXVARIANT_TELETEX,
1157	/** Pretty sure it's latin-1 or Windows-1252. */
1158	RTASN1TELETEXVARIANT_LATIN1,
1159	/** Pretty sure it's Windows-1252. */
1160	RTASN1TELETEXVARIANT_WIN_1252
1161	} RTASN1TELETEXVARIANT;
1162
1163	/**
1164	* Takes a guess as whether TELETEX STRING (T61 STRING) is actually is Latin-1
1165	* or the real thing.
1166	*
1167	* According to RFC-2459, section 4.1.2.4, various libraries, certificate
1168	* authorities and others have perverted the TeletexString/T61String tag by
1169	* ISO-8859-1 (aka latin-1) strings (more probably these are actually Windows
1170	* CP-1252 rather than latin-1). We'll try detect incompatible latin-1
1171	* perversions by:
1172	* - The use of GR (0xf0-0xff) chars.
1173	* - The lack of ESC sequences and shifts (LS0,LS1,SS2,SS3)
1174	*
1175	* An ASSUMTION here is that GR is not loaded with anything at the start of a
1176	* teletex string, as per table 3 in section 8.23.5.2 in T-REC-X.590.200811.
1177	*
1178	* @retval @c true if chances are good that it's LATIN-1.
1179	* @retval @c false if changes are very good that it's real teletex.
1180	* @param pch The first char in the string.
1181	* @param cch The string length.
1182	*
1183	* @remarks Useful info on Teletex and ISO/IEC-2022:
1184	* https://www.mail-archive.com/asn1@asn1.org/msg00460.html
1185	* http://en.wikipedia.org/wiki/ISO/IEC_2022
1186	* http://www.open-std.org/cen/tc304/guide/GCONCEPT.HTM
1187	* http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-035.pdf
1188	*/
1189	static RTASN1TELETEXVARIANT rtAsn1String_IsTeletexLatin1(const char *pch, uint32_t cch)
1190	{
1191	RTASN1TELETEXVARIANT enmVariant = RTASN1TELETEXVARIANT_UNDECIDED;
1192	while (cch-- > 0)
1193	{
1194	uint8_t const b = *pch;
1195	if (b >= 0x20 && b <= 0x7f)
1196	{
1197	if (g_awcIsoIr102Decode[b - 0x20] == RTISO2022_UNUSED)
1198	enmVariant = RTASN1TELETEXVARIANT_LATIN1;
1199	}
1200	else
1201	{
1202	if ( b == 0x1b /* ESC */
1203	\|\| b == 0x0e /* LS0 / SI */
1204	\|\| b == 0x0f /* LS1 / SO */
1205	\|\| b == 0x19 /* SS2 */
1206	\|\| b == 0x1d /* SS3 */ )
1207	return RTASN1TELETEXVARIANT_TELETEX;
1208
1209	if (b >= 0xa0)
1210	enmVariant = RTASN1TELETEXVARIANT_LATIN1;
1211	else if (b >= 0x80 && b <= 0x9f)
1212	{
1213	/* Any use of C1 characters defined by windows cp-1252 will
1214	lead us to believe it's the windows code rather than the
1215	ISO/IEC standard that is being used. (Not that it makes
1216	much of a difference, because we're gonna treat it as the
1217	windows codepage, anyways.) */
1218	if ( b != 0x81
1219	&& b != 0x8d
1220	&& b != 0x8f
1221	&& b != 0x90
1222	&& b != 0x9d)
1223	return RTASN1TELETEXVARIANT_WIN_1252;
1224	}
1225	}
1226	}
1227	return RTASN1TELETEXVARIANT_UNDECIDED;
1228	}
1229
1230
1231	/**
1232	* Checks the encoding of an ASN.1 string according to it's tag.
1233	*
1234	* @returns IPRT status code.
1235	* @param pThis The string to santity check.
1236	* @param pErrInfo Where to store extra error info. Optional.
1237	* @param pcchUtf8 Where to return the UTF-8 string length. Optional.
1238	*/
1239	static int rtAsn1String_CheckSanity(PCRTASN1STRING pThis, PRTERRINFO pErrInfo, const char pszErrorTag, size_t pcchUtf8)
1240	{
1241	int rc;
1242	uint32_t cch = pThis->Asn1Core.cb;
1243	size_t cchUtf8 = cch;
1244	const char *pch = pThis->Asn1Core.uData.pch;
1245	uint32_t uTag = RTASN1CORE_GET_TAG(&pThis->Asn1Core);
1246	switch (uTag)
1247	{
1248	case ASN1_TAG_UTF8_STRING:
1249	rc = RTStrValidateEncodingEx(pch, cch, 0);
1250	if (RT_SUCCESS(rc))
1251	break;
1252	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_UTF8_STRING_ENCODING, "%s: Bad UTF-8 encoding (%Rrc, %.*Rhxs)",
1253	pszErrorTag, rc, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1254
1255	case ASN1_TAG_NUMERIC_STRING:
1256	while (cch-- > 0)
1257	{
1258	char ch = *pch++;
1259	if ( !RT_C_IS_DIGIT(ch)
1260	&& ch != ' ')
1261	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_NUMERIC_STRING_ENCODING,
1262	"%s: Bad numeric string: ch=%#x (pos %u in %.*Rhxs)", pszErrorTag, ch,
1263	pThis->Asn1Core.cb - cch + 1, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1264	}
1265	break;
1266
1267	case ASN1_TAG_PRINTABLE_STRING:
1268	while (cch-- > 0)
1269	{
1270	char ch = *pch++;
1271	if ( !RT_C_IS_ALNUM(ch)
1272	&& ch != ' '
1273	&& ch != '\''
1274	&& ch != '('
1275	&& ch != ')'
1276	&& ch != '+'
1277	&& ch != ','
1278	&& ch != '-'
1279	&& ch != '.'
1280	&& ch != '/'
1281	&& ch != ':'
1282	&& ch != '='
1283	&& ch != '?'
1284	)
1285	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_PRINTABLE_STRING_ENCODING,
1286	"%s: Bad printable string: ch=%#x (pos %u in %.*Rhxs)", pszErrorTag, ch,
1287	pThis->Asn1Core.cb - cch + 1, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1288	}
1289	break;
1290
1291	case ASN1_TAG_IA5_STRING: /* ASCII */
1292	while (cch-- > 0)
1293	{
1294	unsigned char ch = *pch++;
1295	if (ch == 0 \|\| ch >= 0x80)
1296	{
1297	/* Ignore C-style zero terminator as the "Microsoft ECC Product Root Certificate Authority 2018"
1298	for instance, has a policy qualifier string "http://www.microsoft.com/pkiops/Docs/Repository.htm\0" */
1299	/** @todo should '\0' really be excluded above? */
1300	if (ch != 0 \|\| cch != 0)
1301	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_IA5_STRING_ENCODING,
1302	"%s: Bad IA5 string: ch=%#x (pos %u in %.*Rhxs)", pszErrorTag, ch,
1303	pThis->Asn1Core.cb - cch + 1, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1304	break;
1305	}
1306	}
1307	break;
1308
1309	case ASN1_TAG_T61_STRING:
1310	switch (rtAsn1String_IsTeletexLatin1(pch, cch))
1311	{
1312	default:
1313	rc = rtIso2022ValidateString(ASN1_TAG_T61_STRING, pch, cch, &cchUtf8, pErrInfo);
1314	if (RT_FAILURE(rc))
1315	return rc;
1316	break;
1317	case RTASN1TELETEXVARIANT_UNDECIDED:
1318	case RTASN1TELETEXVARIANT_LATIN1:
1319	case RTASN1TELETEXVARIANT_WIN_1252:
1320	cchUtf8 = rtWin1252CalcUtf8Length(pch, cch);
1321	break;
1322	}
1323	break;
1324
1325	case ASN1_TAG_VIDEOTEX_STRING:
1326	case ASN1_TAG_GRAPHIC_STRING:
1327	return VERR_ASN1_STRING_TYPE_NOT_IMPLEMENTED;
1328
1329	case ASN1_TAG_VISIBLE_STRING:
1330	while (cch-- > 0)
1331	{
1332	unsigned char ch = *pch++;
1333	if (ch < 0x20 \|\| ch >= 0x7f)
1334	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_VISIBLE_STRING_ENCODING,
1335	"%s: Bad visible string: ch=%#x (pos %u in %.*Rhxs)", pszErrorTag, ch,
1336	pThis->Asn1Core.cb - cch + 1, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1337	}
1338	break;
1339
1340	case ASN1_TAG_GENERAL_STRING:
1341	return VERR_ASN1_STRING_TYPE_NOT_IMPLEMENTED;
1342
1343	case ASN1_TAG_UNIVERSAL_STRING:
1344	if (!(cch & 3))
1345	{
1346	uint8_t const pb = (uint8_t const )pch;
1347	cchUtf8 = 0;
1348	while (cch > 0)
1349	{
1350	RTUNICP uc = RT_MAKE_U32_FROM_U8(pb[3], pb[2], pb[1], pb[0]); /* big endian */
1351	if (!RTUniCpIsValid(uc))
1352	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_UNIVERSAL_STRING_ENCODING,
1353	"%s: Bad universal string: uc=%#x (pos %u in %.*Rhxs)", pszErrorTag, uc,
1354	pThis->Asn1Core.cb - cch + 1, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1355	cchUtf8 += RTUniCpCalcUtf8Len(uc);
1356
1357	/* next */
1358	pb += 4;
1359	cch -= 4;
1360	}
1361	break;
1362	}
1363	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_UNIVERSAL_STRING_ENCODING,
1364	"%s: Bad universal string: size not a multiple of 4: cch=%#x (%.*Rhxs)",
1365	pszErrorTag, cch, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1366
1367	case ASN1_TAG_BMP_STRING:
1368	if (!(cch & 1))
1369	{
1370	uint8_t const pb = (uint8_t const )pch;
1371	cchUtf8 = 0;
1372	while (cch > 0)
1373	{
1374	RTUNICP uc = RT_MAKE_U32_FROM_U8(pb[1], pb[0], 0, 0); /* big endian */
1375	if (!RTUniCpIsValid(uc))
1376	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_BMP_STRING_ENCODING,
1377	"%s: Bad BMP string: uc=%#x (pos %u in %.*Rhxs)", pszErrorTag, uc,
1378	pThis->Asn1Core.cb - cch + 1, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1379	cchUtf8 += RTUniCpCalcUtf8Len(uc);
1380
1381	/* next */
1382	pb += 2;
1383	cch -= 2;
1384	}
1385	break;
1386	}
1387	return RTErrInfoSetF(pErrInfo, VERR_ASN1_INVALID_BMP_STRING_ENCODING,
1388	"%s: Bad BMP string: odd number of bytes cch=%#x (%.*Rhxs)",
1389	pszErrorTag, cch, pThis->Asn1Core.cb, pThis->Asn1Core.uData.pch);
1390
1391	default:
1392	AssertMsgFailedReturn(("uTag=%#x\n", uTag), VERR_INTERNAL_ERROR_3);
1393	}
1394
1395	if (pcchUtf8)
1396	*pcchUtf8 = cchUtf8;
1397	return VINF_SUCCESS;
1398	}
1399
1400
1401	RTDECL(int) RTAsn1String_CompareValues(PCRTASN1STRING pLeft, PCRTASN1STRING pRight)
1402	{
1403	return RTAsn1String_CompareEx(pLeft, pRight, false /fTypeToo/);
1404	}
1405
1406
1407	RTDECL(int) RTAsn1String_CompareEx(PCRTASN1STRING pLeft, PCRTASN1STRING pRight, bool fTypeToo)
1408	{
1409	Assert(pLeft && (!RTAsn1String_IsPresent(pLeft) \|\| pLeft->Asn1Core.pOps == &g_RTAsn1String_Vtable));
1410	Assert(pRight && (!RTAsn1String_IsPresent(pRight) \|\| pRight->Asn1Core.pOps == &g_RTAsn1String_Vtable));
1411
1412	int iDiff;
1413	if (RTAsn1String_IsPresent(pLeft))
1414	{
1415	if (RTAsn1String_IsPresent(pRight))
1416	{
1417	if (!fTypeToo \|\| RTASN1CORE_GET_TAG(&pLeft->Asn1Core) == RTASN1CORE_GET_TAG(&pRight->Asn1Core))
1418	iDiff = RTAsn1Core_CompareEx(&pLeft->Asn1Core, &pRight->Asn1Core, true /fIgnoreTagAndClass/);
1419	else
1420	iDiff = RTASN1CORE_GET_TAG(&pLeft->Asn1Core) < RTASN1CORE_GET_TAG(&pRight->Asn1Core) ? -1 : 1;
1421	}
1422	else
1423	iDiff = 1;
1424	}
1425	else
1426	iDiff = 0 - RTAsn1String_IsPresent(pRight);
1427	return iDiff;
1428	}
1429
1430
1431	RTDECL(int) RTAsn1String_CompareWithString(PCRTASN1STRING pThis, const char *pszString, size_t cchString)
1432	{
1433	Assert(pThis && (!RTAsn1String_IsPresent(pThis) \|\| pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable));
1434	AssertPtr(pszString);
1435
1436	int iDiff;
1437	if (RTAsn1String_IsPresent(pThis))
1438	{
1439	if (cchString == RTSTR_MAX)
1440	cchString = strlen(pszString);
1441
1442	/*
1443	* If there is a UTF-8 conversion available already, use it.
1444	*/
1445	if (pThis->pszUtf8)
1446	{
1447	iDiff = strncmp(pThis->pszUtf8, pszString, cchString);
1448	if (!iDiff && pThis->cchUtf8 != cchString)
1449	iDiff = pThis->cchUtf8 < cchString ? -1 : 1;
1450	}
1451	else
1452	{
1453	/*
1454	* Some types are UTF-8 compatible, so try do the compare without
1455	* RTAsn1String_QueryUtf8.
1456	*/
1457	uint32_t cch = pThis->Asn1Core.cb;
1458	const char *pch = pThis->Asn1Core.uData.pch;
1459	switch (RTASN1CORE_GET_TAG(&pThis->Asn1Core))
1460	{
1461	case ASN1_TAG_UTF8_STRING:
1462	case ASN1_TAG_NUMERIC_STRING:
1463	case ASN1_TAG_IA5_STRING:
1464	case ASN1_TAG_PRINTABLE_STRING:
1465	iDiff = strncmp(pch, pszString, RT_MIN(cch, cchString));
1466	if (iDiff && cch != cchString)
1467	iDiff = cch < cchString ? - 1 : 1;
1468	break;
1469
1470	/** @todo Implement comparing ASN1_TAG_BMP_STRING, ASN1_TAG_UNIVERSAL_STRING and
1471	* ASN1_TAG_T61_STRING with UTF-8 strings without conversion. */
1472
1473	default:
1474	{
1475	int rc = RTAsn1String_QueryUtf8(pThis, NULL, NULL);
1476	if (RT_SUCCESS(rc))
1477	{
1478	iDiff = strncmp(pThis->pszUtf8, pszString, cchString);
1479	if (!iDiff && pThis->cchUtf8 != cchString)
1480	iDiff = pThis->cchUtf8 < cchString ? -1 : 1;
1481	}
1482	else
1483	iDiff = -1;
1484	break;
1485	}
1486	}
1487	}
1488
1489	/* Reduce the strcmp return value. */
1490	if (iDiff != 0)
1491	iDiff = iDiff < 0 ? -1 : 1;
1492	}
1493	else
1494	iDiff = -1;
1495	return iDiff;
1496	}
1497
1498
1499	RTDECL(int) RTAsn1String_QueryUtf8(PCRTASN1STRING pThis, const char *ppsz, size_t pcch)
1500	{
1501	Assert(pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable);
1502
1503	char psz = (char )pThis->pszUtf8;
1504	size_t cch = pThis->cchUtf8;
1505	if (!psz)
1506	{
1507
1508	/*
1509	* Convert the first time around. Start by validating the encoding and
1510	* calculating the length.
1511	*/
1512	int rc = rtAsn1String_CheckSanity(pThis, NULL, NULL, &cch);
1513	if (RT_SUCCESS(rc))
1514	{
1515	PRTASN1STRING pThisNC = (PRTASN1STRING)pThis;
1516	rc = RTAsn1MemAllocZ(&pThisNC->Allocation, (void **)&psz, cch + 1);
1517	if (RT_SUCCESS(rc))
1518	{
1519	/*
1520	* Got memory, now do the actual convertion to UTF-8 / copying.
1521	*/
1522	switch (RTASN1CORE_GET_TAG(&pThis->Asn1Core))
1523	{
1524	case ASN1_TAG_UTF8_STRING:
1525	case ASN1_TAG_NUMERIC_STRING:
1526	case ASN1_TAG_PRINTABLE_STRING:
1527	case ASN1_TAG_IA5_STRING:
1528	case ASN1_TAG_VISIBLE_STRING:
1529	Assert(cch == pThis->Asn1Core.cb);
1530	memcpy(psz, pThis->Asn1Core.uData.pch, cch);
1531	psz[cch] = '\0';
1532	break;
1533
1534	case ASN1_TAG_T61_STRING:
1535	switch (rtAsn1String_IsTeletexLatin1(pThis->Asn1Core.uData.pch, pThis->Asn1Core.cb))
1536	{
1537	default:
1538	rc = rtIso2022RecodeAsUtf8(ASN1_TAG_T61_STRING, pThis->Asn1Core.uData.pch, pThis->Asn1Core.cb,
1539	psz, cch + 1);
1540	break;
1541	case RTASN1TELETEXVARIANT_UNDECIDED:
1542	case RTASN1TELETEXVARIANT_LATIN1:
1543	case RTASN1TELETEXVARIANT_WIN_1252:
1544	rc = rtWin1252RecodeAsUtf8(pThis->Asn1Core.uData.pch, pThis->Asn1Core.cb, psz, cch + 1);
1545	break;
1546	}
1547	AssertReturnStmt(RT_SUCCESS(rc), RTAsn1MemFree(&pThisNC->Allocation, psz), VERR_INTERNAL_ERROR_3);
1548	break;
1549
1550	/* case ASN1_TAG_VIDEOTEX_STRING: */
1551	/* case ASN1_TAG_GRAPHIC_STRING: */
1552	/* case ASN1_TAG_GENERAL_STRING: */
1553
1554	case ASN1_TAG_UNIVERSAL_STRING:
1555	{
1556	char *pszDst = psz;
1557	size_t cchSrc = pThis->Asn1Core.cb;
1558	uint8_t const *pbSrc = pThis->Asn1Core.uData.pu8;
1559	while (cchSrc > 0)
1560	{
1561	RTUNICP uc = RT_MAKE_U32_FROM_U8(pbSrc[3], pbSrc[2], pbSrc[1], pbSrc[0]); /* big endian */
1562	AssertReturnStmt(RTUniCpIsValid(uc), RTAsn1MemFree(&pThisNC->Allocation, psz), VERR_INTERNAL_ERROR_2);
1563	pszDst = RTStrPutCp(pszDst, uc);
1564
1565	/* next */
1566	pbSrc += 4;
1567	cchSrc -= 4;
1568	}
1569	Assert((size_t)(pszDst - psz) == cch);
1570	break;
1571	}
1572
1573	case ASN1_TAG_BMP_STRING:
1574	{
1575	char *pszDst = psz;
1576	size_t cchSrc = pThis->Asn1Core.cb;
1577	uint8_t const *pbSrc = pThis->Asn1Core.uData.pu8;
1578	while (cchSrc > 0)
1579	{
1580	RTUNICP uc = RT_MAKE_U32_FROM_U8(pbSrc[1], pbSrc[0], 0, 0); /* big endian */
1581	AssertReturnStmt(RTUniCpIsValid(uc), RTAsn1MemFree(&pThisNC->Allocation, psz), VERR_INTERNAL_ERROR_2);
1582	pszDst = RTStrPutCp(pszDst, uc);
1583
1584	/* next */
1585	pbSrc += 2;
1586	cchSrc -= 2;
1587	}
1588	Assert((size_t)(pszDst - psz) == cch);
1589	break;
1590	}
1591
1592	default:
1593	RTAsn1MemFree(&pThisNC->Allocation, psz);
1594	AssertMsgFailedReturn(("uTag=%#x\n", RTASN1CORE_GET_TAG(&pThis->Asn1Core)), VERR_INTERNAL_ERROR_3);
1595	}
1596
1597	/*
1598	* Successfully produced UTF-8. Save it in the object.
1599	*/
1600	pThisNC->pszUtf8 = psz;
1601	pThisNC->cchUtf8 = (uint32_t)cch;
1602	}
1603	else
1604	return rc;
1605	}
1606	else
1607	return rc;
1608	}
1609
1610	/*
1611	* Success.
1612	*/
1613	if (ppsz)
1614	*ppsz = psz;
1615	if (pcch)
1616	*pcch = cch;
1617	return VINF_SUCCESS;
1618	}
1619
1620
1621
1622	RTDECL(int) RTAsn1String_QueryUtf8Len(PCRTASN1STRING pThis, size_t *pcch)
1623	{
1624	Assert(pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable);
1625
1626	size_t cch = pThis->cchUtf8;
1627	if (!cch && !pThis->pszUtf8)
1628	{
1629	int rc = rtAsn1String_CheckSanity(pThis, NULL, NULL, &cch);
1630	if (RT_FAILURE(rc))
1631	return rc;
1632	}
1633
1634	*pcch = cch;
1635	return VINF_SUCCESS;
1636	}
1637
1638
1639
1640
1641	RTDECL(int) RTAsn1String_InitEx(PRTASN1STRING pThis, uint32_t uTag, void const *pvValue, size_t cbValue,
1642	PCRTASN1ALLOCATORVTABLE pAllocator)
1643	{
1644	RT_ZERO(*pThis);
1645	AssertMsgReturn(uTag < RT_ELEMENTS(g_acbStringTags) && g_acbStringTags[uTag] > 0, ("uTag=%#x\n", uTag),
1646	VERR_INVALID_PARAMETER);
1647
1648	RTAsn1MemInitAllocation(&pThis->Allocation, pAllocator);
1649	RTAsn1Core_InitEx(&pThis->Asn1Core,
1650	uTag,
1651	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_PRIMITIVE,
1652	&g_RTAsn1String_Vtable,
1653	RTASN1CORE_F_PRESENT \| RTASN1CORE_F_PRIMITE_TAG_STRUCT);
1654
1655	if (cbValue > 0)
1656	{
1657	int rc = RTAsn1ContentDup(&pThis->Asn1Core, pvValue, cbValue, pAllocator);
1658	if (RT_FAILURE(rc))
1659	return rc;
1660	}
1661
1662	return VINF_SUCCESS;
1663	}
1664
1665
1666	RTDECL(int) RTAsn1String_InitWithValue(PRTASN1STRING pThis, const char *pszUtf8Value, PCRTASN1ALLOCATORVTABLE pAllocator)
1667	{
1668	Assert(RTStrValidateEncoding(pszUtf8Value));
1669	return RTAsn1String_InitEx(pThis, ASN1_TAG_UTF8_STRING, pszUtf8Value, strlen(pszUtf8Value), pAllocator);
1670	}
1671
1672
1673	RTDECL(int) RTAsn1String_RecodeAsUtf8(PRTASN1STRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator)
1674	{
1675	/*
1676	* Query the UTF-8 string. Do this even if it's already an
1677	* ASN1_TAG_UTF8_STRING object as it makes sure we've got a valid UTF-8
1678	* string upon successful return.
1679	*/
1680	int rc = RTAsn1String_QueryUtf8(pThis, NULL, NULL);
1681	if (RT_SUCCESS(rc))
1682	{
1683	if (RTASN1CORE_GET_TAG(&pThis->Asn1Core) != ASN1_TAG_UTF8_STRING)
1684	{
1685	/*
1686	* Resize the content, copy the UTF-8 bytes in there, and change
1687	* the tag.
1688	*/
1689	rc = RTAsn1ContentReallocZ(&pThis->Asn1Core, pThis->cchUtf8, pAllocator);
1690	if (RT_SUCCESS(rc))
1691	{
1692	memcpy((void *)pThis->Asn1Core.uData.pv, pThis->pszUtf8, pThis->cchUtf8);
1693	rc = RTAsn1Core_ChangeTag(&pThis->Asn1Core, ASN1_TAG_UTF8_STRING);
1694	}
1695	}
1696	}
1697	return rc;
1698	}
1699
1700
1701
1702	/*
1703	* ASN.1 STRING - Standard Methods.
1704	*/
1705
1706	RT_DECL_DATA_CONST(RTASN1COREVTABLE const) g_RTAsn1String_Vtable =
1707	{
1708	"RTAsn1String",
1709	sizeof(RTASN1STRING),
1710	UINT8_MAX,
1711	ASN1_TAGCLASS_UNIVERSAL \| ASN1_TAGFLAG_PRIMITIVE,
1712	0,
1713	(PFNRTASN1COREVTDTOR)RTAsn1String_Delete,
1714	NULL,
1715	(PFNRTASN1COREVTCLONE)RTAsn1String_Clone,
1716	(PFNRTASN1COREVTCOMPARE)RTAsn1String_Compare,
1717	(PFNRTASN1COREVTCHECKSANITY)RTAsn1String_CheckSanity,
1718	NULL,
1719	NULL
1720	};
1721
1722
1723	RTDECL(int) RTAsn1String_Init(PRTASN1STRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator)
1724	{
1725	return RTAsn1String_InitEx(pThis, ASN1_TAG_UTF8_STRING, NULL /pvValue/, 0 /cbValue/, pAllocator);
1726	}
1727
1728
1729	RTDECL(int) RTAsn1String_Clone(PRTASN1STRING pThis, PCRTASN1STRING pSrc, PCRTASN1ALLOCATORVTABLE pAllocator)
1730	{
1731	AssertPtr(pSrc); AssertPtr(pThis); AssertPtr(pAllocator);
1732	RT_ZERO(*pThis);
1733	if (RTAsn1String_IsPresent(pSrc))
1734	{
1735	AssertReturn(pSrc->Asn1Core.pOps == &g_RTAsn1String_Vtable, VERR_INTERNAL_ERROR_3);
1736	int rc = RTAsn1Core_CloneContent(&pThis->Asn1Core, &pSrc->Asn1Core, pAllocator);
1737	if (RT_SUCCESS(rc))
1738	{
1739	/* Don't copy the UTF-8 representation, decode it when queried. */
1740	RTAsn1MemInitAllocation(&pThis->Allocation, pAllocator);
1741	return VINF_SUCCESS;
1742	}
1743	}
1744	return VINF_SUCCESS;
1745	}
1746
1747
1748	RTDECL(void) RTAsn1String_Delete(PRTASN1STRING pThis)
1749	{
1750	if ( pThis
1751	&& RTAsn1String_IsPresent(pThis))
1752	{
1753	Assert(pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable);
1754
1755	if (pThis->Allocation.cbAllocated)
1756	RTAsn1MemFree(&pThis->Allocation, (char *)pThis->pszUtf8);
1757	RTAsn1ContentFree(&pThis->Asn1Core);
1758	RT_ZERO(*pThis);
1759	}
1760	}
1761
1762
1763	RTDECL(int) RTAsn1String_Enum(PRTASN1STRING pThis, PFNRTASN1ENUMCALLBACK pfnCallback, uint32_t uDepth, void *pvUser)
1764	{
1765	RT_NOREF_PV(pThis); RT_NOREF_PV(pfnCallback); RT_NOREF_PV(uDepth); RT_NOREF_PV(pvUser);
1766	Assert(pThis && (!RTAsn1String_IsPresent(pThis) \|\| pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable));
1767
1768	/* No children to enumerate. */
1769	return VINF_SUCCESS;
1770	}
1771
1772
1773	RTDECL(int) RTAsn1String_Compare(PCRTASN1STRING pLeft, PCRTASN1STRING pRight)
1774	{
1775	/* Compare tag and binary value. */
1776	return RTAsn1String_CompareEx(pLeft, pRight, true /fTypeToo/);
1777	}
1778
1779
1780	RTDECL(int) RTAsn1String_CheckSanity(PCRTASN1STRING pThis, uint32_t fFlags, PRTERRINFO pErrInfo, const char *pszErrorTag)
1781	{
1782	RT_NOREF_PV(fFlags);
1783	if (RT_UNLIKELY(!RTAsn1String_IsPresent(pThis)))
1784	return RTErrInfoSetF(pErrInfo, VERR_ASN1_NOT_PRESENT, "%s: Missing (STRING).", pszErrorTag);
1785	return rtAsn1String_CheckSanity(pThis, pErrInfo, pszErrorTag, NULL /pcchUtf8/);
1786	}
1787
1788
1789	/*
1790	* Generate code for the tag specific methods.
1791	* Note! This is very similar to what we're doing in asn1-ut-time.cpp.
1792	*/
1793	#define RTASN1STRING_IMPL(a_uTag, a_szTag, a_Api) \
1794	\
1795	RTDECL(int) RT_CONCAT(a_Api,_Init)(PRTASN1STRING pThis, PCRTASN1ALLOCATORVTABLE pAllocator) \
1796	{ \
1797	return RTAsn1String_InitEx(pThis, a_uTag, NULL /pvValue/, 0 /cbValue/, pAllocator); \
1798	} \
1799	\
1800	RTDECL(int) RT_CONCAT(a_Api,_Clone)(PRTASN1STRING pThis, PCRTASN1STRING pSrc, PCRTASN1ALLOCATORVTABLE pAllocator) \
1801	{ \
1802	AssertReturn(RTASN1CORE_GET_TAG(&pSrc->Asn1Core) == a_uTag \|\| !RTAsn1String_IsPresent(pSrc), \
1803	VERR_ASN1_STRING_TAG_MISMATCH); \
1804	return RTAsn1String_Clone(pThis, pSrc, pAllocator); \
1805	} \
1806	\
1807	RTDECL(void) RT_CONCAT(a_Api,_Delete)(PRTASN1STRING pThis) \
1808	{ \
1809	Assert( !pThis \
1810	\|\| !RTAsn1String_IsPresent(pThis) \
1811	\|\| ( pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable \
1812	&& RTASN1CORE_GET_TAG(&pThis->Asn1Core) == a_uTag) ); \
1813	RTAsn1String_Delete(pThis); \
1814	} \
1815	\
1816	RTDECL(int) RT_CONCAT(a_Api,_Enum)(PRTASN1STRING pThis, PFNRTASN1ENUMCALLBACK pfnCallback, uint32_t uDepth, void *pvUser) \
1817	{ \
1818	RT_NOREF_PV(pThis); RT_NOREF_PV(pfnCallback); RT_NOREF_PV(uDepth); RT_NOREF_PV(pvUser); \
1819	Assert( pThis \
1820	&& ( !RTAsn1String_IsPresent(pThis) \
1821	\|\| ( pThis->Asn1Core.pOps == &g_RTAsn1String_Vtable \
1822	&& RTASN1CORE_GET_TAG(&pThis->Asn1Core) == a_uTag) ) ); \
1823	/* No children to enumerate. */ \
1824	return VINF_SUCCESS; \
1825	} \
1826	\
1827	RTDECL(int) RT_CONCAT(a_Api,_Compare)(PCRTASN1STRING pLeft, PCRTASN1STRING pRight) \
1828	{ \
1829	int iDiff = RTAsn1String_CompareEx(pLeft, pRight, true /fTypeToo/); \
1830	if (!iDiff && RTASN1CORE_GET_TAG(&pLeft->Asn1Core) != a_uTag && RTAsn1String_IsPresent(pLeft)) \
1831	iDiff = RTASN1CORE_GET_TAG(&pLeft->Asn1Core) < a_uTag ? -1 : 1; \
1832	return iDiff; \
1833	} \
1834	\
1835	RTDECL(int) RT_CONCAT(a_Api,_CheckSanity)(PCRTASN1STRING pThis, uint32_t fFlags, \
1836	PRTERRINFO pErrInfo, const char *pszErrorTag) \
1837	{ \
1838	if (RTASN1CORE_GET_TAG(&pThis->Asn1Core) != a_uTag && RTAsn1String_IsPresent(pThis)) \
1839	return RTErrInfoSetF(pErrInfo, VERR_ASN1_STRING_TAG_MISMATCH, "%s: uTag=%#x, expected %#x (%s)", \
1840	pszErrorTag, RTASN1CORE_GET_TAG(&pThis->Asn1Core), a_uTag, a_szTag); \
1841	return RTAsn1String_CheckSanity(pThis, fFlags, pErrInfo, pszErrorTag); \
1842	}
1843
1844	#include "asn1-ut-string-template2.h"
1845
1846
1847	/*
1848	* Generate code for the associated collection types.
1849	*/
1850	#define RTASN1TMPL_TEMPLATE_FILE "../common/asn1/asn1-ut-string-template.h"
1851	#include <iprt/asn1-generator-internal-header.h>
1852	#include <iprt/asn1-generator-core.h>
1853	#include <iprt/asn1-generator-init.h>
1854	#include <iprt/asn1-generator-sanity.h>
1855

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

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

Download in other formats: