csharp/Stringprep.cs

   1 /// <summary> Copyright (C) 2004  Free Software Foundation, Inc.
   2 /// *
   3 /// Author: Alexander Gnauck AG-Software
   4 /// *
   5 /// This file is part of GNU Libidn.
   6 /// *
   7 /// This library is free software; you can redistribute it and/or
   8 /// modify it under the terms of the GNU Lesser General Public License
   9 /// as published by the Free Software Foundation; either version 2.1 of
  10 /// the License, or (at your option) any later version.
  11 /// *
  12 /// This library is distributed in the hope that it will be useful, but
  13 /// WITHOUT ANY WARRANTY; without even the implied warranty of
  14 /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 /// Lesser General Public License for more details.
  16 /// *
  17 /// You should have received a copy of the GNU Lesser General Public
  18 /// License along with this library; if not, write to the Free Software
  19 /// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  20 /// USA
  21 /// </summary>
  22
  23 using System;
  24
  25 namespace gnu.inet.encoding
  26 {
  27         /// <summary> This class offers static methods for preparing internationalized
  28         /// strings. It supports the following stringprep profiles:
  29         /// <ul>
  30         /// <li>RFC3491 nameprep
  31         /// <li>RFC3920 XMPP nodeprep and resourceprep
  32         /// </ul>
  33         /// Note that this implementation only supports 16-bit Unicode code
  34         /// points.
  35         /// </summary>
  36         public class Stringprep
  37         {
  38                 /// <summary> Preps a name according to the Stringprep profile defined in
  39                 /// RFC3491. Unassigned code points are not allowed.
  40                 /// *
  41                 /// </summary>
  42                 /// <param name="input">the name to prep.
  43                 /// </param>
  44                 /// <returns> the prepped name.
  45                 /// @throws StringprepException If the name cannot be prepped with
  46                 /// this profile.
  47                 /// @throws NullPointerException If the name is null.
  48                 ///
  49                 /// </returns>
  50                 public static System.String nameprep(System.String input)
  51                 {
  52                         return nameprep(input, false);
  53                 }
  54
  55                 /// <summary> Preps a name according to the Stringprep profile defined in
  56                 /// RFC3491.
  57                 /// *
  58                 /// </summary>
  59                 /// <param name="input">the name to prep.
  60                 /// </param>
  61                 /// <param name="allowUnassigned">true if the name may contain unassigned
  62                 /// code points.
  63                 /// </param>
  64                 /// <returns> the prepped name.
  65                 /// @throws StringprepException If the name cannot be prepped with
  66                 /// this profile.
  67                 /// @throws NullPointerException If the name is null.
  68                 ///
  69                 /// </returns>
  70                 public static System.String nameprep(System.String input, bool allowUnassigned)
  71                 {
  72                         if (input == null)
  73                         {
  74                                 throw new System.NullReferenceException();
  75                         }
  76
  77                         System.Text.StringBuilder s = new System.Text.StringBuilder(input);
  78
  79                         if (!allowUnassigned && contains(s, RFC3454.A1))
  80                         {
  81                                 throw new StringprepException(StringprepException.CONTAINS_UNASSIGNED);
  82                         }
  83
  84                         filter(s, RFC3454.B1);
  85                         map(s, RFC3454.B2search, RFC3454.B2replace);
  86
  87                         s = new System.Text.StringBuilder(NFKC.normalizeNFKC(s.ToString()));
  88                         // B.3 is only needed if NFKC is not used, right?
  89                         // map(s, RFC3454.B3search, RFC3454.B3replace);
  90
  91                         if (contains(s, RFC3454.C12) || contains(s, RFC3454.C22) || contains(s, RFC3454.C3) || contains(s, RFC3454.C4) || contains(s, RFC3454.C5) || contains(s, RFC3454.C6) || contains(s, RFC3454.C7) || contains(s, RFC3454.C8))
  92                         {
  93                                 // Table C.9 only contains code points > 0xFFFF which Java
  94                                 // doesn't handle
  95                                 throw new StringprepException(StringprepException.CONTAINS_PROHIBITED);
  96                         }
  97
  98                         // Bidi handling
  99                         bool r = contains(s, RFC3454.D1);
 100                         bool l = contains(s, RFC3454.D2);
 101
 102                         // RFC 3454, section 6, requirement 1: already handled above (table C.8)
 103
 104                         // RFC 3454, section 6, requirement 2
 105                         if (r && l)
 106                         {
 107                                 throw new StringprepException(StringprepException.BIDI_BOTHRAL);
 108                         }
 109
 110                         // RFC 3454, section 6, requirement 3
 111                         if (r)
 112                         {
 113                                 if (!contains(s[0], RFC3454.D1) || !contains(s[s.Length - 1], RFC3454.D1))
 114                                 {
 115                                         throw new StringprepException(StringprepException.BIDI_LTRAL);
 116                                 }
 117                         }
 118
 119                         return s.ToString();
 120                 }
 121
 122                 /**
 123                 * Characters prohibited by RFC3920 nodeprep that aren't defined as
 124                 * part of the RFC3454 tables.
 125                 */
 126                 private static char [] RFC3920_NODEPREP_PROHIBIT = new char [] {
 127                                  '\u0022', '\u0026', '\'',     '\u002F',
 128                                  '\u003A', '\u003C', '\u003E', '\u0040'
 129                  };
 130
 131                 /// <summary> Preps a node name according to the Stringprep profile defined in
 132                 /// RFC3920. Unassigned code points are not allowed.
 133                 /// *
 134                 /// </summary>
 135                 /// <param name="input">the node name to prep.
 136                 /// </param>
 137                 /// <returns> the prepped node name.
 138                 /// @throws StringprepException If the node name cannot be prepped
 139                 /// with this profile.
 140                 /// @throws NullPointerException If the node name is null.
 141                 ///
 142                 /// </returns>
 143                 public static System.String nodeprep(System.String input)
 144                 {
 145                         return nodeprep(input, false);
 146                 }
 147
 148                 /// <summary> Preps a node name according to the Stringprep profile defined in
 149                 /// RFC3920.
 150                 /// *
 151                 /// </summary>
 152                 /// <param name="input">the node name to prep.
 153                 /// </param>
 154                 /// <param name="allowUnassigned">true if the node name may contain
 155                 /// unassigned code points.
 156                 /// </param>
 157                 /// <returns> the prepped node name.
 158                 /// @throws StringprepException If the node name cannot be prepped
 159                 /// with this profile.
 160                 /// @throws NullPointerException If the node name is null.
 161                 ///
 162                 /// </returns>
 163                 public static System.String nodeprep(System.String input, bool allowUnassigned)
 164                 {
 165                         if (input == null)
 166                         {
 167                                 throw new System.NullReferenceException();
 168                         }
 169
 170                         System.Text.StringBuilder s = new System.Text.StringBuilder(input);
 171
 172                         if (!allowUnassigned && contains(s, RFC3454.A1))
 173                         {
 174                                 throw new StringprepException(StringprepException.CONTAINS_UNASSIGNED);
 175                         }
 176
 177                         filter(s, RFC3454.B1);
 178                         map(s, RFC3454.B2search, RFC3454.B2replace);
 179
 180                         s = new System.Text.StringBuilder(NFKC.normalizeNFKC(s.ToString()));
 181
 182                         if (contains(s, RFC3454.C11) || contains(s, RFC3454.C12) || contains(s, RFC3454.C21) || contains(s, RFC3454.C22) || contains(s, RFC3454.C3) || contains(s, RFC3454.C4) || contains(s, RFC3454.C5) || contains(s, RFC3454.C6) || contains(s, RFC3454.C7) || contains(s, RFC3454.C8) || contains(s, RFC3920_NODEPREP_PROHIBIT))
 183                         {
 184                                 // Table C.9 only contains code points > 0xFFFF which Java
 185                                 // doesn't handle
 186                                 throw new StringprepException(StringprepException.CONTAINS_PROHIBITED);
 187                         }
 188
 189                         // Bidi handling
 190                         bool r = contains(s, RFC3454.D1);
 191                         bool l = contains(s, RFC3454.D2);
 192
 193                         // RFC 3454, section 6, requirement 1: already handled above (table C.8)
 194
 195                         // RFC 3454, section 6, requirement 2
 196                         if (r && l)
 197                         {
 198                                 throw new StringprepException(StringprepException.BIDI_BOTHRAL);
 199                         }
 200
 201                         // RFC 3454, section 6, requirement 3
 202                         if (r)
 203                         {
 204                                 if (!contains(s[0], RFC3454.D1) || !contains(s[s.Length - 1], RFC3454.D1))
 205                                 {
 206                                         throw new StringprepException(StringprepException.BIDI_LTRAL);
 207                                 }
 208                         }
 209
 210                         return s.ToString();
 211                 }
 212
 213                 /// <summary> Preps a resource name according to the Stringprep profile defined
 214                 /// in RFC3920. Unassigned code points are not allowed.
 215                 /// *
 216                 /// </summary>
 217                 /// <param name="input">the resource name to prep.
 218                 /// </param>
 219                 /// <returns> the prepped node name.
 220                 /// @throws StringprepException If the resource name cannot be prepped
 221                 /// with this profile.
 222                 /// @throws NullPointerException If the resource name is null.
 223                 ///
 224                 /// </returns>
 225                 public static System.String resourceprep(System.String input)
 226                 {
 227                         return resourceprep(input, false);
 228                 }
 229
 230                 /// <summary> Preps a resource name according to the Stringprep profile defined
 231                 /// in RFC3920.
 232                 /// *
 233                 /// </summary>
 234                 /// <param name="input">the resource name to prep.
 235                 /// </param>
 236                 /// <param name="allowUnassigned">true if the resource name may contain
 237                 /// unassigned code points.
 238                 /// </param>
 239                 /// <returns> the prepped node name.
 240                 /// @throws StringprepException If the resource name cannot be prepped
 241                 /// with this profile.
 242                 /// @throws NullPointerException If the resource name is null.
 243                 ///
 244                 /// </returns>
 245                 public static System.String resourceprep(System.String input, bool allowUnassigned)
 246                 {
 247                         if (input == null)
 248                         {
 249                                 throw new System.NullReferenceException();
 250                         }
 251
 252                         System.Text.StringBuilder s = new System.Text.StringBuilder(input);
 253
 254                         if (!allowUnassigned && contains(s, RFC3454.A1))
 255                         {
 256                                 throw new StringprepException(StringprepException.CONTAINS_UNASSIGNED);
 257                         }
 258
 259                         filter(s, RFC3454.B1);
 260
 261                         s = new System.Text.StringBuilder(NFKC.normalizeNFKC(s.ToString()));
 262
 263                         if (contains(s, RFC3454.C12) || contains(s, RFC3454.C21) || contains(s, RFC3454.C22) || contains(s, RFC3454.C3) || contains(s, RFC3454.C4) || contains(s, RFC3454.C5) || contains(s, RFC3454.C6) || contains(s, RFC3454.C7) || contains(s, RFC3454.C8))
 264                         {
 265                                 // Table C.9 only contains code points > 0xFFFF which Java
 266                                 // doesn't handle
 267                                 throw new StringprepException(StringprepException.CONTAINS_PROHIBITED);
 268                         }
 269
 270                         // Bidi handling
 271                         bool r = contains(s, RFC3454.D1);
 272                         bool l = contains(s, RFC3454.D2);
 273
 274                         // RFC 3454, section 6, requirement 1: already handled above (table C.8)
 275
 276                         // RFC 3454, section 6, requirement 2
 277                         if (r && l)
 278                         {
 279                                 throw new StringprepException(StringprepException.BIDI_BOTHRAL);
 280                         }
 281
 282                         // RFC 3454, section 6, requirement 3
 283                         if (r)
 284                         {
 285                                 if (!contains(s[0], RFC3454.D1) || !contains(s[s.Length - 1], RFC3454.D1))
 286                                 {
 287                                         throw new StringprepException(StringprepException.BIDI_LTRAL);
 288                                 }
 289                         }
 290
 291                         return s.ToString();
 292                 }
 293
 294                 internal static bool contains(System.Text.StringBuilder s, char[] p)
 295                 {
 296                         for (int i = 0; i < p.Length; i++)
 297                         {
 298                                 char c = p[i];
 299                                 for (int j = 0; j < s.Length; j++)
 300                                 {
 301                                         if (c == s[j])
 302                                         {
 303                                                 return true;
 304                                         }
 305                                 }
 306                         }
 307                         return false;
 308                 }
 309
 310                 internal static bool contains(System.Text.StringBuilder s, char[][] p)
 311                 {
 312                         for (int i = 0; i < p.Length; i++)
 313                         {
 314                                 char[] r = p[i];
 315                                 if (1 == r.Length)
 316                                 {
 317                                         char c = r[0];
 318                                         for (int j = 0; j < s.Length; j++)
 319                                         {
 320                                                 if (c == s[j])
 321                                                 {
 322                                                         return true;
 323                                                 }
 324                                         }
 325                                 }
 326                                 else if (2 == r.Length)
 327                                 {
 328                                         char f = r[0];
 329                                         char t = r[1];
 330                                         for (int j = 0; j < s.Length; j++)
 331                                         {
 332                                                 if (f <= s[j] && t >= s[j])
 333                                                 {
 334                                                         return true;
 335                                                 }
 336                                         }
 337                                 }
 338                         }
 339                         return false;
 340                 }
 341
 342                 internal static bool contains(char c, char[][] p)
 343                 {
 344                         for (int i = 0; i < p.Length; i++)
 345                         {
 346                                 char[] r = p[i];
 347                                 if (1 == r.Length)
 348                                 {
 349                                         if (c == r[0])
 350                                         {
 351                                                 return true;
 352                                         }
 353                                 }
 354                                 else if (2 == r.Length)
 355                                 {
 356                                         char f = r[0];
 357                                         char t = r[1];
 358                                         if (f <= c && t >= c)
 359                                         {
 360                                                 return true;
 361                                         }
 362                                 }
 363                         }
 364                         return false;
 365                 }
 366
 367                 internal static void  filter(System.Text.StringBuilder s, char[] f)
 368                 {
 369                         for (int i = 0; i < f.Length; i++)
 370                         {
 371                                 char c = f[i];
 372
 373                                 int j = 0;
 374                                 while (j < s.Length)
 375                                 {
 376                                         if (c == s[j])
 377                                         {
 378                                                 //s.deleteCharAt(j);
 379                                                 s.Remove(j, 1);
 380                                         }
 381                                         else
 382                                         {
 383                                                 j++;
 384                                         }
 385                                 }
 386                         }
 387                 }
 388
 389                 internal static void  filter(System.Text.StringBuilder s, char[][] f)
 390                 {
 391                         for (int i = 0; i < f.Length; i++)
 392                         {
 393                                 char[] r = f[i];
 394
 395                                 if (1 == r.Length)
 396                                 {
 397                                         char c = r[0];
 398
 399                                         int j = 0;
 400                                         while (j < s.Length)
 401                                         {
 402                                                 if (c == s[j])
 403                                                 {
 404                                                         //s.deleteCharAt(j);
 405                                                         s.Remove(j, 1);
 406                                                 }
 407                                                 else
 408                                                 {
 409                                                         j++;
 410                                                 }
 411                                         }
 412                                 }
 413                                 else if (2 == r.Length)
 414                                 {
 415                                         char from = r[0];
 416                                         char to = r[1];
 417
 418                                         int j = 0;
 419                                         while (j < s.Length)
 420                                         {
 421                                                 if (from <= s[j] && to >= s[j])
 422                                                 {
 423                                                         //s.deleteCharAt(j);
 424                                                         s.Remove(j, 1);
 425                                                 }
 426                                                 else
 427                                                 {
 428                                                         j++;
 429                                                 }
 430                                         }
 431                                 }
 432                         }
 433                 }
 434
 435                 internal static void map(System.Text.StringBuilder s, char[] search, System.String[] replace)
 436                 {
 437                         for (int i = 0; i < search.Length; i++)
 438                         {
 439                                 char c = search[i];
 440
 441                                 int j = 0;
 442                                 while (j < s.Length)
 443                                 {
 444                                         if (c == s[j])
 445                                         {
 446                                                 //s.deleteCharAt(j);
 447                                                 s.Remove(j, 1);
 448                                                 if (null != replace[i])
 449                                                 {
 450                                                         s.Insert(j, replace[i]);
 451                                                         j += replace[i].Length - 1;
 452                                                 }
 453                                         }
 454                                         else
 455                                         {
 456                                                 j++;
 457                                         }
 458                                 }
 459                         }
 460                 }
 461         }
 462 }