The Labs \ Source Viewer \ SSCLI \ System.Globalization \ IdnMapping

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //
  16. // This file contains the IDN functions and implementation.
  17. //
  18. // This allows encoding of non-ASCII domain names in a "punycode" form,
  19. // for example:
  20. //
  21. // \u5B89\u5BA4\u5948\u7F8E\u6075-with-SUPER-MONKEYS
  22. //
  23. // is encoded as:
  24. //
  25. // xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n
  26. //
  27. // Additional options are provided to allow unassigned IDN characters and
  28. // to validate according to the Std3ASCII Rules (like DNS names).
  29. //
  30. // There are also rules regarding bidirectionality of text and the length
  31. // of segments.
  32. //
  33. // For additional rules see also:
  34. // RFC 3490 - Internationalizing Domain Names in Applications (IDNA)
  35. // RFC 3491 - Nameprep: A Stringprep Profile for Internationalized Domain Names (IDN)
  36. // RFC 3492 - Punycode: A Bootstring encoding of Unicode for Internationalized Domain Names in Applications (IDNA)
  37. //
  38. // ==--==
  39. namespace System.Globalization
  40. {
  41.     using System;
  42.     using System.Globalization;
  43.     using System.Text;
  44.    
  45.     // IdnMapping class used to map names to Punycode
  46.    
  47.     public sealed class IdnMapping
  48.     {
  49.         // Legal name lengths for domain names
  50.         const int M_labelLimit = 63;
  51.         // Not including dots
  52.         const int M_defaultNameLimit = 255;
  53.         // Including dots
  54.         // IDNA prefix
  55.         const string M_strAcePrefix = "xn--";
  56.        
  57.         // Legal "dot" seperators (i.e: . in www.microsoft.com)
  58.         static char[] M_Dots = {'.', '。', '.', '。'};
  59.        
  60.         bool m_bAllowUnassigned;
  61.         bool m_bUseStd3AsciiRules;
  62.        
  63.         public IdnMapping()
  64.         {
  65.             this.m_bAllowUnassigned = false;
  66.             this.m_bUseStd3AsciiRules = false;
  67.         }
  68.        
  69.         public bool AllowUnassigned {
  70.             get { return this.m_bAllowUnassigned; }
  71.            
  72.             set { this.m_bAllowUnassigned = value; }
  73.         }
  74.        
  75.         public bool UseStd3AsciiRules {
  76.             get { return this.m_bUseStd3AsciiRules; }
  77.            
  78.             set { this.m_bUseStd3AsciiRules = value; }
  79.         }
  80.        
  81.         // Gets ASCII (Punycode) version of the string
  82.         public string GetAscii(string unicode)
  83.         {
  84.             return GetAscii(unicode, 0);
  85.         }
  86.        
  87.         public string GetAscii(string unicode, int index)
  88.         {
  89.             if (unicode == null)
  90.                 throw new ArgumentNullException("unicode");
  91.             return GetAscii(unicode, index, unicode.Length - index);
  92.         }
  93.        
  94.         public string GetAscii(string unicode, int index, int count)
  95.         {
  96.             if (unicode == null)
  97.                 throw new ArgumentNullException("unicode");
  98.             if (index < 0 || count < 0)
  99.                 throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  100.             if (index > unicode.Length)
  101.                 throw new ArgumentOutOfRangeException("byteIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  102.             if (index > unicode.Length - count)
  103.                 throw new ArgumentOutOfRangeException("unicode", Environment.GetResourceString("ArgumentOutOfRange_IndexCountBuffer"));
  104.            
  105.             // We're only using part of the string
  106.             unicode = unicode.Substring(index, count);
  107.            
  108.             // Check for ASCII only string, which will be unchanged
  109.             if (ValidateStd3AndAscii(unicode, UseStd3AsciiRules, true)) {
  110.                 return unicode;
  111.             }
  112.            
  113.             // Cannot be null terminated (normalization won't help us with this one, and
  114.             // may have returned false before checking the whole string above)
  115.             BCLDebug.Assert(unicode.Length >= 1, "[IdnMapping.GetAscii]Expected 0 length strings to fail before now.");
  116.             if (unicode[unicode.Length - 1] <= 31) {
  117.                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequence", unicode.Length - 1), "unicode");
  118.             }
  119.            
  120.             // Have to correctly IDNA normalize the string and Unassigned flags
  121.             bool bHasLastDot = (unicode.Length > 0) && IsDot(unicode[unicode.Length - 1]);
  122.             unicode = unicode.Normalize((NormalizationForm)(m_bAllowUnassigned ? ExtendedNormalizationForms.FormIdna : ExtendedNormalizationForms.FormIdnaDisallowUnassigned));
  123.            
  124.             // Make sure we didn't normalize away something after a last dot
  125.             if ((!bHasLastDot) && unicode.Length > 0 && IsDot(unicode[unicode.Length - 1])) {
  126.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  127.             }
  128.            
  129.             // May need to check Std3 rules again for non-ascii
  130.             if (UseStd3AsciiRules) {
  131.                 ValidateStd3AndAscii(unicode, true, false);
  132.             }
  133.            
  134.             // Go ahead and encode it
  135.             return punycode_encode(unicode);
  136.         }
  137.        
  138.        
  139.         // Gets Unicode version of the string. Normalized and limited to IDNA characters.
  140.         public string GetUnicode(string ascii)
  141.         {
  142.             return GetUnicode(ascii, 0);
  143.         }
  144.        
  145.         public string GetUnicode(string ascii, int index)
  146.         {
  147.             if (ascii == null)
  148.                 throw new ArgumentNullException("unicode");
  149.             return GetUnicode(ascii, index, ascii.Length - index);
  150.         }
  151.        
  152.         public string GetUnicode(string ascii, int index, int count)
  153.         {
  154.             if (ascii == null)
  155.                 throw new ArgumentNullException("ascii");
  156.             if (index < 0 || count < 0)
  157.                 throw new ArgumentOutOfRangeException((index < 0) ? "index" : "count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
  158.             if (index > ascii.Length)
  159.                 throw new ArgumentOutOfRangeException("byteIndex", Environment.GetResourceString("ArgumentOutOfRange_Index"));
  160.             if (index > ascii.Length - count)
  161.                 throw new ArgumentOutOfRangeException("ascii", Environment.GetResourceString("ArgumentOutOfRange_IndexCountBuffer"));
  162.            
  163.             // We're only using part of the string
  164.             ascii = ascii.Substring(index, count);
  165.            
  166.             // Convert Punycode to Unicode
  167.             string strUnicode = punycode_decode(ascii);
  168.            
  169.             // Output name MUST obey IDNA rules & round trip (casing differences are allowed)
  170.             if (!ascii.Equals(GetAscii(strUnicode), StringComparison.OrdinalIgnoreCase))
  171.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnIllegalName"), "ascii");
  172.            
  173.             return strUnicode;
  174.         }
  175.        
  176.         public override bool Equals(object obj)
  177.         {
  178.             IdnMapping that = obj as IdnMapping;
  179.            
  180.             if (that != null) {
  181.                 return this.m_bAllowUnassigned == that.m_bAllowUnassigned && this.m_bUseStd3AsciiRules == that.m_bUseStd3AsciiRules;
  182.             }
  183.            
  184.             return (false);
  185.         }
  186.        
  187.         public override int GetHashCode()
  188.         {
  189.             return (this.m_bAllowUnassigned ? 100 : 200) + (this.m_bUseStd3AsciiRules ? 1000 : 2000);
  190.         }
  191.        
  192.         // Helpers
  193.         bool IsSupplementary(int cTest)
  194.         {
  195.             return cTest >= 65536;
  196.         }
  197.        
  198.         // Is it a dot?
  199.         // are we U+002E (., full stop), U+3002 (ideographic full stop), U+FF0E (fullwidth full stop), or
  200.         // U+FF61 (halfwidth ideographic full stop).
  201.         // Note: IDNA Normalization gets rid of dots now, but testing for last dot is before normalization
  202.         bool IsDot(char c)
  203.         {
  204.             return c == '.' || c == '。' || c == '.' || c == '。';
  205.         }
  206.        
  207.        
  208.         // See if we're only ASCII
  209.         bool ValidateStd3AndAscii(string unicode, bool bUseStd3, bool bCheckAscii)
  210.         {
  211.             int iLastDot = -1;
  212.            
  213.             // If its empty, then its too small
  214.             if (unicode.Length == 0)
  215.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  216.            
  217.             // Loop the whole string
  218.             for (int i = 0; i < unicode.Length; i++) {
  219.                 // Aren't allowing control chars (or 7f, but idn tables catch that, they don't catch \0 at end though)
  220.                 if (unicode[i] <= 31) {
  221.                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidCharSequence", i), "unicode");
  222.                 }
  223.                
  224.                 // If its Unicode or a control character, return false (non-ascii)
  225.                 if (bCheckAscii && unicode[i] >= 127)
  226.                     return false;
  227.                
  228.                 // Check for dots
  229.                 if (IsDot(unicode[i])) {
  230.                     // Can't have 2 dots in a row
  231.                     if (i == iLastDot + 1)
  232.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  233.                    
  234.                     // If its too far between dots then fail
  235.                     if (i - iLastDot > M_labelLimit + 1)
  236.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "Unicode");
  237.                    
  238.                     // If validating Std3, then char before dot can't be - char
  239.                     if (bUseStd3 && i > 0)
  240.                         ValidateStd3(unicode[i - 1], true);
  241.                    
  242.                     // Remember where the last dot is
  243.                     iLastDot = i;
  244.                     continue;
  245.                 }
  246.                
  247.                 // If necessary, make sure its a valid std3 character
  248.                 if (bUseStd3) {
  249.                     ValidateStd3(unicode[i], (i == iLastDot + 1));
  250.                 }
  251.             }
  252.            
  253.             // If we never had a dot, then we need to be shorter than the label limit
  254.             if (iLastDot == -1 && unicode.Length > M_labelLimit)
  255.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  256.            
  257.             // Need to validate entire string length, 1 shorter if last char wasn't a dot
  258.             if (unicode.Length > M_defaultNameLimit - (IsDot(unicode[unicode.Length - 1]) ? 0 : 1))
  259.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadNameSize", M_defaultNameLimit - (IsDot(unicode[unicode.Length - 1]) ? 0 : 1)), "unicode");
  260.            
  261.             // If last char wasn't a dot we need to check for trailing -
  262.             if (bUseStd3 && !IsDot(unicode[unicode.Length - 1]))
  263.                 ValidateStd3(unicode[unicode.Length - 1], true);
  264.            
  265.             return true;
  266.         }
  267.        
  268.         // Validate Std3 rules for a character
  269.         void ValidateStd3(char c, bool bNextToDot)
  270.         {
  271.             // Check for illegal characters
  272.             if ((c <= ',' || c == '/' || (c >= ':' && c <= '@') || (c >= '[' && c <= '`') || (c >= '{' && c <= (char)127)) || (c == '-' && bNextToDot))
  273.                 // Lots of characters not allowed
  274.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadStd3", c), "Unicode");
  275.         }
  276.        
  277.         //
  278.         // The following punycode implementation is ported from the sample punycode.c in RFC 3492
  279.         // Original sample code was written by Adam M. Costello.
  280.         //
  281.        
  282.         // Return whether a punycode code point is flagged as being upper case.
  283.        
  284.         static bool HasUpperCaseFlag(char punychar)
  285.         {
  286.             return (punychar >= 'A' && punychar <= 'Z');
  287.         }
  288.        
  289.        
  290. /**********************************************************/       
  291. /* Implementation (would normally go in its own .c file): */       
  292.        
  293. /*** Bootstring parameters for Punycode ***/       
  294.         const int punycodeBase = 36;
  295.         const int tmin = 1;
  296.         const int tmax = 26;
  297.         const int skew = 38;
  298.         const int damp = 700;
  299.         const int initial_bias = 72;
  300.         const int initial_n = 128;
  301.         const char delimiter = '-';
  302.        
  303. /* basic(cp) tests whether cp is a basic code point: */       
  304.         static bool basic(uint cp)
  305.         {
  306.             // Is it in ASCII range?
  307.             return cp < 128;
  308.         }
  309.        
  310.         // decode_digit(cp) returns the numeric value of a basic code */
  311.         // point (for use in representing integers) in the range 0 to */
  312.         // punycodeBase-1, or <0 if cp is does not represent a value. */
  313.        
  314.         static int decode_digit(char cp)
  315.         {
  316.             if (cp >= '0' && cp <= '9')
  317.                 return cp - '0' + 26;
  318.            
  319.             // Two flavors for case differences
  320.             if (cp >= 'a' && cp <= 'z')
  321.                 return cp - 'a';
  322.            
  323.             if (cp >= 'A' && cp <= 'Z')
  324.                 return cp - 'A';
  325.            
  326.             // Expected 0-9, A-Z or a-z, everything else is illegal
  327.             throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  328.         }
  329.        
  330. /* encode_digit(d,flag) returns the basic code point whose value      */       
  331. /* (when used for representing integers) is d, which needs to be in  */       
  332. /* the range 0 to punycodeBase-1.  The lowercase form is used unless flag is  */       
  333. /* true, in which case the uppercase form is used. */       
  334.        
  335.         static char encode_digit(int d)
  336.         {
  337.             BCLDebug.Assert(d >= 0 && d < punycodeBase, "[IdnMapping.encode_digit]Expected 0 <= d < punycodeBase");
  338.             // 26-35 map to ASCII 0-9
  339.             if (d > 25)
  340.                 return (char)(d - 26 + '0');
  341.            
  342.             // 0-25 map to a-z or A-Z
  343.             return (char)(d + 'a');
  344.         }
  345.        
  346.        
  347.        
  348. /* encode_basic(bcp,flag) forces a basic code point to lowercase */       
  349. /* if flag is false, uppercase if flag is true, and returns    */       
  350. /* the resulting code point.  The code point is unchanged if it  */       
  351. /* is caseless.  The behavior is undefined if bcp is not a basic */       
  352. /* code point.                                                  */       
  353.        
  354.         static char encode_basic(char bcp)
  355.         {
  356.             if (HasUpperCaseFlag(bcp))
  357.                 bcp += (char)('a' - 'A');
  358.            
  359.             return bcp;
  360.         }
  361.        
  362. /*** Platform-specific constants ***/       
  363.        
  364. /* maxint is the maximum value of a uint variable: */       
  365.         const int maxint = 134217727;
  366.        
  367. /*** Bias adaptation function ***/       
  368.        
  369.         static int adapt(int delta, int numpoints, bool firsttime)
  370.         {
  371.             uint k;
  372.            
  373.             delta = firsttime ? delta / damp : delta / 2;
  374.             BCLDebug.Assert(numpoints != 0, "[IdnMapping.adapt]Expected non-zero numpoints.");
  375.             delta += delta / numpoints;
  376.            
  377.             for (k = 0; delta > ((punycodeBase - tmin) * tmax) / 2; k += punycodeBase) {
  378.                 delta /= punycodeBase - tmin;
  379.             }
  380.            
  381.             BCLDebug.Assert(delta + skew != 0, "[IdnMapping.adapt]Expected non-zero delta+skew.");
  382.             return (int)(k + (punycodeBase - tmin + 1) * delta / (delta + skew));
  383.         }
  384.        
  385. /*** Main encode function ***/       
  386.        
  387. /* punycode_encode() converts Unicode to Punycode.  The input    */       
  388. /* is represented as an array of Unicode code points (not code    */       
  389. /* units; surrogate pairs are not allowed), and the output        */       
  390. /* will be represented as an array of ASCII code points.  The    */       
  391. /* output string is *not* null-terminated; it will contain        */       
  392. /* zeros if and only if the input contains zeros.  (Of course    */       
  393. /* the caller can leave room for a terminator and add one if      */       
  394. /* needed.)  The input_length is the number of code points in    */       
  395. /* the input.  The output_length is an in/out argument: the      */       
  396. /* caller passes in the maximum number of code points that it    */       
  397.        
  398. /* can receive, and on successful return it will contain the      */       
  399. /* number of code points actually output.  The case_flags array  */       
  400. /* holds input_length boolean values, where nonzero suggests that */       
  401. /* the corresponding Unicode character be forced to uppercase    */       
  402. /* after being decoded (if possible), and zero suggests that      */       
  403. /* it be forced to lowercase (if possible).  ASCII code points    */       
  404. /* are encoded literally, except that ASCII letters are forced    */       
  405. /* to uppercase or lowercase according to the corresponding      */       
  406. /* uppercase flags.  If case_flags is a null pointer then ASCII  */       
  407. /* letters are left as they are, and other code points are        */       
  408. /* treated as if their uppercase flags were zero.  The return    */       
  409. /* value can be any of the punycode_status values defined above  */       
  410. /* except punycode_bad_input; if not punycode_success, then      */       
  411. /* output_size and output might contain garbage.                  */       
  412.        
  413.         string punycode_encode(string unicode)
  414.         {
  415.             StringBuilder output = new StringBuilder(unicode.Length);
  416.             int iNextDot = 0;
  417.             int iAfterLastDot = 0;
  418.             int iOutputAfterLastDot = 0;
  419.            
  420.             // 0 length strings aren't allowed
  421.             if (unicode.Length == 0)
  422.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  423.            
  424.             // Find the next dot
  425.             while (iNextDot < unicode.Length) {
  426.                 // Find end of this segment
  427.                 iNextDot = unicode.IndexOfAny(M_Dots, iAfterLastDot);
  428.                 BCLDebug.Assert(iNextDot <= unicode.Length, "[IdnMapping.punycode_encode]IndexOfAny is broken");
  429.                 if (iNextDot < 0)
  430.                     iNextDot = unicode.Length;
  431.                
  432.                 // Only allowed to have empty . section at end (www.microsoft.com.)
  433.                 if (iNextDot == iAfterLastDot) {
  434.                     // Only allowed to have empty sections as trailing .
  435.                     if (iNextDot != unicode.Length)
  436.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  437.                     // Last dot, stop
  438.                     break;
  439.                 }
  440.                
  441.                 // We'll need an Ace prefix
  442.                 output.Append(M_strAcePrefix);
  443.                
  444.                 // Everything resets every segment.
  445.                 bool bRightToLeft = false;
  446.                
  447.                 // Check for RTL. If right-to-left, then 1st & last chars must be RTL
  448.                 BidiCategory eBidi = CharUnicodeInfo.GetBidiCategory(unicode, iAfterLastDot);
  449.                 if (eBidi == BidiCategory.RightToLeft || eBidi == BidiCategory.RightToLeftArabic) {
  450.                     // It has to be right to left.
  451.                     bRightToLeft = true;
  452.                    
  453.                     // Check last char
  454.                     int iTest = iNextDot - 1;
  455.                     if (Char.IsLowSurrogate(unicode, iTest)) {
  456.                         iTest--;
  457.                     }
  458.                    
  459.                     eBidi = CharUnicodeInfo.GetBidiCategory(unicode, iTest);
  460.                     if (eBidi != BidiCategory.RightToLeft && eBidi != BidiCategory.RightToLeftArabic) {
  461.                         // Oops, last wasn't RTL, last should be RTL if first is RTL
  462.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadBidi"), "unicode");
  463.                     }
  464.                 }
  465.                
  466.                 // Handle the basic code points
  467.                 int basicCount;
  468.                 int numProcessed = 0;
  469.                 // Num code points that have been processed so far (this segment)
  470.                 for (basicCount = iAfterLastDot; basicCount < iNextDot; basicCount++) {
  471.                     // Can't be lonely surrogate because it would've thrown in normalization
  472.                     BCLDebug.Assert(Char.IsLowSurrogate(unicode, basicCount) == false, "[IdnMapping.punycode_encode]Unexpected low surrogate");
  473.                    
  474.                     // Double check our bidi rules
  475.                     BidiCategory testBidi = CharUnicodeInfo.GetBidiCategory(unicode, basicCount);
  476.                    
  477.                     // If we're RTL, we can't have LTR chars
  478.                     if (bRightToLeft && testBidi == BidiCategory.LeftToRight) {
  479.                         // Oops, throw error
  480.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadBidi"), "unicode");
  481.                     }
  482.                    
  483.                     // If we're not RTL we can't have RTL chars
  484.                     if (!bRightToLeft && (testBidi == BidiCategory.RightToLeft || testBidi == BidiCategory.RightToLeftArabic)) {
  485.                         // Oops, throw error
  486.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadBidi"), "unicode");
  487.                     }
  488.                    
  489.                     // If its basic then add it
  490.                     if (basic(unicode[basicCount])) {
  491.                         output.Append(encode_basic(unicode[basicCount]));
  492.                         numProcessed++;
  493.                     }
  494.                     else if (Char.IsSurrogatePair(unicode, basicCount))
  495.                         // If its a surrogate, skip the next since our bidi category tester doesn't handle it.
  496.                         basicCount++;
  497.                 }
  498.                
  499.                 int numBasicCodePoints = numProcessed;
  500.                 // number of basic code points
  501.                 // Stop if we ONLY had basic code points
  502.                 if (numBasicCodePoints == iNextDot - iAfterLastDot) {
  503.                     // Get rid of xn-- and this segments done
  504.                     output.Remove(iOutputAfterLastDot, M_strAcePrefix.Length);
  505.                 }
  506.                 else {
  507.                     // If it has some non-basic code points the input cannot start with xn--
  508.                     if (unicode.Length - iAfterLastDot >= M_strAcePrefix.Length && unicode.Substring(iAfterLastDot, M_strAcePrefix.Length).Equals(M_strAcePrefix, StringComparison.OrdinalIgnoreCase))
  509.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "unicode");
  510.                    
  511.                     // Need to do ACE encoding
  512.                     int numSurrogatePairs = 0;
  513.                     // number of surrogate pairs so far
  514.                     // Add a delimiter (-) if we had any basic code points (between basic and encoded pieces)
  515.                     if (numBasicCodePoints > 0) {
  516.                         output.Append(delimiter);
  517.                     }
  518.                    
  519.                     // Initialize the state
  520.                     int n = initial_n;
  521.                     int delta = 0;
  522.                     int bias = initial_bias;
  523.                    
  524.                     // Main loop
  525.                     while (numProcessed < (iNextDot - iAfterLastDot)) {
  526.                         /* All non-basic code points < n have been    */                       
  527. /* handled already.  Find the next larger one: */                       
  528. int j;
  529.                         int m;
  530.                         int test = 0;
  531.                         for (m = maxint,j = iAfterLastDot; j < iNextDot; j += IsSupplementary(test) ? 2 : 1) {
  532.                             test = Char.ConvertToUtf32(unicode, j);
  533.                             if (test >= n && test < m)
  534.                                 m = test;
  535.                         }
  536.                        
  537.                         /* Increase delta enough to advance the decoder's    */                       
  538. /* <n,i> state to <m,0>, but guard against overflow: */                       
  539. delta += (int)((m - n) * ((numProcessed - numSurrogatePairs) + 1));
  540.                         BCLDebug.Assert(delta > 0, "[IdnMapping.cs]1 punicode_encode - delta overflowed int");
  541.                         n = m;
  542.                        
  543.                         for (j = iAfterLastDot; j < iNextDot; j += IsSupplementary(test) ? 2 : 1) {
  544.                             // Make sure we're aware of surrogates
  545.                             test = Char.ConvertToUtf32(unicode, j);
  546.                            
  547.                             // Adjust for character position (only the chars in our string already, some
  548.                             // haven't been processed.
  549.                            
  550.                             if (test < n) {
  551.                                 delta++;
  552.                                 BCLDebug.Assert(delta > 0, "[IdnMapping.cs]2 punicode_encode - delta overflowed int");
  553.                             }
  554.                            
  555.                             if (test == n) {
  556.                                 // Represent delta as a generalized variable-length integer:
  557.                                 int q;
  558.                                 int k;
  559.                                 for (q = delta,k = punycodeBase;; k += punycodeBase) {
  560.                                     int t = k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
  561.                                     if (q < t)
  562.                                         break;
  563.                                     BCLDebug.Assert(punycodeBase != t, "[IdnMapping.punycode_encode]Expected punycodeBase (36) to be != t");
  564.                                     output.Append(encode_digit(t + (q - t) % (punycodeBase - t)));
  565.                                     q = (q - t) / (punycodeBase - t);
  566.                                 }
  567.                                
  568.                                 output.Append(encode_digit(q));
  569.                                 bias = adapt(delta, (numProcessed - numSurrogatePairs) + 1, numProcessed == numBasicCodePoints);
  570.                                 delta = 0;
  571.                                 numProcessed++;
  572.                                
  573.                                 if (IsSupplementary(m)) {
  574.                                     numProcessed++;
  575.                                     numSurrogatePairs++;
  576.                                 }
  577.                             }
  578.                         }
  579.                         ++delta;
  580.                         ++n;
  581.                         BCLDebug.Assert(delta > 0, "[IdnMapping.cs]3 punicode_encode - delta overflowed int");
  582.                     }
  583.                 }
  584.                
  585.                 // Make sure its not too big
  586.                 if (output.Length - iOutputAfterLastDot > M_labelLimit)
  587.                     throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "unicode");
  588.                
  589.                 // Done with this segment, add dot if necessary
  590.                 if (iNextDot != unicode.Length)
  591.                     output.Append('.');
  592.                
  593.                 iAfterLastDot = iNextDot + 1;
  594.                 iOutputAfterLastDot = output.Length;
  595.             }
  596.            
  597.             // Throw if we're too long
  598.             if (output.Length > M_defaultNameLimit - (IsDot(unicode[unicode.Length - 1]) ? 0 : 1))
  599.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadNameSize", M_defaultNameLimit - (IsDot(unicode[unicode.Length - 1]) ? 0 : 1)), "unicode");
  600.            
  601.             // Return our output string
  602.             return output.ToString();
  603.         }
  604.        
  605. /*** Main decode function ***/       
  606.        
  607. /* punycode_decode() converts Punycode to Unicode.  The input is  */       
  608. /* represented as an array of ASCII code points, and the output  */       
  609. /* will be represented as an array of Unicode code points.  The  */       
  610. /* input_length is the number of code points in the input.  The  */       
  611. /* output_length is an in/out argument: the caller passes in      */       
  612. /* the maximum number of code points that it can receive, and    */       
  613. /* on successful return it will contain the actual number of      */       
  614. /* code points output.  The case_flags array needs room for at    */       
  615. /* least output_length values, or it can be a null pointer if the */       
  616. /* case information is not needed.  A nonzero flag suggests that  */       
  617. /* the corresponding Unicode character be forced to uppercase    */       
  618. /* by the caller (if possible), while zero suggests that it be    */       
  619. /* forced to lowercase (if possible).  ASCII code points are      */       
  620. /* output already in the proper case, but their flags will be set */       
  621. /* appropriately so that applying the flags would be harmless.    */       
  622. /* The return value can be any of the punycode_status values      */       
  623. /* defined above; if not punycode_success, then output_length,    */       
  624. /* output, and case_flags might contain garbage.  On success, the */       
  625. /* decoder will never need to write an output_length greater than */       
  626. /* input_length, because of how the encoding is defined.          */       
  627.        
  628.         string punycode_decode(string ascii)
  629.         {
  630.             // 0 length strings aren't allowed
  631.             if (ascii.Length == 0)
  632.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "ascii");
  633.            
  634.             // Throw if we're too long
  635.             if (ascii.Length > M_defaultNameLimit - (IsDot(ascii[ascii.Length - 1]) ? 0 : 1))
  636.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadNameSize", M_defaultNameLimit - (IsDot(ascii[ascii.Length - 1]) ? 0 : 1)), "ascii");
  637.            
  638.             // output stringbuilder
  639.             StringBuilder output = new StringBuilder(ascii.Length);
  640.            
  641.             // Dot searching
  642.             int iNextDot = 0;
  643.             int iAfterLastDot = 0;
  644.             int iOutputAfterLastDot = 0;
  645.            
  646.             while (iNextDot < ascii.Length) {
  647.                 // Find end of this segment
  648.                 iNextDot = ascii.IndexOf('.', iAfterLastDot);
  649.                 if (iNextDot < 0 || iNextDot > ascii.Length)
  650.                     iNextDot = ascii.Length;
  651.                
  652.                 // Only allowed to have empty . section at end (www.microsoft.com.)
  653.                 if (iNextDot == iAfterLastDot) {
  654.                     // Only allowed to have empty sections as trailing .
  655.                     if (iNextDot != ascii.Length)
  656.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "ascii");
  657.                    
  658.                     // Last dot, stop
  659.                     break;
  660.                 }
  661.                
  662.                 // In either case it can't be bigger than segment size
  663.                 if (iNextDot - iAfterLastDot > M_labelLimit)
  664.                     throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "ascii");
  665.                
  666.                 // See if this section's ASCII or ACE
  667.                 if (ascii.Length < M_strAcePrefix.Length + iAfterLastDot || !ascii.Substring(iAfterLastDot, M_strAcePrefix.Length).Equals(M_strAcePrefix, StringComparison.OrdinalIgnoreCase)) {
  668.                     // Its supposed to be just ASCII
  669.                     // Actually, for non xn-- stuff do we want to allow Unicode?
  670.                     // for (int i = iAfterLastDot; i < iNextDot; i++)
  671.                     // {
  672.                     // // Only ASCII is allowed
  673.                     // if (ascii[i] >= 0x80)
  674.                     // throw new ArgumentException(Environment.GetResourceString(
  675.                     // "Argument_IdnBadPunycode"), "ascii");
  676.                     // }
  677.                    
  678.                     // Its ASCII, copy it
  679.                     output.Append(ascii.Substring(iAfterLastDot, iNextDot - iAfterLastDot));
  680.                    
  681.                     // ASCII doesn't have BIDI issues
  682.                 }
  683.                 else {
  684.                     // Not ASCII, bump up iAfterLastDot to be after ACE Prefix
  685.                     iAfterLastDot += M_strAcePrefix.Length;
  686.                    
  687.                     // Get number of basic code points (where delimiter is)
  688.                     // numBasicCodePoints < 0 if there're no basic code points
  689.                     int iTemp = ascii.LastIndexOf(delimiter, iNextDot - 1);
  690.                    
  691.                     // Trailing - not allowed
  692.                     if (iTemp == iNextDot - 1)
  693.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  694.                    
  695.                     int numBasicCodePoints;
  696.                     if (iTemp <= iAfterLastDot)
  697.                         numBasicCodePoints = 0;
  698.                     else {
  699.                         numBasicCodePoints = iTemp - iAfterLastDot;
  700.                        
  701.                         // Copy all the basic code points, making sure they're all in the allowed range,
  702.                         // and losing the casing for all of them.
  703.                         for (int copyAscii = iAfterLastDot; copyAscii < iAfterLastDot + numBasicCodePoints; copyAscii++) {
  704.                             // Make sure we don't allow unicode in the ascii part
  705.                             if (ascii[copyAscii] > 127)
  706.                                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  707.                            
  708.                             // When appending make sure they get lower cased
  709.                             output.Append((char)(ascii[copyAscii] >= 'A' && ascii[copyAscii] <= 'Z' ? ascii[copyAscii] - 'A' + 'a' : ascii[copyAscii]));
  710.                         }
  711.                     }
  712.                    
  713.                     // Get ready for main loop. Start at beginning if we didn't have any
  714.                     // basic code points, otherwise start after the -.
  715.                     // asciiIndex will be next character to read from ascii
  716.                     int asciiIndex = iAfterLastDot + (numBasicCodePoints > 0 ? numBasicCodePoints + 1 : 0);
  717.                    
  718.                     // initialize our state
  719.                     int n = initial_n;
  720.                     int bias = initial_bias;
  721.                     int i = 0;
  722.                    
  723.                     int w;
  724.                     int k;
  725.                    
  726.                     // no Supplementary characters yet
  727.                     int numSurrogatePairs = 0;
  728.                    
  729.                     // Main loop, read rest of ascii
  730.                     while (asciiIndex < iNextDot) {
  731.                         /* Decode a generalized variable-length integer into delta,  */                       
  732. /* which gets added to i.  The overflow checking is easier  */                       
  733. /* if we increase i as we go, then subtract off its starting */                       
  734. /* value at the end to obtain delta.                        */                       
  735. int oldi = i;
  736.                        
  737.                         for (w = 1,k = punycodeBase;; k += punycodeBase) {
  738.                             // Check to make sure we aren't overrunning our ascii string
  739.                             if (asciiIndex >= iNextDot)
  740.                                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  741.                            
  742.                             // decode the digit from the next char
  743.                             int digit = decode_digit(ascii[asciiIndex++]);
  744.                            
  745.                             BCLDebug.Assert(w > 0, "[IdnMapping.punycode_decode]Expected w > 0");
  746.                             if (digit > (maxint - i) / w)
  747.                                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  748.                            
  749.                             i += (int)(digit * w);
  750.                             int t = k <= bias ? tmin : k >= bias + tmax ? tmax : k - bias;
  751.                             if (digit < t)
  752.                                 break;
  753.                             BCLDebug.Assert(punycodeBase != t, "[IdnMapping.punycode_decode]Expected t != punycodeBase (36)");
  754.                             if (w > maxint / (punycodeBase - t))
  755.                                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  756.                             w *= (punycodeBase - t);
  757.                         }
  758.                        
  759.                         bias = adapt(i - oldi, (output.Length - iOutputAfterLastDot - numSurrogatePairs) + 1, oldi == 0);
  760.                        
  761.                         /* i was supposed to wrap around from output.Length to 0,  */                       
  762. /* incrementing n each time, so we'll fix that now: */                       
  763. BCLDebug.Assert((output.Length - iOutputAfterLastDot - numSurrogatePairs) + 1 > 0, "[IdnMapping.punycode_decode]Expected to have added > 0 characters this segment");
  764.                         if (i / ((output.Length - iOutputAfterLastDot - numSurrogatePairs) + 1) > maxint - n)
  765.                             throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  766.                         n += (int)(i / (output.Length - iOutputAfterLastDot - numSurrogatePairs + 1));
  767.                         i %= (output.Length - iOutputAfterLastDot - numSurrogatePairs + 1);
  768.                        
  769.                         // If it was flagged it needs to be capitalized
  770.                         // if (HasUpperCaseFlag(ascii[asciiIndex - 1]))
  771.                         // {
  772.                         // /* Case of last character determines uppercase flag: */
  773.                         // // Any casing stuff need to happen last.
  774.                         // If we wanted to reverse the IDNA casing data
  775.                         // n = MakeNUpperCase(n)
  776.                         // }
  777.                        
  778.                         // Make sure n is legal
  779.                         if ((n < 0 || n > 1114111) || (n >= 55296 && n <= 57343))
  780.                             throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  781.                        
  782.                         // insert n at position i of the output: Really tricky if we have surrogates
  783.                         int iUseInsertLocation;
  784.                         string strTemp = Char.ConvertFromUtf32(n);
  785.                        
  786.                         // If we have supplimentary characters
  787.                         if (numSurrogatePairs > 0) {
  788.                             // Hard way, we have supplimentary characters
  789.                             int iCount;
  790.                             for (iCount = i,iUseInsertLocation = iOutputAfterLastDot; iCount > 0; iCount--,iUseInsertLocation++) {
  791.                                 // If its a surrogate, we have to go one more
  792.                                 if (iUseInsertLocation >= output.Length)
  793.                                     throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadPunycode"), "ascii");
  794.                                 if (Char.IsSurrogate(output[iUseInsertLocation]))
  795.                                     iUseInsertLocation++;
  796.                             }
  797.                         }
  798.                         else {
  799.                             // No Supplementary chars yet, just add i
  800.                             iUseInsertLocation = iOutputAfterLastDot + i;
  801.                         }
  802.                        
  803.                         // Insert it
  804.                         output.Insert(iUseInsertLocation, strTemp);
  805.                        
  806.                         // If it was a surrogate increment our counter
  807.                         if (IsSupplementary(n))
  808.                             numSurrogatePairs++;
  809.                        
  810.                         // Index gets updated
  811.                         i++;
  812.                     }
  813.                    
  814.                     // Do BIDI testing
  815.                     bool bRightToLeft = false;
  816.                    
  817.                     // Check for RTL. If right-to-left, then 1st & last chars must be RTL
  818.                     BidiCategory eBidi = CharUnicodeInfo.GetBidiCategory(output.ToString(), iOutputAfterLastDot);
  819.                     if (eBidi == BidiCategory.RightToLeft || eBidi == BidiCategory.RightToLeftArabic) {
  820.                         // It has to be right to left.
  821.                         bRightToLeft = true;
  822.                     }
  823.                    
  824.                     // Check the rest of them to make sure RTL/LTR is consistent
  825.                     for (int iTest = iOutputAfterLastDot; iTest < output.Length; iTest++) {
  826.                         // This might happen if we run into a pair
  827.                         if (Char.IsLowSurrogate(output.ToString(), iTest))
  828.                             continue;
  829.                        
  830.                         // Check to see if its LTR
  831.                         eBidi = CharUnicodeInfo.GetBidiCategory(output.ToString(), iTest);
  832.                         if ((bRightToLeft && eBidi == BidiCategory.LeftToRight) || (!bRightToLeft && (eBidi == BidiCategory.RightToLeft || eBidi == BidiCategory.RightToLeftArabic)))
  833.                             throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadBidi"), "ascii");
  834.                        
  835.                         // Make it lower case if we must (so we can test IsNormalized later)
  836.                         // if (output[iTest] >= 'A' && output[iTest] <= 'Z')
  837.                         // output[iTest] = (char)(output[iTest] + (char)('a' - 'A'));
  838.                     }
  839.                    
  840.                     // Its also a requirement that the last one be RTL if 1st is RTL
  841.                     if (bRightToLeft && eBidi != BidiCategory.RightToLeft && eBidi != BidiCategory.RightToLeftArabic) {
  842.                         // Oops, last wasn't RTL, last should be RTL if first is RTL
  843.                         throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadBidi"), "ascii");
  844.                     }
  845.                 }
  846.                
  847.                 // See if this label was too long
  848.                 if (iNextDot - iAfterLastDot > M_labelLimit)
  849.                     throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadLabelSize"), "ascii");
  850.                
  851.                 // Done with this segment, add dot if necessary
  852.                 if (iNextDot != ascii.Length)
  853.                     output.Append('.');
  854.                
  855.                 iAfterLastDot = iNextDot + 1;
  856.                 iOutputAfterLastDot = output.Length;
  857.             }
  858.            
  859.             // Throw if we're too long
  860.             if (output.Length > M_defaultNameLimit - (IsDot(output[output.Length - 1]) ? 0 : 1))
  861.                 throw new ArgumentException(Environment.GetResourceString("Argument_IdnBadNameSize", M_defaultNameLimit - (IsDot(output[output.Length - 1]) ? 0 : 1)), "ascii");
  862.            
  863.             // Return our output string
  864.             return output.ToString();
  865.         }
  866.        
  867.         /*
  868.         The previous punycode implimentation is based on the sample code in RFC 3492
  869.         Full Copyright Statement
  870.           Copyright (C) The Internet Society (2003).  All Rights Reserved.
  871.           This document and translations of it may be copied and furnished to
  872.           others, and derivative works that comment on or otherwise explain it
  873.           or assist in its implementation may be prepared, copied, published
  874.           and distributed, in whole or in part, without restriction of any
  875.           kind, provided that the above copyright notice and this paragraph are
  876.           included on all such copies and derivative works.  However, this
  877.           document itself may not be modified in any way, such as by removing
  878.           the copyright notice or references to the Internet Society or other
  879.           Internet organizations, except as needed for the purpose of
  880.           developing Internet standards in which case the procedures for
  881.           copyrights defined in the Internet Standards process must be
  882.           followed, or as required to translate it into languages other than
  883.           English.
  884.           The limited permissions granted above are perpetual and will not be
  885.           revoked by the Internet Society or its successors or assigns.
  886.           This document and the information contained herein is provided on an
  887.           "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING
  888.           TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING
  889.           BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION
  890.           HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF
  891.           MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  892.         */       
  893.     }
  894. }

Developer Fusion