libidn/stringprep.c

   1 /* stringprep.c --- Core stringprep implementation.
   2  * Copyright (C) 2002, 2003, 2004  Simon Josefsson
   3  *
   4  * This file is part of GNU Libidn.
   5  *
   6  * GNU Libidn is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * GNU Libidn is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with GNU Libidn; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <stdint.h>
  27
  28 #include "stringprep.h"
  29
  30 static ssize_t
  31 stringprep_find_character_in_table (uint32_t ucs4,
  32                                     const Stringprep_table_element * table)
  33 {
  34   ssize_t i;
  35
  36   /* This is where typical uses of Libidn spends very close to all CPU
  37      time and causes most cache misses.  One could easily do a binary
  38      search instead.  Before rewriting this, I want hard evidence this
  39      slowness is at all relevant in typical applications.  (I don't
  40      dispute optimization may improve matters significantly, I'm
  41      mostly interested in having someone give real-world benchmark on
  42      the impact of libidn.) */
  43
  44   for (i = 0; table[i].start || table[i].end; i++)
  45     if (ucs4 >= table[i].start &&
  46         ucs4 <= (table[i].end ? table[i].end : table[i].start))
  47       return i;
  48
  49   return -1;
  50 }
  51
  52 static ssize_t
  53 stringprep_find_string_in_table (uint32_t * ucs4,
  54                                  size_t ucs4len,
  55                                  size_t * tablepos,
  56                                  const Stringprep_table_element * table)
  57 {
  58   size_t j;
  59   ssize_t pos;
  60
  61   for (j = 0; j < ucs4len; j++)
  62     if ((pos = stringprep_find_character_in_table (ucs4[j], table)) != -1)
  63       {
  64         if (tablepos)
  65           *tablepos = pos;
  66         return j;
  67       }
  68
  69   return -1;
  70 }
  71
  72 static int
  73 stringprep_apply_table_to_string (uint32_t * ucs4,
  74                                   size_t * ucs4len,
  75                                   size_t maxucs4len,
  76                                   const Stringprep_table_element * table)
  77 {
  78   ssize_t pos;
  79   size_t i, maplen;
  80
  81   while ((pos = stringprep_find_string_in_table (ucs4, *ucs4len,
  82                                                  &i, table)) != -1)
  83     {
  84       for (maplen = STRINGPREP_MAX_MAP_CHARS;
  85            maplen > 0 && table[i].map[maplen - 1] == 0; maplen--)
  86         ;
  87
  88       if (*ucs4len - 1 + maplen >= maxucs4len)
  89         return STRINGPREP_TOO_SMALL_BUFFER;
  90
  91       memmove (&ucs4[pos + maplen], &ucs4[pos + 1],
  92                sizeof (uint32_t) * (*ucs4len - pos - 1));
  93       memcpy (&ucs4[pos], table[i].map, sizeof (uint32_t) * maplen);
  94       *ucs4len = *ucs4len - 1 + maplen;
  95     }
  96
  97   return STRINGPREP_OK;
  98 }
  99
 100 #define INVERTED(x) ((x) & ((~0UL) >> 1))
 101 #define UNAPPLICAPLEFLAGS(flags, profileflags) \
 102   ((!INVERTED(profileflags) && !(profileflags & flags) && profileflags) || \
 103    ( INVERTED(profileflags) && (profileflags & flags)))
 104
 105 /**
 106  * stringprep_4i:
 107  * @ucs4: input/output array with string to prepare.
 108  * @len: on input, length of input array with Unicode code points,
 109  *          on exit, length of output array with Unicode code points.
 110  * @maxucs4len: maximum length of input/output array.
 111  * @flags: stringprep profile flags, or 0.
 112  * @profile: pointer to stringprep profile to use.
 113  *
 114  * Prepare the input UCS-4 string according to the stringprep profile,
 115  * and write back the result to the input string.
 116  *
 117  * The input is not required to be zero terminated (@ucs4[@len] = 0).
 118  * The output will not be zero terminated unless @ucs4[@len] = 0.
 119  * Instead, see stringprep_4zi() if your input is zero terminated or
 120  * if you want the output to be.
 121  *
 122  * Since the stringprep operation can expand the string, @maxucs4len
 123  * indicate how large the buffer holding the string is.  This function
 124  * will not read or write to code points outside that size.
 125  *
 126  * The @flags are one of Stringprep_profile_flags, or 0.
 127  *
 128  * The @profile contain the instructions to perform.  Your application
 129  * can define new profiles, possibly re-using the generic stringprep
 130  * tables that always will be part of the library, or use one of the
 131  * currently supported profiles.
 132  *
 133  * Return value: Returns %STRINGPREP_OK iff successful, or an error code.
 134  **/
 135 int
 136 stringprep_4i (uint32_t * ucs4, size_t * len, size_t maxucs4len,
 137                Stringprep_profile_flags flags,
 138                const Stringprep_profile * profile)
 139 {
 140   size_t i, j;
 141   ssize_t k;
 142   size_t ucs4len = *len;
 143   int rc;
 144
 145   for (i = 0; profile[i].operation; i++)
 146     {
 147       switch (profile[i].operation)
 148         {
 149         case STRINGPREP_NFKC:
 150           {
 151             uint32_t *q = 0;
 152
 153             if (UNAPPLICAPLEFLAGS (flags, profile[i].flags))
 154               break;
 155
 156             if (flags & STRINGPREP_NO_NFKC && !profile[i].flags)
 157               /* Profile requires NFKC, but callee asked for no NFKC. */
 158               return STRINGPREP_FLAG_ERROR;
 159
 160             q = stringprep_ucs4_nfkc_normalize (ucs4, ucs4len);
 161             if (!q)
 162               return STRINGPREP_NFKC_FAILED;
 163
 164             for (ucs4len = 0; q[ucs4len]; ucs4len++)
 165               ;
 166
 167             if (ucs4len >= maxucs4len)
 168               {
 169                 free (q);
 170                 return STRINGPREP_TOO_SMALL_BUFFER;
 171               }
 172
 173             memcpy (ucs4, q, ucs4len * sizeof (ucs4[0]));
 174
 175             free (q);
 176           }
 177           break;
 178
 179         case STRINGPREP_PROHIBIT_TABLE:
 180           k = stringprep_find_string_in_table (ucs4, ucs4len,
 181                                                NULL, profile[i].table);
 182           if (k != -1)
 183             return STRINGPREP_CONTAINS_PROHIBITED;
 184           break;
 185
 186         case STRINGPREP_UNASSIGNED_TABLE:
 187           if (UNAPPLICAPLEFLAGS (flags, profile[i].flags))
 188             break;
 189           if (flags & STRINGPREP_NO_UNASSIGNED)
 190             {
 191               k = stringprep_find_string_in_table
 192                 (ucs4, ucs4len, NULL, profile[i].table);
 193               if (k != -1)
 194                 return STRINGPREP_CONTAINS_UNASSIGNED;
 195             }
 196           break;
 197
 198         case STRINGPREP_MAP_TABLE:
 199           if (UNAPPLICAPLEFLAGS (flags, profile[i].flags))
 200             break;
 201           rc = stringprep_apply_table_to_string
 202             (ucs4, &ucs4len, maxucs4len, profile[i].table);
 203           if (rc != STRINGPREP_OK)
 204             return rc;
 205           break;
 206
 207         case STRINGPREP_BIDI_PROHIBIT_TABLE:
 208         case STRINGPREP_BIDI_RAL_TABLE:
 209         case STRINGPREP_BIDI_L_TABLE:
 210           break;
 211
 212         case STRINGPREP_BIDI:
 213           {
 214             int done_prohibited = 0;
 215             int done_ral = 0;
 216             int done_l = 0;
 217             int contains_ral = -1;
 218             int contains_l = -1;
 219
 220             for (j = 0; profile[j].operation; j++)
 221               if (profile[j].operation == STRINGPREP_BIDI_PROHIBIT_TABLE)
 222                 {
 223                   done_prohibited = 1;
 224                   k = stringprep_find_string_in_table (ucs4, ucs4len,
 225                                                        NULL,
 226                                                        profile[j].table);
 227                   if (k != -1)
 228                     return STRINGPREP_BIDI_CONTAINS_PROHIBITED;
 229                 }
 230               else if (profile[j].operation == STRINGPREP_BIDI_RAL_TABLE)
 231                 {
 232                   done_ral = 1;
 233                   if (stringprep_find_string_in_table
 234                       (ucs4, ucs4len, NULL, profile[j].table) != -1)
 235                     contains_ral = j;
 236                 }
 237               else if (profile[j].operation == STRINGPREP_BIDI_L_TABLE)
 238                 {
 239                   done_l = 1;
 240                   if (stringprep_find_string_in_table
 241                       (ucs4, ucs4len, NULL, profile[j].table) != -1)
 242                     contains_l = j;
 243                 }
 244
 245             if (!done_prohibited || !done_ral || !done_l)
 246               return STRINGPREP_PROFILE_ERROR;
 247
 248             if (contains_ral != -1 && contains_l != -1)
 249               return STRINGPREP_BIDI_BOTH_L_AND_RAL;
 250
 251             if (contains_ral != -1)
 252               {
 253                 if (!(stringprep_find_character_in_table
 254                       (ucs4[0], profile[contains_ral].table) != -1 &&
 255                       stringprep_find_character_in_table
 256                       (ucs4[ucs4len - 1], profile[contains_ral].table) != -1))
 257                   return STRINGPREP_BIDI_LEADTRAIL_NOT_RAL;
 258               }
 259           }
 260           break;
 261
 262         default:
 263           return STRINGPREP_PROFILE_ERROR;
 264           break;
 265         }
 266     }
 267
 268   *len = ucs4len;
 269
 270   return STRINGPREP_OK;
 271 }
 272
 273 static int
 274 stringprep_4zi_1 (uint32_t * ucs4, size_t ucs4len, size_t maxucs4len,
 275                   Stringprep_profile_flags flags,
 276                   const Stringprep_profile * profile)
 277 {
 278   int rc;
 279
 280   rc = stringprep_4i (ucs4, &ucs4len, maxucs4len, flags, profile);
 281   if (rc != STRINGPREP_OK)
 282     return rc;
 283
 284   if (ucs4len >= maxucs4len)
 285     return STRINGPREP_TOO_SMALL_BUFFER;
 286
 287   ucs4[ucs4len] = 0;
 288
 289   return STRINGPREP_OK;
 290 }
 291
 292 /**
 293  * stringprep_4zi:
 294  * @ucs4: input/output array with zero terminated string to prepare.
 295  * @maxucs4len: maximum length of input/output array.
 296  * @flags: stringprep profile flags, or 0.
 297  * @profile: pointer to stringprep profile to use.
 298  *
 299  * Prepare the input zero terminated UCS-4 string according to the
 300  * stringprep profile, and write back the result to the input string.
 301  *
 302  * Since the stringprep operation can expand the string, @maxucs4len
 303  * indicate how large the buffer holding the string is.  This function
 304  * will not read or write to code points outside that size.
 305  *
 306  * The @flags are one of Stringprep_profile_flags, or 0.
 307  *
 308  * The @profile contain the instructions to perform.  Your application
 309  * can define new profiles, possibly re-using the generic stringprep
 310  * tables that always will be part of the library, or use one of the
 311  * currently supported profiles.
 312  *
 313  * Return value: Returns %STRINGPREP_OK iff successful, or an error code.
 314  **/
 315 int
 316 stringprep_4zi (uint32_t * ucs4, size_t maxucs4len,
 317                 Stringprep_profile_flags flags,
 318                 const Stringprep_profile * profile)
 319 {
 320   size_t ucs4len;
 321
 322   for (ucs4len = 0; ucs4len < maxucs4len && ucs4[ucs4len] != 0; ucs4len++)
 323     ;
 324
 325   return stringprep_4zi_1 (ucs4, ucs4len, maxucs4len, flags, profile);
 326 }
 327
 328 /**
 329  * stringprep:
 330  * @in: input/ouput array with string to prepare.
 331  * @maxlen: maximum length of input/output array.
 332  * @flags: stringprep profile flags, or 0.
 333  * @profile: pointer to stringprep profile to use.
 334  *
 335  * Prepare the input zero terminated UTF-8 string according to the
 336  * stringprep profile, and write back the result to the input string.
 337  *
 338  * Note that you must convert strings entered in the systems locale
 339  * into UTF-8 before using this function, see
 340  * stringprep_locale_to_utf8().
 341  *
 342  * Since the stringprep operation can expand the string, @maxlen
 343  * indicate how large the buffer holding the string is.  This function
 344  * will not read or write to characters outside that size.
 345  *
 346  * The @flags are one of Stringprep_profile_flags, or 0.
 347  *
 348  * The @profile contain the instructions to perform.  Your application
 349  * can define new profiles, possibly re-using the generic stringprep
 350  * tables that always will be part of the library, or use one of the
 351  * currently supported profiles.
 352  *
 353  * Return value: Returns %STRINGPREP_OK iff successful, or an error code.
 354  **/
 355 int
 356 stringprep (char *in,
 357             size_t maxlen,
 358             Stringprep_profile_flags flags,
 359             const Stringprep_profile * profile)
 360 {
 361   int rc;
 362   char *utf8 = NULL;
 363   uint32_t *ucs4 = NULL;
 364   size_t ucs4len, maxucs4len, adducs4len = 50;
 365
 366   do
 367     {
 368       free (ucs4);
 369       ucs4 = stringprep_utf8_to_ucs4 (in, -1, &ucs4len);
 370       maxucs4len = ucs4len + adducs4len;
 371       uint32_t *newp = realloc (ucs4, maxucs4len * sizeof (uint32_t));
 372       if (!newp)
 373         {
 374           free (ucs4);
 375           return STRINGPREP_MALLOC_ERROR;
 376         }
 377       ucs4 = newp;
 378
 379       rc = stringprep_4i (ucs4, &ucs4len, maxucs4len, flags, profile);
 380       adducs4len += 50;
 381     }
 382   while (rc == STRINGPREP_TOO_SMALL_BUFFER);
 383   if (rc != STRINGPREP_OK)
 384     {
 385       free (ucs4);
 386       return rc;
 387     }
 388
 389   utf8 = stringprep_ucs4_to_utf8 (ucs4, ucs4len, 0, 0);
 390   free (ucs4);
 391   if (!utf8)
 392     return STRINGPREP_MALLOC_ERROR;
 393
 394   if (strlen (utf8) >= maxlen)
 395     {
 396       free (utf8);
 397       return STRINGPREP_TOO_SMALL_BUFFER;
 398     }
 399
 400   strcpy (in, utf8);            /* flawfinder: ignore */
 401
 402   free (utf8);
 403
 404   return STRINGPREP_OK;
 405 }
 406
 407 /**
 408  * stringprep_profile:
 409  * @in: input array with UTF-8 string to prepare.
 410  * @out: output variable with pointer to newly allocate string.
 411  * @profile: name of stringprep profile to use.
 412  * @flags: stringprep profile flags, or 0.
 413  *
 414  * Prepare the input zero terminated UTF-8 string according to the
 415  * stringprep profile, and return the result in a newly allocated
 416  * variable.
 417  *
 418  * Note that you must convert strings entered in the systems locale
 419  * into UTF-8 before using this function, see
 420  * stringprep_locale_to_utf8().
 421  *
 422  * The output @out variable must be deallocated by the caller.
 423  *
 424  * The @flags are one of Stringprep_profile_flags, or 0.
 425  *
 426  * The @profile specifies the name of the stringprep profile to use.
 427  * It must be one of the internally supported stringprep profiles.
 428  *
 429  * Return value: Returns %STRINGPREP_OK iff successful, or an error code.
 430  **/
 431 int
 432 stringprep_profile (const char *in,
 433                     char **out,
 434                     const char *profile, Stringprep_profile_flags flags)
 435 {
 436   const Stringprep_profiles *p;
 437   char *str = NULL;
 438   size_t len = strlen (in) + 1;
 439   int rc;
 440
 441   for (p = &stringprep_profiles[0]; p->name; p++)
 442     if (strcmp (p->name, profile) == 0)
 443       break;
 444
 445   if (!p || !p->name || !p->tables)
 446     return STRINGPREP_UNKNOWN_PROFILE;
 447
 448   do
 449     {
 450       free (str);
 451       str = (char *) malloc (len);
 452       if (str == NULL)
 453         return STRINGPREP_MALLOC_ERROR;
 454
 455       strcpy (str, in);
 456
 457       rc = stringprep (str, len, flags, p->tables);
 458       len += 50;
 459     }
 460   while (rc == STRINGPREP_TOO_SMALL_BUFFER);
 461
 462   if (rc == STRINGPREP_OK)
 463     *out = str;
 464   else
 465     free (str);
 466
 467   return rc;
 468 }
 469
 470 /*! \mainpage GNU Internationalized Domain Name Library
 471  *
 472  * \section intro Introduction
 473  *
 474  * GNU Libidn is an implementation of the Stringprep, Punycode and IDNA
 475  * specifications defined by the IETF Internationalized Domain Names
 476  * (IDN) working group, used for internationalized domain names.  The
 477  * package is available under the GNU Lesser General Public License.
 478  *
 479  * The library contains a generic Stringprep implementation that does
 480  * Unicode 3.2 NFKC normalization, mapping and prohibitation of
 481  * characters, and bidirectional character handling.  Profiles for
 482  * Nameprep, iSCSI, SASL and XMPP are included.  Punycode and ASCII
 483  * Compatible Encoding (ACE) via IDNA are supported.  A mechanism to
 484  * define Top-Level Domain (TLD) specific validation tables, and to
 485  * compare strings against those tables, is included.  Default tables
 486  * for some TLDs are also included.
 487  *
 488  * The Stringprep API consists of two main functions, one for
 489  * converting data from the system's native representation into UTF-8,
 490  * and one function to perform the Stringprep processing.  Adding a
 491  * new Stringprep profile for your application within the API is
 492  * straightforward.  The Punycode API consists of one encoding
 493  * function and one decoding function.  The IDNA API consists of the
 494  * ToASCII and ToUnicode functions, as well as an high-level interface
 495  * for converting entire domain names to and from the ACE encoded
 496  * form.  The TLD API consists of one set of functions to extract the
 497  * TLD name from a domain string, one set of functions to locate the
 498  * proper TLD table to use based on the TLD name, and core functions
 499  * to validate a string against a TLD table, and some utility wrappers
 500  * to perform all the steps in one call.
 501  *
 502  * The library is used by, e.g., GNU SASL and Shishi to process user
 503  * names and passwords.  Libidn can be built into GNU Libc to enable a
 504  * new system-wide getaddrinfo() flag for IDN processing.
 505  *
 506  * Libidn is developed for the GNU/Linux system, but runs on over 20 Unix
 507  * platforms (including Solaris, IRIX, AIX, and Tru64) and Windows.
 508  * Libidn is written in C and (parts of) the API is accessible from C,
 509  * C++, Emacs Lisp, Python and Java.
 510  *
 511  * The project web page:\n
 512  * http://www.gnu.org/software/libidn/
 513  *
 514  * The software archive:\n
 515  * ftp://alpha.gnu.org/pub/gnu/libidn/
 516  *
 517  * For more information see:\n
 518  * http://www.ietf.org/html.charters/idn-charter.html\n
 519  * http://www.ietf.org/rfc/rfc3454.txt (stringprep specification)\n
 520  * http://www.ietf.org/rfc/rfc3490.txt (idna specification)\n
 521  * http://www.ietf.org/rfc/rfc3491.txt (nameprep specification)\n
 522  * http://www.ietf.org/rfc/rfc3492.txt (punycode specification)\n
 523  * http://www.ietf.org/internet-drafts/draft-ietf-ips-iscsi-string-prep-04.txt\n
 524  * http://www.ietf.org/internet-drafts/draft-ietf-krb-wg-utf8-profile-01.txt\n
 525  * http://www.ietf.org/internet-drafts/draft-ietf-sasl-anon-00.txt\n
 526  * http://www.ietf.org/internet-drafts/draft-ietf-sasl-saslprep-00.txt\n
 527  * http://www.ietf.org/internet-drafts/draft-ietf-xmpp-nodeprep-01.txt\n
 528  * http://www.ietf.org/internet-drafts/draft-ietf-xmpp-resourceprep-01.txt\n
 529  *
 530  * Further information and paid contract development:\n
 531  * Simon Josefsson <simon@josefsson.org>
 532  *
 533  * \section examples Examples
 534  *
 535  * \include example.c
 536  * \include example3.c
 537  * \include example4.c
 538  * \include example5.c
 539  */
 540
 541 /**
 542  * STRINGPREP_VERSION
 543  *
 544  * String defined via CPP denoting the header file version number.
 545  * Used together with stringprep_check_version() to verify header file
 546  * and run-time library consistency.
 547  */
 548
 549 /**
 550  * STRINGPREP_MAX_MAP_CHARS
 551  *
 552  * Maximum number of code points that can replace a single code point,
 553  * during stringprep mapping.
 554  */
 555
 556 /**
 557  * Stringprep_rc:
 558  * @STRINGPREP_OK: Successful operation.  This value is guaranteed to
 559  *   always be zero, the remaining ones are only guaranteed to hold
 560  *   non-zero values, for logical comparison purposes.
 561  * @STRINGPREP_CONTAINS_UNASSIGNED: String contain unassigned Unicode
 562  *   code points, which is forbidden by the profile.
 563  * @STRINGPREP_CONTAINS_PROHIBITED: String contain code points
 564  *   prohibited by the profile.
 565  * @STRINGPREP_BIDI_BOTH_L_AND_RAL: String contain code points with
 566  *   conflicting bidirectional category.
 567  * @STRINGPREP_BIDI_LEADTRAIL_NOT_RAL: Leading and trailing character
 568  *   in string not of proper bidirectional category.
 569  * @STRINGPREP_BIDI_CONTAINS_PROHIBITED: Contains prohibited code
 570  *   points detected by bidirectional code.
 571  * @STRINGPREP_TOO_SMALL_BUFFER: Buffer handed to function was too
 572  *   small.  This usually indicate a problem in the calling
 573  *   application.
 574  * @STRINGPREP_PROFILE_ERROR: The stringprep profile was inconsistent.
 575  *   This usually indicate an internal error in the library.
 576  * @STRINGPREP_FLAG_ERROR: The supplied flag conflicted with profile.
 577  *   This usually indicate a problem in the calling application.
 578  * @STRINGPREP_UNKNOWN_PROFILE: The supplied profile name was not
 579  *   known to the library.
 580  * @STRINGPREP_NFKC_FAILED: The Unicode NFKC operation failed.  This
 581  *   usually indicate an internal error in the library.
 582  * @STRINGPREP_MALLOC_ERROR: The malloc() was out of memory.  This is
 583  *   usually a fatal error.
 584  *
 585  * Enumerated return codes of stringprep(), stringprep_profile()
 586  * functions (and macros using those functions).  The value 0 is
 587  * guaranteed to always correspond to success.
 588  */
 589
 590 /**
 591  * Stringprep_profile_flags:
 592  * @STRINGPREP_NO_NFKC: Disable the NFKC normalization, as well as
 593  *   selecting the non-NFKC case folding tables.  Usually the profile
 594  *   specifies BIDI and NFKC settings, and applications should not
 595  *   override it unless in special situations.
 596  * @STRINGPREP_NO_BIDI: Disable the BIDI step.  Usually the profile
 597  *   specifies BIDI and NFKC settings, and applications should not
 598  *   override it unless in special situations.
 599  * @STRINGPREP_NO_UNASSIGNED: Make the library return with an error if
 600  *   string contains unassigned characters according to profile.
 601  *
 602  * Stringprep profile flags.
 603  */
 604
 605 /**
 606  * Stringprep_profile_steps:
 607  *
 608  * Various steps in the stringprep algorithm.  You really want to
 609  * study the source code to understand this one.  Only useful if you
 610  * want to add another profile.
 611  */
 612
 613 /**
 614  * stringprep_nameprep:
 615  * @in: input/ouput array with string to prepare.
 616  * @maxlen: maximum length of input/output array.
 617  *
 618  * Prepare the input UTF-8 string according to the nameprep profile.
 619  * The AllowUnassigned flag is true, use
 620  * stringprep_nameprep_no_unassigned() if you want a false
 621  * AllowUnassigned.  Returns 0 iff successful, or an error code.
 622  **/
 623
 624 /**
 625  * stringprep_nameprep_no_unassigned:
 626  * @in: input/ouput array with string to prepare.
 627  * @maxlen: maximum length of input/output array.
 628  *
 629  * Prepare the input UTF-8 string according to the nameprep profile.
 630  * The AllowUnassigned flag is false, use stringprep_nameprep() for
 631  * true AllowUnassigned.  Returns 0 iff successful, or an error code.
 632  **/
 633
 634 /**
 635  * stringprep_iscsi:
 636  * @in: input/ouput array with string to prepare.
 637  * @maxlen: maximum length of input/output array.
 638  *
 639  * Prepare the input UTF-8 string according to the draft iSCSI
 640  * stringprep profile.  Returns 0 iff successful, or an error code.
 641  **/
 642
 643 /**
 644  * stringprep_plain:
 645  * @in: input/ouput array with string to prepare.
 646  * @maxlen: maximum length of input/output array.
 647  *
 648  * Prepare the input UTF-8 string according to the draft SASL
 649  * ANONYMOUS profile.  Returns 0 iff successful, or an error code.
 650  **/
 651
 652 /**
 653  * stringprep_xmpp_nodeprep:
 654  * @in: input/ouput array with string to prepare.
 655  * @maxlen: maximum length of input/output array.
 656  *
 657  * Prepare the input UTF-8 string according to the draft XMPP node
 658  * identifier profile.  Returns 0 iff successful, or an error code.
 659  **/
 660
 661 /**
 662  * stringprep_xmpp_resourceprep:
 663  * @in: input/ouput array with string to prepare.
 664  * @maxlen: maximum length of input/output array.
 665  *
 666  * Prepare the input UTF-8 string according to the draft XMPP resource
 667  * identifier profile.  Returns 0 iff successful, or an error code.
 668  **/