Util.java
上传用户:sxlinghang
上传日期:2022-07-20
资源大小:1405k
文件大小:8k
源码类别:

数据库编程

开发平台:

Java

  1. /*
  2.    Copyright (C) 2002 MySQL AB
  3.       This program is free software; you can redistribute it and/or modify
  4.       it under the terms of the GNU General Public License as published by
  5.       the Free Software Foundation; either version 2 of the License, or
  6.       (at your option) any later version.
  7.       This program is distributed in the hope that it will be useful,
  8.       but WITHOUT ANY WARRANTY; without even the implied warranty of
  9.       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10.       GNU General Public License for more details.
  11.       You should have received a copy of the GNU General Public License
  12.       along with this program; if not, write to the Free Software
  13.       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  14.  */
  15. package com.mysql.jdbc;
  16. import java.io.ObjectInputStream;
  17. import java.io.PrintWriter;
  18. import java.io.StringWriter;
  19. /**
  20.  * Various utility methods for the driver.
  21.  *
  22.  * @author Mark Matthews
  23.  */
  24. public class Util {
  25.     private static Util enclosingInstance = new Util();
  26.     /**
  27.      * Given a ResultSet and an index into the columns of that ResultSet,
  28.      * read binary data from the column which represents a serialized object,
  29.      * and re-create the object.
  30.      *
  31.      * @param resultSet the ResultSet to use.
  32.      * @param index an index into the ResultSet.
  33.      * @return the object if it can be de-serialized
  34.      * @throws Exception if an error occurs
  35.      */
  36.     public static Object readObject(java.sql.ResultSet resultSet, int index)
  37.         throws Exception {
  38.         ObjectInputStream objIn = new ObjectInputStream(resultSet
  39.                 .getBinaryStream(index));
  40.         Object obj = objIn.readObject();
  41.         objIn.close();
  42.         return obj;
  43.     }
  44.     /**
  45.      * DOCUMENT ME!
  46.      *
  47.      * @param message DOCUMENT ME!
  48.      * @param password DOCUMENT ME!
  49.      *
  50.      * @return DOCUMENT ME!
  51.      */
  52.     public static String scramble(String message, String password) {
  53.         long[] hashPass;
  54.         long[] hashMessage;
  55.         byte[] to = new byte[8];
  56.         String val = "";
  57.         message = message.substring(0, 8);
  58.         if ((password != null) && (password.length() > 0)) {
  59.             hashPass = newHash(password);
  60.             hashMessage = newHash(message);
  61.             RandStructcture randStruct = randomInit(hashPass[0]
  62.                     ^ hashMessage[0], hashPass[1] ^ hashMessage[1]);
  63.             int msgPos = 0;
  64.             int msgLength = message.length();
  65.             int toPos = 0;
  66.             while (msgPos++ < msgLength) {
  67.                 to[toPos++] = (byte) (Math.floor(rnd(randStruct) * 31) + 64);
  68.             }
  69.             /* Make it harder to break */
  70.             byte extra = (byte) (Math.floor(rnd(randStruct) * 31));
  71.             for (int i = 0; i < to.length; i++) {
  72.                 to[i] ^= extra;
  73.             }
  74.             val = new String(to);
  75.         }
  76.         return val;
  77.     }
  78.     /**
  79.      * Converts a nested exception into a nicer message
  80.      *
  81.      * @param ex the exception to expand into a message.
  82.      *
  83.      * @return a message containing the exception, the
  84.      * message (if any), and a stacktrace.
  85.      */
  86.     public static String stackTraceToString(Throwable ex) {
  87.         StringBuffer traceBuf = new StringBuffer();
  88.         traceBuf.append("nn** BEGIN NESTED EXCEPTION ** nn");
  89.         if (ex != null) {
  90.             traceBuf.append(ex.getClass().getName());
  91.             String message = ex.getMessage();
  92.             if (message != null) {
  93.                 traceBuf.append("nMESSAGE: ");
  94.                 traceBuf.append(message);
  95.             }
  96.             StringWriter out = new StringWriter();
  97.             PrintWriter printOut = new PrintWriter(out);
  98.             ex.printStackTrace(printOut);
  99.             traceBuf.append("nnSTACKTRACE:nn");
  100.             traceBuf.append(out.toString());
  101.         }
  102.         traceBuf.append("nn** END NESTED EXCEPTION **nn");
  103.         return traceBuf.toString();
  104.     }
  105.     // Right from Monty's code
  106.     static String newCrypt(String password, String seed) {
  107.         byte b;
  108.         double d;
  109.         if ((password == null) || (password.length() == 0)) {
  110.             return password;
  111.         }
  112.         long[] pw = newHash(seed);
  113.         long[] msg = newHash(password);
  114.         long max = 0x3fffffffL;
  115.         long seed1 = (pw[0] ^ msg[0]) % max;
  116.         long seed2 = (pw[1] ^ msg[1]) % max;
  117.         char[] chars = new char[seed.length()];
  118.         for (int i = 0; i < seed.length(); i++) {
  119.             seed1 = ((seed1 * 3) + seed2) % max;
  120.             seed2 = (seed1 + seed2 + 33) % max;
  121.             d = (double) seed1 / (double) max;
  122.             b = (byte) java.lang.Math.floor((d * 31) + 64);
  123.             chars[i] = (char) b;
  124.         }
  125.         seed1 = ((seed1 * 3) + seed2) % max;
  126.         seed2 = (seed1 + seed2 + 33) % max;
  127.         d = (double) seed1 / (double) max;
  128.         b = (byte) java.lang.Math.floor(d * 31);
  129.         for (int i = 0; i < seed.length(); i++) {
  130.             chars[i] ^= (char) b;
  131.         }
  132.         return new String(chars);
  133.     }
  134.     static long[] newHash(String password) {
  135.         long nr = 1345345333L;
  136.         long add = 7;
  137.         long nr2 = 0x12345671L;
  138.         long tmp;
  139.         for (int i = 0; i < password.length(); ++i) {
  140.             if ((password.charAt(i) == ' ') || (password.charAt(i) == 't')) {
  141.                 continue; // skip spaces
  142.             }
  143.             tmp = (long) (0xff & password.charAt(i));
  144.             nr ^= ((((nr & 63) + add) * tmp) + (nr << 8));
  145.             nr2 += ((nr2 << 8) ^ nr);
  146.             add += tmp;
  147.         }
  148.         long[] result = new long[2];
  149.         result[0] = nr & 0x7fffffffL;
  150.         result[1] = nr2 & 0x7fffffffL;
  151.         return result;
  152.     }
  153.     static String oldCrypt(String password, String seed) {
  154.         long hp;
  155.         long hm;
  156.         long s1;
  157.         long s2;
  158.         long max = 0x01FFFFFF;
  159.         double d;
  160.         byte b;
  161.         if ((password == null) || (password.length() == 0)) {
  162.             return password;
  163.         }
  164.         hp = oldHash(seed);
  165.         hm = oldHash(password);
  166.         long nr = hp ^ hm;
  167.         nr %= max;
  168.         s1 = nr;
  169.         s2 = nr / 2;
  170.         char[] chars = new char[seed.length()];
  171.         for (int i = 0; i < seed.length(); i++) {
  172.             s1 = ((s1 * 3) + s2) % max;
  173.             s2 = (s1 + s2 + 33) % max;
  174.             d = (double) s1 / max;
  175.             b = (byte) java.lang.Math.floor((d * 31) + 64);
  176.             chars[i] = (char) b;
  177.         }
  178.         return new String(chars);
  179.     }
  180.     static long oldHash(String password) {
  181.         long nr = 1345345333;
  182.         long nr2 = 7;
  183.         long tmp;
  184.         for (int i = 0; i < password.length(); i++) {
  185.             if ((password.charAt(i) == ' ') || (password.charAt(i) == 't')) {
  186.                 continue;
  187.             }
  188.             tmp = (long) password.charAt(i);
  189.             nr ^= ((((nr & 63) + nr2) * tmp) + (nr << 8));
  190.             nr2 += tmp;
  191.         }
  192.         return nr & (((long) 1L << 31) - 1L);
  193.     }
  194.     private static RandStructcture randomInit(long seed1, long seed2) {
  195.         RandStructcture randStruct = enclosingInstance.new RandStructcture();
  196.         randStruct.maxValue = 0x3FFFFFFFL;
  197.         randStruct.maxValueDbl = (double) randStruct.maxValue;
  198.         randStruct.seed1 = seed1 % randStruct.maxValue;
  199.         randStruct.seed2 = seed2 % randStruct.maxValue;
  200.         return randStruct;
  201.     }
  202.     private static double rnd(RandStructcture randStruct) {
  203.         randStruct.seed1 = ((randStruct.seed1 * 3) + randStruct.seed2) % randStruct.maxValue;
  204.         randStruct.seed2 = (randStruct.seed1 + randStruct.seed2 + 33) % randStruct.maxValue;
  205.         return (((double) randStruct.seed1) / randStruct.maxValueDbl);
  206.     }
  207.     class RandStructcture {
  208.         double maxValueDbl;
  209.         long maxValue;
  210.         long seed1;
  211.         long seed2;
  212.     }
  213. }