1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4 *******************************************************************************
5 *
6 * Copyright (C) 2003-2014, International Business Machines
7 * Corporation and others. All Rights Reserved.
8 *
9 *******************************************************************************
10 * file name: uidna.h
11 * encoding: UTF-8
12 * tab size: 8 (not used)
13 * indentation:4
14 *
15 * created on: 2003feb1
16 * created by: Ram Viswanadha
17 */
18
19#ifndef __UIDNA_H__
20#define __UIDNA_H__
21
22#include "unicode/utypes.h"
23
24#if !UCONFIG_NO_IDNA
25
26#include "unicode/localpointer.h"
27#include "unicode/parseerr.h"
28
29/**
30 * \file
31 * \brief C API: Internationalizing Domain Names in Applications (IDNA)
32 *
33 * IDNA2008 is implemented according to UTS #46, see the IDNA C++ class in idna.h.
34 *
35 * The C API functions which do take a UIDNA * service object pointer
36 * implement UTS #46 and IDNA2008.
37 *
38 * IDNA2003 is obsolete.
39 * The C API functions which do not take a service object pointer
40 * implement IDNA2003. They are all deprecated.
41 */
42
43/*
44 * IDNA option bit set values.
45 */
46enum {
47 /**
48 * Default options value: None of the other options are set.
49 * For use in static worker and factory methods.
50 * @stable ICU 2.6
51 */
52 UIDNA_DEFAULT=0,
53#ifndef U_HIDE_DEPRECATED_API
54 /**
55 * Option to allow unassigned code points in domain names and labels.
56 * For use in static worker and factory methods.
57 * <p>This option is ignored by the UTS46 implementation.
58 * (UTS #46 disallows unassigned code points.)
59 * @deprecated ICU 55 Use UTS #46 instead via uidna_openUTS46() or class IDNA.
60 */
61 UIDNA_ALLOW_UNASSIGNED=1,
62#endif /* U_HIDE_DEPRECATED_API */
63 /**
64 * Option to check whether the input conforms to the STD3 ASCII rules,
65 * for example the restriction of labels to LDH characters
66 * (ASCII Letters, Digits and Hyphen-Minus).
67 * For use in static worker and factory methods.
68 * @stable ICU 2.6
69 */
70 UIDNA_USE_STD3_RULES=2,
71 /**
72 * IDNA option to check for whether the input conforms to the BiDi rules.
73 * For use in static worker and factory methods.
74 * <p>This option is ignored by the IDNA2003 implementation.
75 * (IDNA2003 always performs a BiDi check.)
76 * @stable ICU 4.6
77 */
78 UIDNA_CHECK_BIDI=4,
79 /**
80 * IDNA option to check for whether the input conforms to the CONTEXTJ rules.
81 * For use in static worker and factory methods.
82 * <p>This option is ignored by the IDNA2003 implementation.
83 * (The CONTEXTJ check is new in IDNA2008.)
84 * @stable ICU 4.6
85 */
86 UIDNA_CHECK_CONTEXTJ=8,
87 /**
88 * IDNA option for nontransitional processing in ToASCII().
89 * For use in static worker and factory methods.
90 * <p>By default, ToASCII() uses transitional processing.
91 * <p>This option is ignored by the IDNA2003 implementation.
92 * (This is only relevant for compatibility of newer IDNA implementations with IDNA2003.)
93 * @stable ICU 4.6
94 */
95 UIDNA_NONTRANSITIONAL_TO_ASCII=0x10,
96 /**
97 * IDNA option for nontransitional processing in ToUnicode().
98 * For use in static worker and factory methods.
99 * <p>By default, ToUnicode() uses transitional processing.
100 * <p>This option is ignored by the IDNA2003 implementation.
101 * (This is only relevant for compatibility of newer IDNA implementations with IDNA2003.)
102 * @stable ICU 4.6
103 */
104 UIDNA_NONTRANSITIONAL_TO_UNICODE=0x20,
105 /**
106 * IDNA option to check for whether the input conforms to the CONTEXTO rules.
107 * For use in static worker and factory methods.
108 * <p>This option is ignored by the IDNA2003 implementation.
109 * (The CONTEXTO check is new in IDNA2008.)
110 * <p>This is for use by registries for IDNA2008 conformance.
111 * UTS #46 does not require the CONTEXTO check.
112 * @stable ICU 49
113 */
114 UIDNA_CHECK_CONTEXTO=0x40
115};
116
117/**
118 * Opaque C service object type for the new IDNA API.
119 * @stable ICU 4.6
120 */
121struct UIDNA;
122typedef struct UIDNA UIDNA; /**< C typedef for struct UIDNA. @stable ICU 4.6 */
123
124/**
125 * Returns a UIDNA instance which implements UTS #46.
126 * Returns an unmodifiable instance, owned by the caller.
127 * Cache it for multiple operations, and uidna_close() it when done.
128 * The instance is thread-safe, that is, it can be used concurrently.
129 *
130 * For details about the UTS #46 implementation see the IDNA C++ class in idna.h.
131 *
132 * @param options Bit set to modify the processing and error checking.
133 * See option bit set values in uidna.h.
134 * @param pErrorCode Standard ICU error code. Its input value must
135 * pass the U_SUCCESS() test, or else the function returns
136 * immediately. Check for U_FAILURE() on output or use with
137 * function chaining. (See User Guide for details.)
138 * @return the UTS #46 UIDNA instance, if successful
139 * @stable ICU 4.6
140 */
141U_STABLE UIDNA * U_EXPORT2
142uidna_openUTS46(uint32_t options, UErrorCode *pErrorCode);
143
144/**
145 * Closes a UIDNA instance.
146 * @param idna UIDNA instance to be closed
147 * @stable ICU 4.6
148 */
149U_STABLE void U_EXPORT2
150uidna_close(UIDNA *idna);
151
152#if U_SHOW_CPLUSPLUS_API
153
154U_NAMESPACE_BEGIN
155
156/**
157 * \class LocalUIDNAPointer
158 * "Smart pointer" class, closes a UIDNA via uidna_close().
159 * For most methods see the LocalPointerBase base class.
160 *
161 * @see LocalPointerBase
162 * @see LocalPointer
163 * @stable ICU 4.6
164 */
165U_DEFINE_LOCAL_OPEN_POINTER(LocalUIDNAPointer, UIDNA, uidna_close);
166
167U_NAMESPACE_END
168
169#endif
170
171/**
172 * Output container for IDNA processing errors.
173 * Initialize with UIDNA_INFO_INITIALIZER:
174 * \code
175 * UIDNAInfo info = UIDNA_INFO_INITIALIZER;
176 * int32_t length = uidna_nameToASCII(..., &info, &errorCode);
177 * if(U_SUCCESS(errorCode) && info.errors!=0) { ... }
178 * \endcode
179 * @stable ICU 4.6
180 */
181typedef struct UIDNAInfo {
182 /** sizeof(UIDNAInfo) @stable ICU 4.6 */
183 int16_t size;
184 /**
185 * Set to TRUE if transitional and nontransitional processing produce different results.
186 * For details see C++ IDNAInfo::isTransitionalDifferent().
187 * @stable ICU 4.6
188 */
189 UBool isTransitionalDifferent;
190 UBool reservedB3; /**< Reserved field, do not use. @internal */
191 /**
192 * Bit set indicating IDNA processing errors. 0 if no errors.
193 * See UIDNA_ERROR_... constants.
194 * @stable ICU 4.6
195 */
196 uint32_t errors;
197 int32_t reservedI2; /**< Reserved field, do not use. @internal */
198 int32_t reservedI3; /**< Reserved field, do not use. @internal */
199} UIDNAInfo;
200
201/**
202 * Static initializer for a UIDNAInfo struct.
203 * @stable ICU 4.6
204 */
205#define UIDNA_INFO_INITIALIZER { \
206 (int16_t)sizeof(UIDNAInfo), \
207 FALSE, FALSE, \
208 0, 0, 0 }
209
210/**
211 * Converts a single domain name label into its ASCII form for DNS lookup.
212 * If any processing step fails, then pInfo->errors will be non-zero and
213 * the result might not be an ASCII string.
214 * The label might be modified according to the types of errors.
215 * Labels with severe errors will be left in (or turned into) their Unicode form.
216 *
217 * The UErrorCode indicates an error only in exceptional cases,
218 * such as a U_MEMORY_ALLOCATION_ERROR.
219 *
220 * @param idna UIDNA instance
221 * @param label Input domain name label
222 * @param length Label length, or -1 if NUL-terminated
223 * @param dest Destination string buffer
224 * @param capacity Destination buffer capacity
225 * @param pInfo Output container of IDNA processing details.
226 * @param pErrorCode Standard ICU error code. Its input value must
227 * pass the U_SUCCESS() test, or else the function returns
228 * immediately. Check for U_FAILURE() on output or use with
229 * function chaining. (See User Guide for details.)
230 * @return destination string length
231 * @stable ICU 4.6
232 */
233U_STABLE int32_t U_EXPORT2
234uidna_labelToASCII(const UIDNA *idna,
235 const UChar *label, int32_t length,
236 UChar *dest, int32_t capacity,
237 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
238
239/**
240 * Converts a single domain name label into its Unicode form for human-readable display.
241 * If any processing step fails, then pInfo->errors will be non-zero.
242 * The label might be modified according to the types of errors.
243 *
244 * The UErrorCode indicates an error only in exceptional cases,
245 * such as a U_MEMORY_ALLOCATION_ERROR.
246 *
247 * @param idna UIDNA instance
248 * @param label Input domain name label
249 * @param length Label length, or -1 if NUL-terminated
250 * @param dest Destination string buffer
251 * @param capacity Destination buffer capacity
252 * @param pInfo Output container of IDNA processing details.
253 * @param pErrorCode Standard ICU error code. Its input value must
254 * pass the U_SUCCESS() test, or else the function returns
255 * immediately. Check for U_FAILURE() on output or use with
256 * function chaining. (See User Guide for details.)
257 * @return destination string length
258 * @stable ICU 4.6
259 */
260U_STABLE int32_t U_EXPORT2
261uidna_labelToUnicode(const UIDNA *idna,
262 const UChar *label, int32_t length,
263 UChar *dest, int32_t capacity,
264 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
265
266/**
267 * Converts a whole domain name into its ASCII form for DNS lookup.
268 * If any processing step fails, then pInfo->errors will be non-zero and
269 * the result might not be an ASCII string.
270 * The domain name might be modified according to the types of errors.
271 * Labels with severe errors will be left in (or turned into) their Unicode form.
272 *
273 * The UErrorCode indicates an error only in exceptional cases,
274 * such as a U_MEMORY_ALLOCATION_ERROR.
275 *
276 * @param idna UIDNA instance
277 * @param name Input domain name
278 * @param length Domain name length, or -1 if NUL-terminated
279 * @param dest Destination string buffer
280 * @param capacity Destination buffer capacity
281 * @param pInfo Output container of IDNA processing details.
282 * @param pErrorCode Standard ICU error code. Its input value must
283 * pass the U_SUCCESS() test, or else the function returns
284 * immediately. Check for U_FAILURE() on output or use with
285 * function chaining. (See User Guide for details.)
286 * @return destination string length
287 * @stable ICU 4.6
288 */
289U_STABLE int32_t U_EXPORT2
290uidna_nameToASCII(const UIDNA *idna,
291 const UChar *name, int32_t length,
292 UChar *dest, int32_t capacity,
293 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
294
295/**
296 * Converts a whole domain name into its Unicode form for human-readable display.
297 * If any processing step fails, then pInfo->errors will be non-zero.
298 * The domain name might be modified according to the types of errors.
299 *
300 * The UErrorCode indicates an error only in exceptional cases,
301 * such as a U_MEMORY_ALLOCATION_ERROR.
302 *
303 * @param idna UIDNA instance
304 * @param name Input domain name
305 * @param length Domain name length, or -1 if NUL-terminated
306 * @param dest Destination string buffer
307 * @param capacity Destination buffer capacity
308 * @param pInfo Output container of IDNA processing details.
309 * @param pErrorCode Standard ICU error code. Its input value must
310 * pass the U_SUCCESS() test, or else the function returns
311 * immediately. Check for U_FAILURE() on output or use with
312 * function chaining. (See User Guide for details.)
313 * @return destination string length
314 * @stable ICU 4.6
315 */
316U_STABLE int32_t U_EXPORT2
317uidna_nameToUnicode(const UIDNA *idna,
318 const UChar *name, int32_t length,
319 UChar *dest, int32_t capacity,
320 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
321
322/* UTF-8 versions of the processing methods --------------------------------- */
323
324/**
325 * Converts a single domain name label into its ASCII form for DNS lookup.
326 * UTF-8 version of uidna_labelToASCII(), same behavior.
327 *
328 * @param idna UIDNA instance
329 * @param label Input domain name label
330 * @param length Label length, or -1 if NUL-terminated
331 * @param dest Destination string buffer
332 * @param capacity Destination buffer capacity
333 * @param pInfo Output container of IDNA processing details.
334 * @param pErrorCode Standard ICU error code. Its input value must
335 * pass the U_SUCCESS() test, or else the function returns
336 * immediately. Check for U_FAILURE() on output or use with
337 * function chaining. (See User Guide for details.)
338 * @return destination string length
339 * @stable ICU 4.6
340 */
341U_STABLE int32_t U_EXPORT2
342uidna_labelToASCII_UTF8(const UIDNA *idna,
343 const char *label, int32_t length,
344 char *dest, int32_t capacity,
345 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
346
347/**
348 * Converts a single domain name label into its Unicode form for human-readable display.
349 * UTF-8 version of uidna_labelToUnicode(), same behavior.
350 *
351 * @param idna UIDNA instance
352 * @param label Input domain name label
353 * @param length Label length, or -1 if NUL-terminated
354 * @param dest Destination string buffer
355 * @param capacity Destination buffer capacity
356 * @param pInfo Output container of IDNA processing details.
357 * @param pErrorCode Standard ICU error code. Its input value must
358 * pass the U_SUCCESS() test, or else the function returns
359 * immediately. Check for U_FAILURE() on output or use with
360 * function chaining. (See User Guide for details.)
361 * @return destination string length
362 * @stable ICU 4.6
363 */
364U_STABLE int32_t U_EXPORT2
365uidna_labelToUnicodeUTF8(const UIDNA *idna,
366 const char *label, int32_t length,
367 char *dest, int32_t capacity,
368 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
369
370/**
371 * Converts a whole domain name into its ASCII form for DNS lookup.
372 * UTF-8 version of uidna_nameToASCII(), same behavior.
373 *
374 * @param idna UIDNA instance
375 * @param name Input domain name
376 * @param length Domain name length, or -1 if NUL-terminated
377 * @param dest Destination string buffer
378 * @param capacity Destination buffer capacity
379 * @param pInfo Output container of IDNA processing details.
380 * @param pErrorCode Standard ICU error code. Its input value must
381 * pass the U_SUCCESS() test, or else the function returns
382 * immediately. Check for U_FAILURE() on output or use with
383 * function chaining. (See User Guide for details.)
384 * @return destination string length
385 * @stable ICU 4.6
386 */
387U_STABLE int32_t U_EXPORT2
388uidna_nameToASCII_UTF8(const UIDNA *idna,
389 const char *name, int32_t length,
390 char *dest, int32_t capacity,
391 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
392
393/**
394 * Converts a whole domain name into its Unicode form for human-readable display.
395 * UTF-8 version of uidna_nameToUnicode(), same behavior.
396 *
397 * @param idna UIDNA instance
398 * @param name Input domain name
399 * @param length Domain name length, or -1 if NUL-terminated
400 * @param dest Destination string buffer
401 * @param capacity Destination buffer capacity
402 * @param pInfo Output container of IDNA processing details.
403 * @param pErrorCode Standard ICU error code. Its input value must
404 * pass the U_SUCCESS() test, or else the function returns
405 * immediately. Check for U_FAILURE() on output or use with
406 * function chaining. (See User Guide for details.)
407 * @return destination string length
408 * @stable ICU 4.6
409 */
410U_STABLE int32_t U_EXPORT2
411uidna_nameToUnicodeUTF8(const UIDNA *idna,
412 const char *name, int32_t length,
413 char *dest, int32_t capacity,
414 UIDNAInfo *pInfo, UErrorCode *pErrorCode);
415
416/*
417 * IDNA error bit set values.
418 * When a domain name or label fails a processing step or does not meet the
419 * validity criteria, then one or more of these error bits are set.
420 */
421enum {
422 /**
423 * A non-final domain name label (or the whole domain name) is empty.
424 * @stable ICU 4.6
425 */
426 UIDNA_ERROR_EMPTY_LABEL=1,
427 /**
428 * A domain name label is longer than 63 bytes.
429 * (See STD13/RFC1034 3.1. Name space specifications and terminology.)
430 * This is only checked in ToASCII operations, and only if the output label is all-ASCII.
431 * @stable ICU 4.6
432 */
433 UIDNA_ERROR_LABEL_TOO_LONG=2,
434 /**
435 * A domain name is longer than 255 bytes in its storage form.
436 * (See STD13/RFC1034 3.1. Name space specifications and terminology.)
437 * This is only checked in ToASCII operations, and only if the output domain name is all-ASCII.
438 * @stable ICU 4.6
439 */
440 UIDNA_ERROR_DOMAIN_NAME_TOO_LONG=4,
441 /**
442 * A label starts with a hyphen-minus ('-').
443 * @stable ICU 4.6
444 */
445 UIDNA_ERROR_LEADING_HYPHEN=8,
446 /**
447 * A label ends with a hyphen-minus ('-').
448 * @stable ICU 4.6
449 */
450 UIDNA_ERROR_TRAILING_HYPHEN=0x10,
451 /**
452 * A label contains hyphen-minus ('-') in the third and fourth positions.
453 * @stable ICU 4.6
454 */
455 UIDNA_ERROR_HYPHEN_3_4=0x20,
456 /**
457 * A label starts with a combining mark.
458 * @stable ICU 4.6
459 */
460 UIDNA_ERROR_LEADING_COMBINING_MARK=0x40,
461 /**
462 * A label or domain name contains disallowed characters.
463 * @stable ICU 4.6
464 */
465 UIDNA_ERROR_DISALLOWED=0x80,
466 /**
467 * A label starts with "xn--" but does not contain valid Punycode.
468 * That is, an xn-- label failed Punycode decoding.
469 * @stable ICU 4.6
470 */
471 UIDNA_ERROR_PUNYCODE=0x100,
472 /**
473 * A label contains a dot=full stop.
474 * This can occur in an input string for a single-label function.
475 * @stable ICU 4.6
476 */
477 UIDNA_ERROR_LABEL_HAS_DOT=0x200,
478 /**
479 * An ACE label does not contain a valid label string.
480 * The label was successfully ACE (Punycode) decoded but the resulting
481 * string had severe validation errors. For example,
482 * it might contain characters that are not allowed in ACE labels,
483 * or it might not be normalized.
484 * @stable ICU 4.6
485 */
486 UIDNA_ERROR_INVALID_ACE_LABEL=0x400,
487 /**
488 * A label does not meet the IDNA BiDi requirements (for right-to-left characters).
489 * @stable ICU 4.6
490 */
491 UIDNA_ERROR_BIDI=0x800,
492 /**
493 * A label does not meet the IDNA CONTEXTJ requirements.
494 * @stable ICU 4.6
495 */
496 UIDNA_ERROR_CONTEXTJ=0x1000,
497 /**
498 * A label does not meet the IDNA CONTEXTO requirements for punctuation characters.
499 * Some punctuation characters "Would otherwise have been DISALLOWED"
500 * but are allowed in certain contexts. (RFC 5892)
501 * @stable ICU 49
502 */
503 UIDNA_ERROR_CONTEXTO_PUNCTUATION=0x2000,
504 /**
505 * A label does not meet the IDNA CONTEXTO requirements for digits.
506 * Arabic-Indic Digits (U+066x) must not be mixed with Extended Arabic-Indic Digits (U+06Fx).
507 * @stable ICU 49
508 */
509 UIDNA_ERROR_CONTEXTO_DIGITS=0x4000
510};
511
512#ifndef U_HIDE_DEPRECATED_API
513
514/* IDNA2003 API ------------------------------------------------------------- */
515
516/**
517 * IDNA2003: This function implements the ToASCII operation as defined in the IDNA RFC.
518 * This operation is done on <b>single labels</b> before sending it to something that expects
519 * ASCII names. A label is an individual part of a domain name. Labels are usually
520 * separated by dots; e.g. "www.example.com" is composed of 3 labels "www","example", and "com".
521 *
522 * IDNA2003 API Overview:
523 *
524 * The uidna_ API implements the IDNA protocol as defined in the IDNA RFC
525 * (http://www.ietf.org/rfc/rfc3490.txt).
526 * The RFC defines 2 operations: ToASCII and ToUnicode. Domain name labels
527 * containing non-ASCII code points are processed by the
528 * ToASCII operation before passing it to resolver libraries. Domain names
529 * that are obtained from resolver libraries are processed by the
530 * ToUnicode operation before displaying the domain name to the user.
531 * IDNA requires that implementations process input strings with Nameprep
532 * (http://www.ietf.org/rfc/rfc3491.txt),
533 * which is a profile of Stringprep (http://www.ietf.org/rfc/rfc3454.txt),
534 * and then with Punycode (http://www.ietf.org/rfc/rfc3492.txt).
535 * Implementations of IDNA MUST fully implement Nameprep and Punycode;
536 * neither Nameprep nor Punycode are optional.
537 * The input and output of ToASCII and ToUnicode operations are Unicode
538 * and are designed to be chainable, i.e., applying ToASCII or ToUnicode operations
539 * multiple times to an input string will yield the same result as applying the operation
540 * once.
541 * ToUnicode(ToUnicode(ToUnicode...(ToUnicode(string)))) == ToUnicode(string)
542 * ToASCII(ToASCII(ToASCII...(ToASCII(string))) == ToASCII(string).
543 *
544 * @param src Input UChar array containing label in Unicode.
545 * @param srcLength Number of UChars in src, or -1 if NUL-terminated.
546 * @param dest Output UChar array with ASCII (ACE encoded) label.
547 * @param destCapacity Size of dest.
548 * @param options A bit set of options:
549 *
550 * - UIDNA_DEFAULT Use default options, i.e., do not process unassigned code points
551 * and do not use STD3 ASCII rules
552 * If unassigned code points are found the operation fails with
553 * U_UNASSIGNED_ERROR error code.
554 *
555 * - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASCII for query operations
556 * If this option is set, the unassigned code points are in the input
557 * are treated as normal Unicode code points.
558 *
559 * - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
560 * If this option is set and the input does not satisfy STD3 rules,
561 * the operation will fail with U_IDNA_STD3_ASCII_RULES_ERROR
562 *
563 * @param parseError Pointer to UParseError struct to receive information on position
564 * of error if an error is encountered. Can be NULL.
565 * @param status ICU in/out error code parameter.
566 * U_INVALID_CHAR_FOUND if src contains
567 * unmatched single surrogates.
568 * U_INDEX_OUTOFBOUNDS_ERROR if src contains
569 * too many code points.
570 * U_BUFFER_OVERFLOW_ERROR if destCapacity is not enough
571 * @return The length of the result string, if successful - or in case of a buffer overflow,
572 * in which case it will be greater than destCapacity.
573 * @deprecated ICU 55 Use UTS #46 instead via uidna_openUTS46() or class IDNA.
574 */
575U_DEPRECATED int32_t U_EXPORT2
576uidna_toASCII(const UChar* src, int32_t srcLength,
577 UChar* dest, int32_t destCapacity,
578 int32_t options,
579 UParseError* parseError,
580 UErrorCode* status);
581
582
583/**
584 * IDNA2003: This function implements the ToUnicode operation as defined in the IDNA RFC.
585 * This operation is done on <b>single labels</b> before sending it to something that expects
586 * Unicode names. A label is an individual part of a domain name. Labels are usually
587 * separated by dots; for e.g. "www.example.com" is composed of 3 labels "www","example", and "com".
588 *
589 * @param src Input UChar array containing ASCII (ACE encoded) label.
590 * @param srcLength Number of UChars in src, or -1 if NUL-terminated.
591 * @param dest Output Converted UChar array containing Unicode equivalent of label.
592 * @param destCapacity Size of dest.
593 * @param options A bit set of options:
594 *
595 * - UIDNA_DEFAULT Use default options, i.e., do not process unassigned code points
596 * and do not use STD3 ASCII rules
597 * If unassigned code points are found the operation fails with
598 * U_UNASSIGNED_ERROR error code.
599 *
600 * - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASCII for query operations
601 * If this option is set, the unassigned code points are in the input
602 * are treated as normal Unicode code points. <b> Note: </b> This option is
603 * required on toUnicode operation because the RFC mandates
604 * verification of decoded ACE input by applying toASCII and comparing
605 * its output with source
606 *
607 * - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
608 * If this option is set and the input does not satisfy STD3 rules,
609 * the operation will fail with U_IDNA_STD3_ASCII_RULES_ERROR
610 *
611 * @param parseError Pointer to UParseError struct to receive information on position
612 * of error if an error is encountered. Can be NULL.
613 * @param status ICU in/out error code parameter.
614 * U_INVALID_CHAR_FOUND if src contains
615 * unmatched single surrogates.
616 * U_INDEX_OUTOFBOUNDS_ERROR if src contains
617 * too many code points.
618 * U_BUFFER_OVERFLOW_ERROR if destCapacity is not enough
619 * @return The length of the result string, if successful - or in case of a buffer overflow,
620 * in which case it will be greater than destCapacity.
621 * @deprecated ICU 55 Use UTS #46 instead via uidna_openUTS46() or class IDNA.
622 */
623U_DEPRECATED int32_t U_EXPORT2
624uidna_toUnicode(const UChar* src, int32_t srcLength,
625 UChar* dest, int32_t destCapacity,
626 int32_t options,
627 UParseError* parseError,
628 UErrorCode* status);
629
630
631/**
632 * IDNA2003: Convenience function that implements the IDNToASCII operation as defined in the IDNA RFC.
633 * This operation is done on complete domain names, e.g: "www.example.com".
634 * It is important to note that this operation can fail. If it fails, then the input
635 * domain name cannot be used as an Internationalized Domain Name and the application
636 * should have methods defined to deal with the failure.
637 *
638 * <b>Note:</b> IDNA RFC specifies that a conformant application should divide a domain name
639 * into separate labels, decide whether to apply allowUnassigned and useSTD3ASCIIRules on each,
640 * and then convert. This function does not offer that level of granularity. The options once
641 * set will apply to all labels in the domain name
642 *
643 * @param src Input UChar array containing IDN in Unicode.
644 * @param srcLength Number of UChars in src, or -1 if NUL-terminated.
645 * @param dest Output UChar array with ASCII (ACE encoded) IDN.
646 * @param destCapacity Size of dest.
647 * @param options A bit set of options:
648 *
649 * - UIDNA_DEFAULT Use default options, i.e., do not process unassigned code points
650 * and do not use STD3 ASCII rules
651 * If unassigned code points are found the operation fails with
652 * U_UNASSIGNED_CODE_POINT_FOUND error code.
653 *
654 * - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASCII for query operations
655 * If this option is set, the unassigned code points are in the input
656 * are treated as normal Unicode code points.
657 *
658 * - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
659 * If this option is set and the input does not satisfy STD3 rules,
660 * the operation will fail with U_IDNA_STD3_ASCII_RULES_ERROR
661 *
662 * @param parseError Pointer to UParseError struct to receive information on position
663 * of error if an error is encountered. Can be NULL.
664 * @param status ICU in/out error code parameter.
665 * U_INVALID_CHAR_FOUND if src contains
666 * unmatched single surrogates.
667 * U_INDEX_OUTOFBOUNDS_ERROR if src contains
668 * too many code points.
669 * U_BUFFER_OVERFLOW_ERROR if destCapacity is not enough
670 * @return The length of the result string, if successful - or in case of a buffer overflow,
671 * in which case it will be greater than destCapacity.
672 * @deprecated ICU 55 Use UTS #46 instead via uidna_openUTS46() or class IDNA.
673 */
674U_DEPRECATED int32_t U_EXPORT2
675uidna_IDNToASCII( const UChar* src, int32_t srcLength,
676 UChar* dest, int32_t destCapacity,
677 int32_t options,
678 UParseError* parseError,
679 UErrorCode* status);
680
681/**
682 * IDNA2003: Convenience function that implements the IDNToUnicode operation as defined in the IDNA RFC.
683 * This operation is done on complete domain names, e.g: "www.example.com".
684 *
685 * <b>Note:</b> IDNA RFC specifies that a conformant application should divide a domain name
686 * into separate labels, decide whether to apply allowUnassigned and useSTD3ASCIIRules on each,
687 * and then convert. This function does not offer that level of granularity. The options once
688 * set will apply to all labels in the domain name
689 *
690 * @param src Input UChar array containing IDN in ASCII (ACE encoded) form.
691 * @param srcLength Number of UChars in src, or -1 if NUL-terminated.
692 * @param dest Output UChar array containing Unicode equivalent of source IDN.
693 * @param destCapacity Size of dest.
694 * @param options A bit set of options:
695 *
696 * - UIDNA_DEFAULT Use default options, i.e., do not process unassigned code points
697 * and do not use STD3 ASCII rules
698 * If unassigned code points are found the operation fails with
699 * U_UNASSIGNED_CODE_POINT_FOUND error code.
700 *
701 * - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASCII for query operations
702 * If this option is set, the unassigned code points are in the input
703 * are treated as normal Unicode code points.
704 *
705 * - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
706 * If this option is set and the input does not satisfy STD3 rules,
707 * the operation will fail with U_IDNA_STD3_ASCII_RULES_ERROR
708 *
709 * @param parseError Pointer to UParseError struct to receive information on position
710 * of error if an error is encountered. Can be NULL.
711 * @param status ICU in/out error code parameter.
712 * U_INVALID_CHAR_FOUND if src contains
713 * unmatched single surrogates.
714 * U_INDEX_OUTOFBOUNDS_ERROR if src contains
715 * too many code points.
716 * U_BUFFER_OVERFLOW_ERROR if destCapacity is not enough
717 * @return The length of the result string, if successful - or in case of a buffer overflow,
718 * in which case it will be greater than destCapacity.
719 * @deprecated ICU 55 Use UTS #46 instead via uidna_openUTS46() or class IDNA.
720 */
721U_DEPRECATED int32_t U_EXPORT2
722uidna_IDNToUnicode( const UChar* src, int32_t srcLength,
723 UChar* dest, int32_t destCapacity,
724 int32_t options,
725 UParseError* parseError,
726 UErrorCode* status);
727
728/**
729 * IDNA2003: Compare two IDN strings for equivalence.
730 * This function splits the domain names into labels and compares them.
731 * According to IDN RFC, whenever two labels are compared, they are
732 * considered equal if and only if their ASCII forms (obtained by
733 * applying toASCII) match using an case-insensitive ASCII comparison.
734 * Two domain names are considered a match if and only if all labels
735 * match regardless of whether label separators match.
736 *
737 * @param s1 First source string.
738 * @param length1 Length of first source string, or -1 if NUL-terminated.
739 *
740 * @param s2 Second source string.
741 * @param length2 Length of second source string, or -1 if NUL-terminated.
742 * @param options A bit set of options:
743 *
744 * - UIDNA_DEFAULT Use default options, i.e., do not process unassigned code points
745 * and do not use STD3 ASCII rules
746 * If unassigned code points are found the operation fails with
747 * U_UNASSIGNED_CODE_POINT_FOUND error code.
748 *
749 * - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASCII for query operations
750 * If this option is set, the unassigned code points are in the input
751 * are treated as normal Unicode code points.
752 *
753 * - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax restrictions
754 * If this option is set and the input does not satisfy STD3 rules,
755 * the operation will fail with U_IDNA_STD3_ASCII_RULES_ERROR
756 *
757 * @param status ICU error code in/out parameter.
758 * Must fulfill U_SUCCESS before the function call.
759 * @return <0 or 0 or >0 as usual for string comparisons
760 * @deprecated ICU 55 Use UTS #46 instead via uidna_openUTS46() or class IDNA.
761 */
762U_DEPRECATED int32_t U_EXPORT2
763uidna_compare( const UChar *s1, int32_t length1,
764 const UChar *s2, int32_t length2,
765 int32_t options,
766 UErrorCode* status);
767
768#endif /* U_HIDE_DEPRECATED_API */
769
770#endif /* #if !UCONFIG_NO_IDNA */
771
772#endif
773