1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
3 /* GLIB - Library of useful routines for C programming
4 * Copyright (C) 2008 Red Hat, Inc.
6 * This library 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 of the License, or (at your option) any later version.
11 * This library 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.
16 * You should have received a copy of the GNU Lesser General
17 * Public License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19 * Boston, MA 02111-1307, USA.
26 #include "ghostutils.h"
31 #include "gstrfuncs.h"
37 * @short_description: Internet hostname utilities
39 * Functions for manipulating internet hostnames; in particular, for
40 * converting between Unicode and ASCII-encoded forms of
41 * Internationalized Domain Names (IDNs).
44 * url="http://www.ietf.org/rfc/rfc3490.txt">Internationalized Domain
45 * Names for Applications (IDNA)</ulink> standards allow for the use
46 * of Unicode domain names in applications, while providing
47 * backward-compatibility with the old ASCII-only DNS, by defining an
48 * ASCII-Compatible Encoding of any given Unicode name, which can be
49 * used with non-IDN-aware applications and protocols. (For example,
50 * "Παν語.org" maps to "xn--4wa8awb4637h.org".)
53 #define IDNA_ACE_PREFIX "xn--"
54 #define IDNA_ACE_PREFIX_LEN 4
56 /* Punycode constants, from RFC 3492. */
58 #define PUNYCODE_BASE 36
59 #define PUNYCODE_TMIN 1
60 #define PUNYCODE_TMAX 26
61 #define PUNYCODE_SKEW 38
62 #define PUNYCODE_DAMP 700
63 #define PUNYCODE_INITIAL_BIAS 72
64 #define PUNYCODE_INITIAL_N 0x80
66 #define PUNYCODE_IS_BASIC(cp) ((guint)(cp) < 0x80)
68 /* Encode/decode a single base-36 digit */
70 encode_digit (guint dig)
75 return dig - 26 + '0';
79 decode_digit (gchar dig)
81 if (dig >= 'A' && dig <= 'Z')
83 else if (dig >= 'a' && dig <= 'z')
85 else if (dig >= '0' && dig <= '9')
86 return dig - '0' + 26;
91 /* Punycode bias adaptation algorithm, RFC 3492 section 6.1 */
99 delta = firsttime ? delta / PUNYCODE_DAMP : delta / 2;
100 delta += delta / numpoints;
103 while (delta > ((PUNYCODE_BASE - PUNYCODE_TMIN) * PUNYCODE_TMAX) / 2)
105 delta /= PUNYCODE_BASE - PUNYCODE_TMIN;
109 return k + ((PUNYCODE_BASE - PUNYCODE_TMIN + 1) * delta /
110 (delta + PUNYCODE_SKEW));
113 /* Punycode encoder, RFC 3492 section 6.3. The algorithm is
114 * sufficiently bizarre that it's not really worth trying to explain
118 punycode_encode (const gchar *input_utf8,
119 gsize input_utf8_length,
122 guint delta, handled_chars, num_basic_chars, bias, j, q, k, t, digit;
123 gunichar n, m, *input;
125 gboolean success = FALSE;
127 /* Convert from UTF-8 to Unicode code points */
128 input = g_utf8_to_ucs4 (input_utf8, input_utf8_length, NULL,
129 &input_length, NULL);
133 /* Copy basic chars */
134 for (j = num_basic_chars = 0; j < input_length; j++)
136 if (PUNYCODE_IS_BASIC (input[j]))
138 g_string_append_c (output, g_ascii_tolower (input[j]));
143 g_string_append_c (output, '-');
145 handled_chars = num_basic_chars;
147 /* Encode non-basic chars */
149 bias = PUNYCODE_INITIAL_BIAS;
150 n = PUNYCODE_INITIAL_N;
151 while (handled_chars < input_length)
153 /* let m = the minimum {non-basic} code point >= n in the input */
154 for (m = G_MAXUINT, j = 0; j < input_length; j++)
156 if (input[j] >= n && input[j] < m)
160 if (m - n > (G_MAXUINT - delta) / (handled_chars + 1))
162 delta += (m - n) * (handled_chars + 1);
165 for (j = 0; j < input_length; j++)
172 else if (input[j] == n)
175 for (k = PUNYCODE_BASE; ; k += PUNYCODE_BASE)
179 else if (k >= bias + PUNYCODE_TMAX)
185 digit = t + (q - t) % (PUNYCODE_BASE - t);
186 g_string_append_c (output, encode_digit (digit));
187 q = (q - t) / (PUNYCODE_BASE - t);
190 g_string_append_c (output, encode_digit (q));
191 bias = adapt (delta, handled_chars + 1, handled_chars == num_basic_chars);
208 /* From RFC 3454, Table B.1 */
209 #define idna_is_junk(ch) ((ch) == 0x00AD || (ch) == 0x1806 || (ch) == 0x200B || (ch) == 0x2060 || (ch) == 0xFEFF || (ch) == 0x034F || (ch) == 0x180B || (ch) == 0x180C || (ch) == 0x180D || (ch) == 0x200C || (ch) == 0x200D || ((ch) >= 0xFE00 && (ch) <= 0xFE0F))
211 /* Scan @str for "junk" and return a cleaned-up string if any junk
212 * is found. Else return %NULL.
215 remove_junk (const gchar *str,
218 GString *cleaned = NULL;
222 for (p = str; len == -1 ? *p : p < str + len; p = g_utf8_next_char (p))
224 ch = g_utf8_get_char (p);
225 if (idna_is_junk (ch))
229 cleaned = g_string_new (NULL);
230 g_string_append_len (cleaned, str, p - str);
234 g_string_append_unichar (cleaned, ch);
238 return g_string_free (cleaned, FALSE);
243 static inline gboolean
244 contains_uppercase_letters (const gchar *str,
249 for (p = str; len == -1 ? *p : p < str + len; p = g_utf8_next_char (p))
251 if (g_unichar_isupper (g_utf8_get_char (p)))
257 static inline gboolean
258 contains_non_ascii (const gchar *str,
263 for (p = str; len == -1 ? *p : p < str + len; p++)
265 if ((guchar)*p > 0x80)
271 /* RFC 3454, Appendix C. ish. */
272 static inline gboolean
273 idna_is_prohibited (gunichar ch)
275 switch (g_unichar_type (ch))
277 case G_UNICODE_CONTROL:
278 case G_UNICODE_FORMAT:
279 case G_UNICODE_UNASSIGNED:
280 case G_UNICODE_PRIVATE_USE:
281 case G_UNICODE_SURROGATE:
282 case G_UNICODE_LINE_SEPARATOR:
283 case G_UNICODE_PARAGRAPH_SEPARATOR:
284 case G_UNICODE_SPACE_SEPARATOR:
287 case G_UNICODE_OTHER_SYMBOL:
288 if (ch == 0xFFFC || ch == 0xFFFD ||
289 (ch >= 0x2FF0 && ch <= 0x2FFB))
293 case G_UNICODE_NON_SPACING_MARK:
294 if (ch == 0x0340 || ch == 0x0341)
303 /* RFC 3491 IDN cleanup algorithm. */
305 nameprep (const gchar *hostname,
308 gchar *name, *tmp = NULL, *p;
310 /* It would be nice if we could do this without repeatedly
311 * allocating strings and converting back and forth between
312 * gunichars and UTF-8... The code does at least avoid doing most of
313 * the sub-operations when they would just be equivalent to a
317 /* Remove presentation-only characters */
318 name = remove_junk (hostname, len);
325 name = (gchar *)hostname;
327 /* Convert to lowercase */
328 if (contains_uppercase_letters (name, len))
330 name = g_utf8_strdown (name, len);
336 /* If there are no UTF8 characters, we're done. */
337 if (!contains_non_ascii (name, len))
339 if (name == (gchar *)hostname)
340 return len == -1 ? g_strdup (hostname) : g_strndup (hostname, len);
346 name = g_utf8_normalize (name, len, G_NORMALIZE_NFKC);
353 /* KC normalization may have created more capital letters (eg,
354 * angstrom -> capital A with ring). So we have to lowercasify a
355 * second time. (This is more-or-less how the nameprep algorithm
356 * does it. If tolower(nfkc(tolower(X))) is guaranteed to be the
357 * same as tolower(nfkc(X)), then we could skip the first tolower,
358 * but I'm not sure it is.)
360 if (contains_uppercase_letters (name, -1))
362 name = g_utf8_strdown (name, -1);
367 /* Check for prohibited characters */
368 for (p = name; *p; p = g_utf8_next_char (p))
370 if (idna_is_prohibited (g_utf8_get_char (p)))
378 /* FIXME: We're supposed to verify certain constraints on bidi
379 * characters, but glib does not appear to have that information.
387 * g_hostname_to_ascii:
388 * @hostname: a valid UTF-8 or ASCII hostname
390 * Converts @hostname to its canonical ASCII form; an ASCII-only
391 * string containing no uppercase letters and not ending with a
394 * Return value: an ASCII hostname, which must be freed, or %NULL if
395 * @hostname is in some way invalid.
400 g_hostname_to_ascii (const gchar *hostname)
402 gchar *name, *label, *p;
407 label = name = nameprep (hostname, -1);
411 out = g_string_new (NULL);
416 for (p = label; *p && *p != '.'; p++)
418 if ((guchar)*p > 0x80)
426 if (!strncmp (label, IDNA_ACE_PREFIX, IDNA_ACE_PREFIX_LEN))
429 g_string_append (out, IDNA_ACE_PREFIX);
430 if (!punycode_encode (label, llen, out))
434 g_string_append_len (out, label, llen);
436 if (out->len - oldlen > 63)
440 if (*label && *++label)
441 g_string_append_c (out, '.');
446 return g_string_free (out, FALSE);
450 g_string_free (out, TRUE);
455 * g_hostname_is_non_ascii:
456 * @hostname: a hostname
458 * Tests if @hostname contains Unicode characters. If this returns
459 * %TRUE, you need to encode the hostname with g_hostname_to_ascii()
460 * before using it in non-IDN-aware contexts.
462 * Note that a hostname might contain a mix of encoded and unencoded
463 * segments, and so it is possible for g_hostname_is_non_ascii() and
464 * g_hostname_is_ascii_encoded() to both return %TRUE for a name.
466 * Return value: %TRUE if @hostname contains any non-ASCII characters
471 g_hostname_is_non_ascii (const gchar *hostname)
473 return contains_non_ascii (hostname, -1);
476 /* Punycode decoder, RFC 3492 section 6.2. As with punycode_encode(),
477 * read the RFC if you want to understand what this is actually doing.
480 punycode_decode (const gchar *input,
484 GArray *output_chars;
487 guint oldi, w, k, digit, t;
490 n = PUNYCODE_INITIAL_N;
492 bias = PUNYCODE_INITIAL_BIAS;
494 split = input + input_length - 1;
495 while (split > input && *split != '-')
499 output_chars = g_array_sized_new (FALSE, FALSE, sizeof (gunichar),
501 input_length -= (split - input) + 1;
502 while (input < split)
504 gunichar ch = (gunichar)*input++;
505 if (!PUNYCODE_IS_BASIC (ch))
507 g_array_append_val (output_chars, ch);
512 output_chars = g_array_new (FALSE, FALSE, sizeof (gunichar));
518 for (k = PUNYCODE_BASE; ; k += PUNYCODE_BASE)
522 digit = decode_digit (*input++);
523 if (digit >= PUNYCODE_BASE)
525 if (digit > (G_MAXUINT - i) / w)
530 else if (k >= bias + PUNYCODE_TMAX)
536 if (w > G_MAXUINT / (PUNYCODE_BASE - t))
538 w *= (PUNYCODE_BASE - t);
541 bias = adapt (i - oldi, output_chars->len + 1, oldi == 0);
543 if (i / (output_chars->len + 1) > G_MAXUINT - n)
545 n += i / (output_chars->len + 1);
546 i %= (output_chars->len + 1);
548 g_array_insert_val (output_chars, i++, n);
551 for (i = 0; i < output_chars->len; i++)
552 g_string_append_unichar (output, g_array_index (output_chars, gunichar, i));
553 g_array_free (output_chars, TRUE);
557 g_array_free (output_chars, TRUE);
562 * g_hostname_to_unicode:
563 * @hostname: a valid UTF-8 or ASCII hostname
565 * Converts @hostname to its canonical presentation form; a UTF-8
566 * string in Unicode normalization form C, containing no uppercase
567 * letters, no forbidden characters, and no ASCII-encoded segments,
568 * and not ending with a trailing dot.
570 * Of course if @hostname is not an internationalized hostname, then
571 * the canonical presentation form will be entirely ASCII.
573 * Return value: a UTF-8 hostname, which must be freed, or %NULL if
574 * @hostname is in some way invalid.
579 g_hostname_to_unicode (const gchar *hostname)
584 out = g_string_new (NULL);
588 llen = strcspn (hostname, ".");
589 if (!g_ascii_strncasecmp (hostname, IDNA_ACE_PREFIX, IDNA_ACE_PREFIX_LEN))
591 hostname += IDNA_ACE_PREFIX_LEN;
592 llen -= IDNA_ACE_PREFIX_LEN;
593 if (!punycode_decode (hostname, llen, out))
595 g_string_free (out, TRUE);
601 gchar *canonicalized = nameprep (hostname, llen);
605 g_string_free (out, TRUE);
608 g_string_append (out, canonicalized);
609 g_free (canonicalized);
613 if (*hostname && *++hostname)
614 g_string_append_c (out, '.');
618 return g_string_free (out, FALSE);
622 * g_hostname_is_ascii_encoded:
623 * @hostname: a hostname
625 * Tests if @hostname contains segments with an ASCII-compatible
626 * encoding of an Internationalized Domain Name. If this returns
627 * %TRUE, you should decode the hostname with g_hostname_to_unicode()
628 * before displaying it to the user.
630 * Note that a hostname might contain a mix of encoded and unencoded
631 * segments, and so it is possible for g_hostname_is_non_ascii() and
632 * g_hostname_is_ascii_encoded() to both return %TRUE for a name.
634 * Return value: %TRUE if @hostname contains any ASCII-encoded
640 g_hostname_is_ascii_encoded (const gchar *hostname)
644 if (!g_ascii_strncasecmp (hostname, IDNA_ACE_PREFIX, IDNA_ACE_PREFIX_LEN))
646 hostname = strchr (hostname, '.');
653 * g_hostname_is_ip_address:
654 * @hostname: a hostname (or IP address in string form)
656 * Tests if @hostname is the string form of an IPv4 or IPv6 address.
657 * (Eg, "192.168.0.1".)
659 * Return value: %TRUE if @hostname is an IP address
664 g_hostname_is_ip_address (const gchar *hostname)
667 gint nsegments, octet;
669 /* On Linux we could implement this using inet_pton, but the Windows
670 * equivalent of that requires linking against winsock, so we just
671 * figure this out ourselves. Tested by tests/hostutils.c.
674 p = (char *)hostname;
680 /* If it contains a ':', it's an IPv6 address (assuming it's an
681 * IP address at all). This consists of eight ':'-separated
682 * segments, each containing a 1-4 digit hex number, except that
683 * optionally: (a) the last two segments can be replaced by an
684 * IPv4 address, and (b) a single span of 1 to 8 "0000" segments
685 * can be replaced with just "::".
690 while (*p && nsegments < 8)
692 /* Each segment after the first must be preceded by a ':'.
693 * (We also handle half of the "string starts with ::" case
696 if (p != (char *)hostname || (p[0] == ':' && p[1] == ':'))
703 /* If there's another ':', it means we're skipping some segments */
704 if (*p == ':' && !skipped)
709 /* Handle the "string ends with ::" case */
716 /* Read the segment, make sure it's valid. */
717 for (end = p; g_ascii_isxdigit (*end); end++)
719 if (end == p || end > p + 4)
724 if ((nsegments == 6 && !skipped) || (nsegments <= 6 && skipped))
734 return !*p && (nsegments == 8 || skipped);
739 /* Parse IPv4: N.N.N.N, where each N <= 255 and doesn't have leading 0s. */
740 for (nsegments = 0; nsegments < 4; nsegments++)
749 /* Check the segment; a little tricker than the IPv6 case since
750 * we can't allow extra leading 0s, and we can't assume that all
751 * strings of valid length are within range.
758 for (end = p; g_ascii_isdigit (*end); end++)
759 octet = 10 * octet + (*end - '0');
761 if (end == p || end > p + 3 || octet > 255)
767 /* If there's nothing left to parse, then it's ok. */