utils.java

这是linux下ssl vpn的实现程序

        for (i=0; i<s1.length() && i<s2.length(); ++i)
        {
            if (s1.charAt(i) != s2.charAt(i)) {
                break;
            }
        }
        if (i<s2.length() || i<s1.length())
            return i;
        return -1;
    }

    /**
     * Compare two strings, and return a verbose description of how
     * they differ. Shows a window around the location to provide
     * context.  E.g. strdiffVerbose("i am a robot", "i am a machine")
     * might return a string containing <pre>
     * strings differ at character 7
     * Expected: ...am a robot
     *   Actual: ...am a machine</pre>
     *
     * This was developed in order to provide some sanity to JUnit's
     * assertEquals routine.
     **/

    public static String strdiffVerbose(String expected, String actual)
    {
        int at = Utils.strdiffat(actual, expected);
        if (at == -1)
            return null;
        int length = 60;        // todo: parameterize
        int back = 20;          // todo: parameterize
        int start = at - back;
        if (start < 3) start = 0;

        StringBuffer buf = new StringBuffer(length*2 + 100);
        buf.append("strings differ at character ").append(at);
        buf.append("\n");

        buf.append("Expected: ");
        appendWithEllipses(buf, expected, start, length);
        buf.append("\n");

        buf.append("  Actual: ");
        appendWithEllipses(buf, actual, start, length);
        buf.append("\n");

        return buf.toString();
    }

    private static void appendWithEllipses(StringBuffer buf, String s, int start, int length)
    {
        if (start > 0) buf.append("...");
        buf.append
            (javaEscape   // note that escapes may add \, making final string more than 60 chars
             (abbreviate  // abbreviate adds the final ... if necessary
              (s.substring(start), length)));
    }

    /**
     * count the number of occurences of ch inside s
     * @deprecated use org.apache.commons.lang.StringUtils.countMatches instead
     **/
    public static int count(String s, char ch) {
        int c=0;
        for (int i=0; i<s.length(); ++i) {
            if (s.charAt(i) == ch) c++;
        }
        return c;
    }

    /**
     * Replace all occurences of target inside source with replacement.
     * E.g. replace("fee fie fo fum", "f", "gr") -> "gree grie gro grum"
     **/
    public static String replace(String source, String target, String replacement)
    {
        // could use a regular expression, but this keeps it portable
        StringBuffer result = new StringBuffer(source.length());
        int i = 0, j = 0;
        int len = source.length();
        while (i < len) {
            j = source.indexOf(target, i);
            if (j == -1) {
                result.append( source.substring(i,len) );
                break;
            }
            else {
                result.append( source.substring(i,j) );
                result.append( replacement );
                i = j + target.length();
            }
        }
        return result.toString();
    }

    /**
     * <p>
     *  Trim the whitespace off the right side of a <code>String</code>.
     * </p>
     *
     * @param orig <code>String</code> to rtrim.
     * @return <code>String</code> - orig with no right spaces
     */
    public static String rtrim(String orig) {
        int len = orig.length();
        int st = 0;
        int off = 0;
        char[] val = orig.toCharArray();

        while ((st < len) && (val[off + len - 1] <= ' ')) {
            len--;
        }
        return ((st > 0) || (len < orig.length())) ? orig.substring(st, len) : orig;
    }

    /**
     * <p>
     *  Trim the left spacing off of a <code>String</code>.
     * </p>
     *
     * @param orig <code>String</code> to rtrim.
     * @return <code>String</code> - orig with no left spaces
     */
    public static String ltrim(String orig) {
        int len = orig.length();
        int st = 0;
        int off = 0;
        char[] val = orig.toCharArray();

        while ((st < len) && (val[off + st] <= ' ')) {
            st++;
        }
        return ((st > 0) || (len < orig.length())) ? orig.substring(st, len) : orig;
    }

    /**
     * calculate the maximum length of all strings in i.  If i
     * contains other than strings, uses toString() value.
     **/
    public static int getMaxLength(Iterator i) {
        int max = 0;
        while (i.hasNext()) {
            String s = i.next().toString();
            int c = s.length();
            if (c>max) max=c;
        }
        return max;
    }

    // see http://hotwired.lycos.com/webmonkey/reference/special_characters/
    static Object[][] entities = {
       // {"#39", new Integer(39)},       // ' - apostrophe
        {"quot", new Integer(34)},      // " - double-quote
        {"amp", new Integer(38)},       // & - ampersand
        {"lt", new Integer(60)},        // < - less-than
        {"gt", new Integer(62)},        // > - greater-than
        {"nbsp", new Integer(160)},     // non-breaking space
        {"copy", new Integer(169)},     // � - copyright
        {"reg", new Integer(174)},      // � - registered trademark
        {"Agrave", new Integer(192)},   // � - uppercase A, grave accent
        {"Aacute", new Integer(193)},   // � - uppercase A, acute accent
        {"Acirc", new Integer(194)},    // � - uppercase A, circumflex accent
        {"Atilde", new Integer(195)},   // � - uppercase A, tilde
        {"Auml", new Integer(196)},     // � - uppercase A, umlaut
        {"Aring", new Integer(197)},    // � - uppercase A, ring
        {"AElig", new Integer(198)},    // � - uppercase AE
        {"Ccedil", new Integer(199)},   // � - uppercase C, cedilla
        {"Egrave", new Integer(200)},   // � - uppercase E, grave accent
        {"Eacute", new Integer(201)},   // � - uppercase E, acute accent
        {"Ecirc", new Integer(202)},    // � - uppercase E, circumflex accent
        {"Euml", new Integer(203)},     // � - uppercase E, umlaut
        {"Igrave", new Integer(204)},   // � - uppercase I, grave accent
        {"Iacute", new Integer(205)},   // � - uppercase I, acute accent
        {"Icirc", new Integer(206)},    // � - uppercase I, circumflex accent
        {"Iuml", new Integer(207)},     // � - uppercase I, umlaut
        {"ETH", new Integer(208)},      // � - uppercase Eth, Icelandic
        {"Ntilde", new Integer(209)},   // � - uppercase N, tilde
        {"Ograve", new Integer(210)},   // � - uppercase O, grave accent
        {"Oacute", new Integer(211)},   // � - uppercase O, acute accent
        {"Ocirc", new Integer(212)},    // � - uppercase O, circumflex accent
        {"Otilde", new Integer(213)},   // � - uppercase O, tilde
        {"Ouml", new Integer(214)},     // � - uppercase O, umlaut
        {"Oslash", new Integer(216)},   // � - uppercase O, slash
        {"Ugrave", new Integer(217)},   // � - uppercase U, grave accent
        {"Uacute", new Integer(218)},   // � - uppercase U, acute accent
        {"Ucirc", new Integer(219)},    // � - uppercase U, circumflex accent
        {"Uuml", new Integer(220)},     // � - uppercase U, umlaut
        {"Yacute", new Integer(221)},   // � - uppercase Y, acute accent
        {"THORN", new Integer(222)},    // � - uppercase THORN, Icelandic
        {"szlig", new Integer(223)},    // � - lowercase sharps, German
        {"agrave", new Integer(224)},   // � - lowercase a, grave accent
        {"aacute", new Integer(225)},   // � - lowercase a, acute accent
        {"acirc", new Integer(226)},    // � - lowercase a, circumflex accent
        {"atilde", new Integer(227)},   // � - lowercase a, tilde
        {"auml", new Integer(228)},     // � - lowercase a, umlaut
        {"aring", new Integer(229)},    // � - lowercase a, ring
        {"aelig", new Integer(230)},    // � - lowercase ae
        {"ccedil", new Integer(231)},   // � - lowercase c, cedilla
        {"egrave", new Integer(232)},   // � - lowercase e, grave accent
        {"eacute", new Integer(233)},   // � - lowercase e, acute accent
        {"ecirc", new Integer(234)},    // � - lowercase e, circumflex accent
        {"euml", new Integer(235)},     // � - lowercase e, umlaut
        {"igrave", new Integer(236)},   // � - lowercase i, grave accent
        {"iacute", new Integer(237)},   // � - lowercase i, acute accent
        {"icirc", new Integer(238)},    // � - lowercase i, circumflex accent
        {"iuml", new Integer(239)},     // � - lowercase i, umlaut
        {"igrave", new Integer(236)},   // � - lowercase i, grave accent
        {"iacute", new Integer(237)},   // � - lowercase i, acute accent
        {"icirc", new Integer(238)},    // � - lowercase i, circumflex accent
        {"iuml", new Integer(239)},     // � - lowercase i, umlaut
        {"eth", new Integer(240)},      // � - lowercase eth, Icelandic
        {"ntilde", new Integer(241)},   // � - lowercase n, tilde
        {"ograve", new Integer(242)},   // � - lowercase o, grave accent
        {"oacute", new Integer(243)},   // � - lowercase o, acute accent
        {"ocirc", new Integer(244)},    // � - lowercase o, circumflex accent
        {"otilde", new Integer(245)},   // � - lowercase o, tilde
        {"ouml", new Integer(246)},     // � - lowercase o, umlaut
        {"oslash", new Integer(248)},   // � - lowercase o, slash
        {"ugrave", new Integer(249)},   // � - lowercase u, grave accent
        {"uacute", new Integer(250)},   // � - lowercase u, acute accent
        {"ucirc", new Integer(251)},    // � - lowercase u, circumflex accent
        {"uuml", new Integer(252)},     // � - lowercase u, umlaut
        {"yacute", new Integer(253)},   // � - lowercase y, acute accent
        {"thorn", new Integer(254)},    // � - lowercase thorn, Icelandic
        {"yuml", new Integer(255)},     // � - lowercase y, umlaut
        {"euro", new Integer(8364)},    // Euro symbol
    };
    static Map e2i = new HashMap();
    static Map i2e = new HashMap();
    static {
        for (int i=0; i<entities.length; ++i) {
            e2i.put(entities[i][0], entities[i][1]);
            i2e.put(entities[i][1], entities[i][0]);
        }
    }

    /**
     * Turns funky characters into HTML entity equivalents<p>
     * e.g. <tt>"bread" & "butter"</tt> => <tt>&amp;quot;bread&amp;quot; &amp;amp; &amp;quot;butter&amp;quot;</tt>.
     * Update: supports nearly all HTML entities, including funky accents. See the source code for more detail.
     * @see #htmlunescape(String)
     **/
    public static String htmlescape(String s1)
    {
        StringBuffer buf = new StringBuffer();
        int i;
        for (i=0; i<s1.length(); ++i) {
            char ch = s1.charAt(i);
            String entity = (String)i2e.get( new Integer((int)ch) );
            if (entity == null) {
                if (((int)ch) > 128) {
                    buf.append("&#" + ((int)ch) + ";");
                }
                else {
                    buf.append(ch);
                }
            }
            else {
                buf.append("&" + entity + ";");
            }
        }
        return buf.toString();
    }

    /**
     * Given a string containing entity escapes, returns a string
     * containing the actual Unicode characters corresponding to the
     * escapes.
     *
     * Note: nasty bug fixed by Helge Tesgaard (and, in parallel, by
     * Alex, but Helge deserves major props for emailing me the fix).
     * 15-Feb-2002 Another bug fixed by Sean Brown <[e-mail]>
     *
     * @see #htmlescape(String)
     **/
    public static String htmlunescape(String s1) {
        StringBuffer buf = new StringBuffer();
        int i;
        for (i=0; i<s1.length(); ++i) {
            char ch = s1.charAt(i);
            if (ch == '&') {
                int semi = s1.indexOf(';', i+1);
                if (semi == -1) {
                    buf.append(ch);
                    continue;
                }
                String entity = s1.substring(i+1, semi);
                Integer iso;
                if (entity.charAt(0) == '#') {
                    iso = new Integer(entity.substring(1));
                }
                else {
                    iso = (Integer)e2i.get(entity);
                }
                if (iso == null) {
                    buf.append("&" + entity + ";");