stringprep

STRINGPREP_VERSION

#define STRINGPREP_VERSION "0.5.2"

String defined via CPP denoting the header file version number. Used together with stringprep_check_version() to verify header file and run-time library consistency.

enum Stringprep_rc

  typedef enum
  {
    STRINGPREP_OK = 0,
    /* Stringprep errors. */
    STRINGPREP_CONTAINS_UNASSIGNED = 1,
    STRINGPREP_CONTAINS_PROHIBITED = 2,
    STRINGPREP_BIDI_BOTH_L_AND_RAL = 3,
    STRINGPREP_BIDI_LEADTRAIL_NOT_RAL = 4,
    STRINGPREP_BIDI_CONTAINS_PROHIBITED = 5,
    /* Error in calling application. */
    STRINGPREP_TOO_SMALL_BUFFER = 100,
    STRINGPREP_PROFILE_ERROR = 101,
    STRINGPREP_FLAG_ERROR = 102,
    STRINGPREP_UNKNOWN_PROFILE = 103,
    /* Internal errors. */
    STRINGPREP_NFKC_FAILED = 200,
    STRINGPREP_MALLOC_ERROR = 201
  } Stringprep_rc;

Enumerated return codes of stringprep(), stringprep_profile() functions (and macros using those functions). The value 0 is guaranteed to always correspond to success.

enum Stringprep_profile_flags

  typedef enum
  {
    STRINGPREP_NO_NFKC = 1,
    STRINGPREP_NO_BIDI = 2,
    STRINGPREP_NO_UNASSIGNED = 4
  } Stringprep_profile_flags;

Stringprep profile flags.

enum Stringprep_profile_steps

  typedef enum
  {
    STRINGPREP_NFKC = 1,
    STRINGPREP_BIDI = 2,
    STRINGPREP_MAP_TABLE = 3,
    STRINGPREP_UNASSIGNED_TABLE = 4,
    STRINGPREP_PROHIBIT_TABLE = 5,
    STRINGPREP_BIDI_PROHIBIT_TABLE = 6,
    STRINGPREP_BIDI_RAL_TABLE = 7,
    STRINGPREP_BIDI_L_TABLE = 8
  } Stringprep_profile_steps;

Various steps in the stringprep algorithm. You really want to study the source code to understand this one. Only useful if you want to add another profile.

STRINGPREP_MAX_MAP_CHARS

#define STRINGPREP_MAX_MAP_CHARS 4

Maximum number of code points that can replace a single code point, during stringprep mapping.

stringprep_nameprep()

#define     stringprep_nameprep(in, maxlen)

Prepare the input UTF-8 string according to the nameprep profile. The AllowUnassigned flag is true, use stringprep_nameprep_no_unassigned() if you want a false AllowUnassigned. Returns 0 iff successful, or an error code.

stringprep_nameprep_no_unassigned()

#define     stringprep_nameprep_no_unassigned(in, maxlen)

Prepare the input UTF-8 string according to the nameprep profile. The AllowUnassigned flag is false, use stringprep_nameprep() for true AllowUnassigned. Returns 0 iff successful, or an error code.

stringprep_plain()

#define     stringprep_plain(in, maxlen)

Prepare the input UTF-8 string according to the draft SASL ANONYMOUS profile. Returns 0 iff successful, or an error code.

stringprep_kerberos5()

#define     stringprep_kerberos5(in, maxlen)

stringprep_xmpp_nodeprep()

#define     stringprep_xmpp_nodeprep(in, maxlen)

Prepare the input UTF-8 string according to the draft XMPP node identifier profile. Returns 0 iff successful, or an error code.

stringprep_xmpp_resourceprep()

#define     stringprep_xmpp_resourceprep(in, maxlen)

Prepare the input UTF-8 string according to the draft XMPP resource identifier profile. Returns 0 iff successful, or an error code.

stringprep_iscsi()

#define     stringprep_iscsi(in, maxlen)

Prepare the input UTF-8 string according to the draft iSCSI stringprep profile. Returns 0 iff successful, or an error code.

stringprep_4i ()

int         stringprep_4i                   (uint32_t *ucs4,
                                             size_t *len,
                                             size_t maxucs4len,
                                             Stringprep_profile_flags flags,
                                             const Stringprep_profile *profile);

Prepare the input UCS-4 string according to the stringprep profile, and write back the result to the input string.

The input is not required to be zero terminated (ucs4[len] = 0). The output will not be zero terminated unless ucs4[len] = 0. Instead, see stringprep_4zi() if your input is zero terminated or if you want the output to be.

Since the stringprep operation can expand the string, maxucs4len indicate how large the buffer holding the string is. This function will not read or write to code points outside that size.

The flags are one of Stringprep_profile_flags, or 0.

The profile contain the instructions to perform. Your application can define new profiles, possibly re-using the generic stringprep tables that always will be part of the library, or use one of the currently supported profiles.

stringprep_4zi ()

int         stringprep_4zi                  (uint32_t *ucs4,
                                             size_t maxucs4len,
                                             Stringprep_profile_flags flags,
                                             const Stringprep_profile *profile);

Prepare the input zero terminated UCS-4 string according to the stringprep profile, and write back the result to the input string.

Since the stringprep operation can expand the string, maxucs4len indicate how large the buffer holding the string is. This function will not read or write to code points outside that size.

The flags are one of Stringprep_profile_flags, or 0.

The profile contain the instructions to perform. Your application can define new profiles, possibly re-using the generic stringprep tables that always will be part of the library, or use one of the currently supported profiles.

stringprep ()

int         stringprep                      (char *in,
                                             size_t maxlen,
                                             Stringprep_profile_flags flags,
                                             const Stringprep_profile *profile);

Prepare the input zero terminated UTF-8 string according to the stringprep profile, and write back the result to the input string.

Note that you must convert strings entered in the systems locale into UTF-8 before using this function, see stringprep_locale_to_utf8().

Since the stringprep operation can expand the string, maxlen indicate how large the buffer holding the string is. This function will not read or write to characters outside that size.

The flags are one of Stringprep_profile_flags, or 0.

The profile contain the instructions to perform. Your application can define new profiles, possibly re-using the generic stringprep tables that always will be part of the library, or use one of the currently supported profiles.

stringprep_profile ()

int         stringprep_profile              (const char *in,
                                             char **out,
                                             const char *profile,
                                             Stringprep_profile_flags flags);

Prepare the input zero terminated UTF-8 string according to the stringprep profile, and return the result in a newly allocated variable.

Note that you must convert strings entered in the systems locale into UTF-8 before using this function, see stringprep_locale_to_utf8().

The output out variable must be deallocated by the caller.

The flags are one of Stringprep_profile_flags, or 0.

The profile specifies the name of the stringprep profile to use. It must be one of the internally supported stringprep profiles.

stringprep_check_version ()

const char* stringprep_check_version        (const char *req_version);

Check that the the version of the library is at minimum the requested one and return the version string; return NULL if the condition is not satisfied. If a NULL is passed to this function, no check is done, but the version string is simply returned.

See STRINGPREP_VERSION for a suitable req_version string.

stringprep_unichar_to_utf8 ()

int         stringprep_unichar_to_utf8      (uint32_t c,
                                             char *outbuf);

Converts a single character to UTF-8.

stringprep_utf8_to_unichar ()

uint32_t    stringprep_utf8_to_unichar      (const char *p);

Converts a sequence of bytes encoded as UTF-8 to a Unicode character. If p does not point to a valid UTF-8 encoded character, results are undefined.

stringprep_utf8_to_ucs4 ()

uint32_t*   stringprep_utf8_to_ucs4         (const char *str,
                                             ssize_t len,
                                             size_t *items_written);

Convert a string from UTF-8 to a 32-bit fixed width representation as UCS-4, assuming valid UTF-8 input. This function does no error checking on the input.

stringprep_ucs4_to_utf8 ()

char*       stringprep_ucs4_to_utf8         (const uint32_t *str,
                                             ssize_t len,
                                             size_t *items_read,
                                             size_t *items_written);

Convert a string from a 32-bit fixed width representation as UCS-4. to UTF-8. The result will be terminated with a 0 byte.

stringprep_utf8_nfkc_normalize ()

char*       stringprep_utf8_nfkc_normalize  (const char *str,
                                             ssize_t len);

Converts a string into canonical form, standardizing such issues as whether a character with an accent is represented as a base character and combining accent or as a single precomposed character.

The normalization mode is NFKC (ALL COMPOSE). It standardizes differences that do not affect the text content, such as the above-mentioned accent representation. It standardizes the "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to the standard forms (in this case DIGIT THREE). Formatting information may be lost but for most text operations such characters should be considered the same. It returns a result with composed forms rather than a maximally decomposed form.

stringprep_ucs4_nfkc_normalize ()

uint32_t*   stringprep_ucs4_nfkc_normalize  (uint32_t *str,
                                             ssize_t len);

Converts UCS4 string into UTF-8 and runs stringprep_utf8_nfkc_normalize().

stringprep_locale_charset ()

const char* stringprep_locale_charset       (void);

Find out current locale charset. The function respect the CHARSET environment variable, but typically uses nl_langinfo(CODESET) when it is supported. It fall back on "ASCII" if CHARSET isn't set and nl_langinfo isn't supported or return anything.

Note that this function return the application's locale's preferred charset (or thread's locale's preffered charset, if your system support thread-specific locales). It does not return what the system may be using. Thus, if you receive data from external sources you cannot in general use this function to guess what charset it is encoded in. Use stringprep_convert from the external representation into the charset returned by this function, to have data in the locale encoding.

stringprep_convert ()

char*       stringprep_convert              (const char *str,
                                             const char *to_codeset,
                                             const char *from_codeset);

Convert the string from one character set to another using the system's iconv() function.

stringprep_locale_to_utf8 ()

char*       stringprep_locale_to_utf8       (const char *str);

Convert string encoded in the locale's character set into UTF-8 by using stringprep_convert().

stringprep_utf8_to_locale ()

char*       stringprep_utf8_to_locale       (const char *str);

Convert string encoded in UTF-8 into the locale's character set by using stringprep_convert().