tests/tst_stringprep.c

   1 /* tst_stringprep.c     Self tests for stringprep().
   2  * Copyright (C) 2002, 2003  Simon Josefsson
   3  *
   4  * This file is part of GNU Libidn.
   5  *
   6  * GNU Libidn is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (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
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GNU Libidn; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #if HAVE_CONFIG_H
  23 # include "config.h"
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30
  31 #include <stringprep.h>
  32
  33 static int debug = 0;
  34 static int error_count = 0;
  35 static int break_on_error = 0;
  36
  37 static void
  38 fail (const char *format, ...)
  39 {
  40   va_list arg_ptr;
  41
  42   va_start (arg_ptr, format);
  43   vfprintf (stderr, format, arg_ptr);
  44   va_end (arg_ptr);
  45   error_count++;
  46   if (break_on_error)
  47     exit (1);
  48 }
  49
  50 static void
  51 escapeprint (char *str, int len)
  52 {
  53   int i;
  54
  55   printf (" (length %d bytes):\n\t", len);
  56   for (i = 0; i < len; i++)
  57     {
  58       if (((str[i] & 0xFF) >= 'A' && (str[i] & 0xFF) <= 'Z') ||
  59           ((str[i] & 0xFF) >= 'a' && (str[i] & 0xFF) <= 'z') ||
  60           ((str[i] & 0xFF) >= '0' && (str[i] & 0xFF) <= '9')
  61           || (str[i] & 0xFF) == ' ' || (str[i] & 0xFF) == '.')
  62         printf ("%c", (str[i] & 0xFF));
  63       else
  64         printf ("\\x%02X", (str[i] & 0xFF));
  65       if ((i + 1) % 16 == 0 && (i + 1) < len)
  66         printf ("'\n\t'");
  67     }
  68   printf ("\n");
  69 }
  70
  71 static void
  72 hexprint (char *str, int len)
  73 {
  74   int i;
  75
  76   printf ("\t;; ");
  77   for (i = 0; i < len; i++)
  78     {
  79       printf ("%02x ", (str[i] & 0xFF));
  80       if ((i + 1) % 8 == 0)
  81         printf (" ");
  82       if ((i + 1) % 16 == 0 && i + 1 < len)
  83         printf ("\n\t;; ");
  84     }
  85   printf ("\n");
  86 }
  87
  88 static void
  89 binprint (char *str, int len)
  90 {
  91   int i;
  92
  93   printf ("\t;; ");
  94   for (i = 0; i < len; i++)
  95     {
  96       printf ("%d%d%d%d%d%d%d%d ",
  97               (str[i] & 0xFF) & 0x80 ? 1 : 0,
  98               (str[i] & 0xFF) & 0x40 ? 1 : 0,
  99               (str[i] & 0xFF) & 0x20 ? 1 : 0,
 100               (str[i] & 0xFF) & 0x10 ? 1 : 0,
 101               (str[i] & 0xFF) & 0x08 ? 1 : 0,
 102               (str[i] & 0xFF) & 0x04 ? 1 : 0,
 103               (str[i] & 0xFF) & 0x02 ? 1 : 0, (str[i] & 0xFF) & 0x01 ? 1 : 0);
 104       if ((i + 1) % 3 == 0)
 105         printf (" ");
 106       if ((i + 1) % 6 == 0 && i + 1 < len)
 107         printf ("\n\t;; ");
 108     }
 109   printf ("\n");
 110 }
 111
 112 struct stringprep
 113 {
 114   char *comment;
 115   char *in;
 116   char *out;
 117   char *profile;
 118   int flags;
 119   int rc;
 120 };
 121
 122 const struct stringprep strprep[] = {
 123   {"Map to nothing",
 124    "foo\xC2\xAD\xCD\x8F\xE1\xA0\x86\xE1\xA0\x8B"
 125    "bar" "\xE2\x80\x8B\xE2\x81\xA0" "baz\xEF\xB8\x80\xEF\xB8\x88"
 126    "\xEF\xB8\x8F\xEF\xBB\xBF", "foobarbaz"},
 127   {"Case folding ASCII U+0043 U+0041 U+0046 U+0045", "CAFE", "cafe"},
 128   {"Case folding 8bit U+00DF (german sharp s)", "\xC3\x9F", "ss"},
 129   {"Case folding U+0130 (turkish capital I with dot)",
 130    "\xC4\xB0", "i\xcc\x87"},
 131   {"Case folding multibyte U+0143 U+037A",
 132    "\xC5\x83\xCD\xBA", "\xC5\x84 \xCE\xB9"},
 133   {"Case folding U+2121 U+33C6 U+1D7BB",
 134    "\xE2\x84\xA1\xE3\x8F\x86\xF0\x9D\x9E\xBB",
 135    "telc\xE2\x88\x95" "kg\xCF\x83"},
 136   {"Normalization of U+006a U+030c U+00A0 U+00AA",
 137    "\x6A\xCC\x8C\xC2\xA0\xC2\xAA", "\xC7\xB0 a"},
 138   {"Case folding U+1FB7 and normalization",
 139    "\xE1\xBE\xB7", "\xE1\xBE\xB6\xCE\xB9"},
 140   {"Self-reverting case folding U+01F0 and normalization",
 141    "\xC7\xB0", "\xC7\xB0"},
 142   {"Self-reverting case folding U+0390 and normalization",
 143    "\xCE\x90", "\xCE\x90"},
 144   {"Self-reverting case folding U+03B0 and normalization",
 145    "\xCE\xB0", "\xCE\xB0"},
 146   {"Self-reverting case folding U+1E96 and normalization",
 147    "\xE1\xBA\x96", "\xE1\xBA\x96"},
 148   {"Self-reverting case folding U+1F56 and normalization",
 149    "\xE1\xBD\x96", "\xE1\xBD\x96"},
 150   {"ASCII space character U+0020", "\x20", "\x20"},
 151   {"Non-ASCII 8bit space character U+00A0", "\xC2\xA0", "\x20"},
 152   {"Non-ASCII multibyte space character U+1680",
 153    "\xE1\x9A\x80", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 154   {"Non-ASCII multibyte space character U+2000", "\xE2\x80\x80", "\x20"},
 155   {"Zero Width Space U+200b", "\xE2\x80\x8b", ""},
 156   {"Non-ASCII multibyte space character U+3000", "\xE3\x80\x80", "\x20"},
 157   {"ASCII control characters U+0010 U+007F", "\x10\x7F", "\x10\x7F"},
 158   {"Non-ASCII 8bit control character U+0085",
 159    "\xC2\x85", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 160   {"Non-ASCII multibyte control character U+180E",
 161    "\xE1\xA0\x8E", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 162   {"Zero Width No-Break Space U+FEFF", "\xEF\xBB\xBF", ""},
 163   {"Non-ASCII control character U+1D175",
 164    "\xF0\x9D\x85\xB5", NULL, "Nameprep", 0,
 165    STRINGPREP_CONTAINS_PROHIBITED},
 166   {"Plane 0 private use character U+F123",
 167    "\xEF\x84\xA3", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 168   {"Plane 15 private use character U+F1234",
 169    "\xF3\xB1\x88\xB4", NULL, "Nameprep", 0,
 170    STRINGPREP_CONTAINS_PROHIBITED},
 171   {"Plane 16 private use character U+10F234",
 172    "\xF4\x8F\x88\xB4", NULL, "Nameprep", 0,
 173    STRINGPREP_CONTAINS_PROHIBITED},
 174   {"Non-character code point U+8FFFE",
 175    "\xF2\x8F\xBF\xBE", NULL, "Nameprep", 0,
 176    STRINGPREP_CONTAINS_PROHIBITED},
 177   {"Non-character code point U+10FFFF",
 178    "\xF4\x8F\xBF\xBF", NULL, "Nameprep", 0,
 179    STRINGPREP_CONTAINS_PROHIBITED},
 180   {"Surrogate code U+DF42",
 181    "\xED\xBD\x82", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 182   {"Non-plain text character U+FFFD",
 183    "\xEF\xBF\xBD", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 184   {"Ideographic description character U+2FF5",
 185    "\xE2\xBF\xB5", NULL, "Nameprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 186   {"Display property character U+0341", "\xCD\x81", "\xCC\x81"},
 187   {"Left-to-right mark U+200E",
 188    "\xE2\x80\x8E", "\xCC\x81", "Nameprep", 0,
 189    STRINGPREP_CONTAINS_PROHIBITED},
 190   {"Deprecated U+202A", "\xE2\x80\xAA", "\xCC\x81", "Nameprep", 0,
 191    STRINGPREP_CONTAINS_PROHIBITED},
 192   {"Language tagging character U+E0001",
 193    "\xF3\xA0\x80\x81", "\xCC\x81", "Nameprep", 0,
 194    STRINGPREP_CONTAINS_PROHIBITED},
 195   {"Language tagging character U+E0042",
 196    "\xF3\xA0\x81\x82", NULL, "Nameprep", 0,
 197    STRINGPREP_CONTAINS_PROHIBITED},
 198   {"Bidi: RandALCat character U+05BE and LCat characters",
 199    "foo\xD6\xBE" "bar", NULL, "Nameprep", 0,
 200    STRINGPREP_BIDI_BOTH_L_AND_RAL},
 201   {"Bidi: RandALCat character U+FD50 and LCat characters",
 202    "foo\xEF\xB5\x90" "bar", NULL, "Nameprep", 0,
 203    STRINGPREP_BIDI_BOTH_L_AND_RAL},
 204   {"Bidi: RandALCat character U+FB38 and LCat characters",
 205    "foo\xEF\xB9\xB6" "bar", "foo \xd9\x8e" "bar"},
 206   {"Bidi: RandALCat without trailing RandALCat U+0627 U+0031",
 207    "\xD8\xA7\x31", NULL, "Nameprep", 0, STRINGPREP_BIDI_LEADTRAIL_NOT_RAL},
 208   {"Bidi: RandALCat character U+0627 U+0031 U+0628",
 209    "\xD8\xA7\x31\xD8\xA8", "\xD8\xA7\x31\xD8\xA8"},
 210   {"Unassigned code point U+E0002",
 211    "\xF3\xA0\x80\x82", NULL, "Nameprep", STRINGPREP_NO_UNASSIGNED,
 212    STRINGPREP_CONTAINS_UNASSIGNED},
 213   {"Larger test (shrinking)",
 214    "X\xC2\xAD\xC3\x9F\xC4\xB0\xE2\x84\xA1\x6a\xcc\x8c\xc2\xa0\xc2"
 215    "\xaa\xce\xb0\xe2\x80\x80", "xssi\xcc\x87" "tel\xc7\xb0 a\xce\xb0 ",
 216    "Nameprep"},
 217   {"Larger test (expanding)",
 218    "X\xC3\x9F\xe3\x8c\x96\xC4\xB0\xE2\x84\xA1\xE2\x92\x9F\xE3\x8c\x80",
 219    "xss\xe3\x82\xad\xe3\x83\xad\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\x88"
 220    "\xe3\x83\xab" "i\xcc\x87" "tel\x28" "d\x29\xe3\x82\xa2\xe3\x83\x91"
 221    "\xe3\x83\xbc\xe3\x83\x88"},
 222   {"Test of prohibited ASCII character U+0020",
 223    "\x20", NULL, "Nodeprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 224   {"Test of NFKC U+00A0 and prohibited character U+0020",
 225    "\xC2\xA0", NULL, "Nodeprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 226   {"Case map + normalization", "\xC2\xB5", "\xCE\xBC", "Nameprep"},
 227   /* The rest are rather non-interesting, but no point in removing
 228      working test cases... */
 229   {"case_nonfkc", "\xC2\xB5", "\xCE\xBC", "Nameprep", STRINGPREP_NO_NFKC,
 230    STRINGPREP_FLAG_ERROR},
 231   {"NFKC test", "\xC2\xAA", "\x61", "Nameprep"},
 232   {"nameprep, exposed a bug in libstringprep 0.0.5",
 233    "\xC2\xAA\x0A", "\x61\x0A"},
 234   {"unassigned code point U+0221", "\xC8\xA1", "\xC8\xA1", "Nameprep"},
 235   {"Unassigned code point U+0221",
 236    "\xC8\xA1", NULL, "Nameprep", STRINGPREP_NO_UNASSIGNED,
 237    STRINGPREP_CONTAINS_UNASSIGNED},
 238   {"Unassigned code point U+0236", "\xC8\xB6", "\xC8\xB6", "Nameprep"},
 239   {"unassigned code point U+0236",
 240    "\xC8\xB6", NULL, "Nameprep", STRINGPREP_NO_UNASSIGNED,
 241    STRINGPREP_CONTAINS_UNASSIGNED},
 242   {"bidi both RandALCat and LCat  U+0627 U+00AA U+0628",
 243    "\xD8\xA7\xC2\xAA\xD8\xA8", NULL, "Nameprep", 0,
 244    STRINGPREP_BIDI_BOTH_L_AND_RAL},
 245   {"XMPP node profile prohibited output",
 246    "foo@bar", NULL, "Nodeprep", 0, STRINGPREP_CONTAINS_PROHIBITED},
 247   {"XMPP resource profile on same string should work though",
 248    "foo@bar", "foo@bar", "Resourceprep"},
 249   {"SASL ANONYMOUS plain mechanism",
 250    "simon@josefsson.org", "simon@josefsson.org", "plain"},
 251   {"iSCSI profile", "Example-Name", "example-name", "ISCSIprep"},
 252   {"SASL profile", "Example\xC2\xA0" "Name", "Example Name", "SASLprep"}
 253 };
 254
 255 int
 256 main (int argc, char *argv[])
 257 {
 258   char *p;
 259   int rc;
 260   size_t i;
 261
 262   if (!stringprep_check_version (STRINGPREP_VERSION))
 263     fail ("stringprep_check_version() failed\n");
 264
 265   do
 266     if (strcmp (argv[argc - 1], "-v") == 0 ||
 267         strcmp (argv[argc - 1], "--verbose") == 0)
 268       debug = 1;
 269     else if (strcmp (argv[argc - 1], "-b") == 0 ||
 270              strcmp (argv[argc - 1], "--break-on-error") == 0)
 271       break_on_error = 1;
 272     else if (strcmp (argv[argc - 1], "-h") == 0 ||
 273              strcmp (argv[argc - 1], "-?") == 0 ||
 274              strcmp (argv[argc - 1], "--help") == 0)
 275       {
 276         printf ("Usage: %s [-vbh?] [--verbose] [--break-on-error] [--help]\n",
 277                 argv[0]);
 278         return 1;
 279       }
 280   while (argc-- > 1);
 281
 282   for (i = 0; i < sizeof (strprep) / sizeof (strprep[0]); i++)
 283     {
 284       if (debug)
 285         printf ("STRINGPREP entry %d\n", i);
 286
 287       if (debug)
 288         {
 289           printf ("flags: %d\n", strprep[i].flags);
 290
 291           printf ("in: ");
 292           escapeprint (strprep[i].in, strlen (strprep[i].in));
 293           hexprint (strprep[i].in, strlen (strprep[i].in));
 294           binprint (strprep[i].in, strlen (strprep[i].in));
 295         }
 296
 297       {
 298         uint32_t *l;
 299         char *x;
 300         l = stringprep_utf8_to_ucs4 (strprep[i].in, -1, NULL);
 301         x = stringprep_ucs4_to_utf8 (l, -1, NULL, NULL);
 302         free (l);
 303
 304         if (strcmp (strprep[i].in, x) != 0)
 305           {
 306             fail ("bad UTF-8 in entry %d\n", i);
 307             if (debug)
 308               {
 309                 puts ("expected:");
 310                 escapeprint (strprep[i].in, strlen (strprep[i].in));
 311                 hexprint (strprep[i].in, strlen (strprep[i].in));
 312                 puts ("computed:");
 313                 escapeprint (x, strlen (x));
 314                 hexprint (x, strlen (x));
 315               }
 316           }
 317
 318         free (x);
 319       }
 320       rc = stringprep_profile (strprep[i].in, &p,
 321                                strprep[i].profile ?
 322                                strprep[i].profile :
 323                                "Nameprep", strprep[i].flags);
 324       if (rc != strprep[i].rc)
 325         {
 326           fail ("stringprep() entry %d failed: %d\n", i, rc);
 327           if (debug)
 328             printf ("FATAL\n");
 329           if (rc == STRINGPREP_OK)
 330             free (p);
 331           continue;
 332         }
 333
 334       if (debug && rc == STRINGPREP_OK)
 335         {
 336           printf ("out: ");
 337           escapeprint (p, strlen (p));
 338           hexprint (p, strlen (p));
 339           binprint (p, strlen (p));
 340
 341           printf ("expected out: ");
 342           escapeprint (strprep[i].out, strlen (strprep[i].out));
 343           hexprint (strprep[i].out, strlen (strprep[i].out));
 344           binprint (strprep[i].out, strlen (strprep[i].out));
 345         }
 346       else if (debug)
 347         printf ("returned %d expected %d\n", rc, strprep[i].rc);
 348
 349       if (rc == STRINGPREP_OK)
 350         {
 351           if (strlen (strprep[i].out) != strlen (p) ||
 352               memcmp (strprep[i].out, p, strlen (p)) != 0)
 353             {
 354               fail ("stringprep() entry %d failed\n", i);
 355               if (debug)
 356                 printf ("ERROR\n");
 357             }
 358           else if (debug)
 359             printf ("OK\n\n");
 360
 361           free (p);
 362         }
 363       else if (debug)
 364         printf ("OK\n\n");
 365     }
 366
 367 #if 0
 368   {
 369     char p[20];
 370     memset (p, 0, 10);
 371     stringprep_unichar_to_utf8 (0x00DF, p);
 372     hexprint (p, strlen (p));
 373     puts ("");
 374   }
 375 #endif
 376
 377   if (debug)
 378     printf ("Stringprep self tests done with %d errors\n", error_count);
 379
 380   return error_count ? 1 : 0;
 381 }