diff options
Diffstat (limited to 'src/interfaces/jdbc/org/postgresql/util')
9 files changed, 0 insertions, 1694 deletions
diff --git a/src/interfaces/jdbc/org/postgresql/util/MD5Digest.java b/src/interfaces/jdbc/org/postgresql/util/MD5Digest.java deleted file mode 100644 index 86d3b344dbf..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/MD5Digest.java +++ /dev/null @@ -1,90 +0,0 @@ -/*------------------------------------------------------------------------- - * - * MD5Digest.java - * MD5-based utility function to obfuscate passwords before network - * transmission - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/MD5Digest.java,v 1.6 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -/* - * @author Jeremy Wohl - */ - -import java.security.*; - -public class MD5Digest -{ - private MD5Digest() - {} - - - /* - * Encodes user/password/salt information in the following way: - * MD5(MD5(password + user) + salt) - * - * @param user The connecting user. - * @param password The connecting user's password. - * @param salt A four-salt sent by the server. - * - * @return A 35-byte array, comprising the string "md5" and an MD5 digest. - */ - public static byte[] encode(String user, String password, byte []salt) - { - MessageDigest md; - byte[] temp_digest, pass_digest; - byte[] hex_digest = new byte[35]; - - try - { - md = MessageDigest.getInstance("MD5"); - - md.update(password.getBytes()); - md.update(user.getBytes()); - temp_digest = md.digest(); - - bytesToHex(temp_digest, hex_digest, 0); - md.update(hex_digest, 0, 32); - md.update(salt); - pass_digest = md.digest(); - - bytesToHex(pass_digest, hex_digest, 3); - hex_digest[0] = (byte) 'm'; - hex_digest[1] = (byte) 'd'; - hex_digest[2] = (byte) '5'; - } - catch (Exception e) - { - ; // "MessageDigest failure; " + e - } - - return hex_digest; - } - - - /* - * Turn 16-byte stream into a human-readable 32-byte hex string - */ - private static void bytesToHex(byte[] bytes, byte[] hex, int offset) - { - final char lookup[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'a', 'b', 'c', 'd', 'e', 'f' }; - - int i, c, j, pos = offset; - - for (i = 0; i < 16; i++) - { - c = bytes[i] & 0xFF; - j = c >> 4; - hex[pos++] = (byte) lookup[j]; - j = (c & 0xF); - hex[pos++] = (byte) lookup[j]; - } - } -} diff --git a/src/interfaces/jdbc/org/postgresql/util/MessageTranslator.java b/src/interfaces/jdbc/org/postgresql/util/MessageTranslator.java deleted file mode 100644 index 6fa6ef9367a..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/MessageTranslator.java +++ /dev/null @@ -1,97 +0,0 @@ -/*------------------------------------------------------------------------- - * - * MessageTranslator.java - * A singleton class to translate JDBC driver messages in SQLException's. - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/MessageTranslator.java,v 1.6 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -import java.text.MessageFormat; -import java.util.MissingResourceException; -import java.util.ResourceBundle; - -public class MessageTranslator -{ - - // The singleton instance. - private static MessageTranslator instance = null; - - private ResourceBundle bundle; - - private MessageTranslator() - { - try - { - bundle = ResourceBundle.getBundle("org.postgresql.errors"); - } - catch (MissingResourceException e) - { - // translation files have not been installed. - bundle = null; - } - } - - // Synchronized, otherwise multiple threads may perform the test and - // assign to the singleton instance simultaneously. - private synchronized final static MessageTranslator getInstance() - { - if (instance == null) - { - instance = new MessageTranslator(); - } - return instance; - } - - public final static String translate(String id, Object[] args) - { - - MessageTranslator translator = MessageTranslator.getInstance(); - - return translator._translate(id, args); - } - - public final static String translate(String id, Object arg) - { - MessageTranslator translator = MessageTranslator.getInstance(); - Object[] args = new Object[1]; - args[0] = arg; - return translator._translate(id, args); - } - - private final String _translate(String id, Object[] args) - { - String message; - - if (bundle != null && id != null) - { - // Now look up a localized message. If one is not found, then use - // the supplied message instead. - try - { - message = bundle.getString(id); - } - catch (MissingResourceException e) - { - message = id; - } - } - else - { - message = id; - } - - // Expand any arguments - if (args != null && message != null) - { - message = MessageFormat.format(message, args); - } - - return message; - } -} diff --git a/src/interfaces/jdbc/org/postgresql/util/PGbytea.java b/src/interfaces/jdbc/org/postgresql/util/PGbytea.java deleted file mode 100644 index 25cc3e10cad..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/PGbytea.java +++ /dev/null @@ -1,108 +0,0 @@ -/*------------------------------------------------------------------------- - * - * PGbytea.java - * Converts to and from the postgresql bytea datatype used by the backend. - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/PGbytea.java,v 1.9 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -import java.sql.*; - -public class PGbytea -{ - - /* - * Converts a PG bytea raw value (i.e. the raw binary representation - * of the bytea data type) into a java byte[] - */ - public static byte[] toBytes(byte[] s) throws SQLException - { - if (s == null) - return null; - int slength = s.length; - byte[] buf = new byte[slength]; - int bufpos = 0; - int thebyte; - byte nextbyte; - byte secondbyte; - for (int i = 0; i < slength; i++) - { - nextbyte = s[i]; - if (nextbyte == (byte)'\\') - { - secondbyte = s[++i]; - if (secondbyte == (byte)'\\') - { - //escaped \ - buf[bufpos++] = (byte)'\\'; - } - else - { - thebyte = (secondbyte - 48) * 64 + (s[++i] - 48) * 8 + (s[++i] - 48); - if (thebyte > 127) - thebyte -= 256; - buf[bufpos++] = (byte)thebyte; - } - } - else - { - buf[bufpos++] = nextbyte; - } - } - byte[] l_return = new byte[bufpos]; - System.arraycopy(buf, 0, l_return, 0, bufpos); - return l_return; - } - - /* - * Converts a java byte[] into a PG bytea string (i.e. the text - * representation of the bytea data type) - */ - public static String toPGString(byte[] p_buf) throws SQLException - { - if (p_buf == null) - return null; - StringBuffer l_strbuf = new StringBuffer(2 * p_buf.length); - for (int i = 0; i < p_buf.length; i++) - { - int l_int = (int)p_buf[i]; - if (l_int < 0) - { - l_int = 256 + l_int; - } - //we escape the same non-printable characters as the backend - //we must escape all 8bit characters otherwise when convering - //from java unicode to the db character set we may end up with - //question marks if the character set is SQL_ASCII - if (l_int < 040 || l_int > 0176) - { - //escape charcter with the form \000, but need two \\ because of - //the parser - l_strbuf.append("\\"); - l_strbuf.append((char)(((l_int >> 6) & 0x3) + 48)); - l_strbuf.append((char)(((l_int >> 3) & 0x7) + 48)); - l_strbuf.append((char)((l_int & 0x07) + 48)); - } - else if (p_buf[i] == (byte)'\\') - { - //escape the backslash character as \\, but need four \\\\ because - //of the parser - l_strbuf.append("\\\\"); - } - else - { - //other characters are left alone - l_strbuf.append((char)p_buf[i]); - } - } - return l_strbuf.toString(); - } - - -} diff --git a/src/interfaces/jdbc/org/postgresql/util/PGmoney.java b/src/interfaces/jdbc/org/postgresql/util/PGmoney.java deleted file mode 100644 index a68376e0cc1..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/PGmoney.java +++ /dev/null @@ -1,108 +0,0 @@ -/*------------------------------------------------------------------------- - * - * PGmoney.java - * This implements a class that handles the PostgreSQL money and cash types - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/PGmoney.java,v 1.7 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - - -import java.io.Serializable; -import java.sql.SQLException; - -public class PGmoney extends PGobject implements Serializable, Cloneable -{ - /* - * The value of the field - */ - public double val; - - /* - * @param value of field - */ - public PGmoney(double value) - { - this(); - val = value; - } - - public PGmoney(String value) throws SQLException - { - this(); - setValue(value); - } - - /* - * Required by the driver - */ - public PGmoney() - { - setType("money"); - } - - public void setValue(String s) throws SQLException - { - try - { - String s1; - boolean negative; - - negative = (s.charAt(0) == '(') ; - - // Remove any () (for negative) & currency symbol - s1 = PGtokenizer.removePara(s).substring(1); - - // Strip out any , in currency - int pos = s1.indexOf(','); - while (pos != -1) - { - s1 = s1.substring(0, pos) + s1.substring(pos + 1); - pos = s1.indexOf(','); - } - - val = Double.valueOf(s1).doubleValue(); - val = negative ? -val : val; - - } - catch (NumberFormatException e) - { - throw new PSQLException("postgresql.money", PSQLState.NUMERIC_CONSTANT_OUT_OF_RANGE, e); - } - } - - public boolean equals(Object obj) - { - if (obj instanceof PGmoney) - { - PGmoney p = (PGmoney)obj; - return val == p.val; - } - return false; - } - - /* - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - return new PGmoney(val); - } - - public String getValue() - { - if (val < 0) - { - return "-$" + ( -val); - } - else - { - return "$" + val; - } - } -} diff --git a/src/interfaces/jdbc/org/postgresql/util/PGobject.java b/src/interfaces/jdbc/org/postgresql/util/PGobject.java deleted file mode 100644 index 61716638987..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/PGobject.java +++ /dev/null @@ -1,104 +0,0 @@ -/*------------------------------------------------------------------------- - * - * PGobject.java - * PGobject is a class used to describe unknown types - * An unknown type is any type that is unknown by JDBC Standards - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/PGobject.java,v 1.5 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -import java.io.Serializable; -import java.sql.SQLException; - -public class PGobject implements Serializable, Cloneable -{ - protected String type; - protected String value; - - /* - * This is called by org.postgresql.Connection.getObject() to create the - * object. - */ - public PGobject() - {} - - /* - * This method sets the type of this object. - * - * <p>It should not be extended by subclasses, hence its final - * - * @param type a string describing the type of the object - */ - public final void setType(String type) - { - this.type = type; - } - - /* - * This method sets the value of this object. It must be overidden. - * - * @param value a string representation of the value of the object - * @exception SQLException thrown if value is invalid for this type - */ - public void setValue(String value) throws SQLException - { - this.value = value; - } - - /* - * As this cannot change during the life of the object, it's final. - * @return the type name of this object - */ - public final String getType() - { - return type; - } - - /* - * This must be overidden, to return the value of the object, in the - * form required by org.postgresql. - * @return the value of this object - */ - public String getValue() - { - return value; - } - - /* - * This must be overidden to allow comparisons of objects - * @param obj Object to compare with - * @return true if the two boxes are identical - */ - public boolean equals(Object obj) - { - if (obj instanceof PGobject) - return ((PGobject)obj).getValue().equals(getValue()); - return false; - } - - /* - * This must be overidden to allow the object to be cloned - */ - public Object clone() - { - PGobject obj = new PGobject(); - obj.type = type; - obj.value = value; - return obj; - } - - /* - * This is defined here, so user code need not overide it. - * @return the value of this object, in the syntax expected by org.postgresql - */ - public String toString() - { - return getValue(); - } -} diff --git a/src/interfaces/jdbc/org/postgresql/util/PGtokenizer.java b/src/interfaces/jdbc/org/postgresql/util/PGtokenizer.java deleted file mode 100644 index cf33d3d2059..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/PGtokenizer.java +++ /dev/null @@ -1,214 +0,0 @@ -/*------------------------------------------------------------------------- - * - * PGtokenizer.java - * This class is used to tokenize the text output of org.postgres. - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/PGtokenizer.java,v 1.8 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -import java.util.Vector; - -/* - * It's mainly used by the geometric classes, but is useful in parsing any - * output from custom data types output from org.postgresql. - * - * @see org.postgresql.geometric.PGbox - * @see org.postgresql.geometric.PGcircle - * @see org.postgresql.geometric.PGlseg - * @see org.postgresql.geometric.PGpath - * @see org.postgresql.geometric.PGpoint - * @see org.postgresql.geometric.PGpolygon - */ -public class PGtokenizer -{ - // Our tokens - protected Vector tokens; - - /* - * Create a tokeniser. - * - * <p>We could have used StringTokenizer to do this, however, we needed to - * handle nesting of '(' ')' '[' ']' '<' and '>' as these are used - * by the geometric data types. - * - * @param string containing tokens - * @param delim single character to split the tokens - */ - public PGtokenizer(String string, char delim) - { - tokenize(string, delim); - } - - /* - * This resets this tokenizer with a new string and/or delimiter. - * - * @param string containing tokens - * @param delim single character to split the tokens - */ - public int tokenize(String string, char delim) - { - tokens = new Vector(); - - // nest holds how many levels we are in the current token. - // if this is > 0 then we don't split a token when delim is matched. - // - // The Geometric datatypes use this, because often a type may have others - // (usualls PGpoint) imbedded within a token. - // - // Peter 1998 Jan 6 - Added < and > to the nesting rules - int nest = 0, p, s; - - for (p = 0, s = 0;p < string.length();p++) - { - char c = string.charAt(p); - - // increase nesting if an open character is found - if (c == '(' || c == '[' || c == '<') - nest++; - - // decrease nesting if a close character is found - if (c == ')' || c == ']' || c == '>') - nest--; - - if (nest == 0 && c == delim) - { - tokens.addElement(string.substring(s, p)); - s = p + 1; // +1 to skip the delimiter - } - - } - - // Don't forget the last token ;-) - - - - if (s < string.length()) - tokens.addElement(string.substring(s)); - - return tokens.size(); - } - - /* - * @return the number of tokens available - */ - public int getSize() - { - return tokens.size(); - } - - /* - * @param n Token number ( 0 ... getSize()-1 ) - * @return The token value - */ - public String getToken(int n) - { - return (String)tokens.elementAt(n); - } - - /* - * This returns a new tokenizer based on one of our tokens. - * - * The geometric datatypes use this to process nested tokens (usually - * PGpoint). - * - * @param n Token number ( 0 ... getSize()-1 ) - * @param delim The delimiter to use - * @return A new instance of PGtokenizer based on the token - */ - public PGtokenizer tokenizeToken(int n, char delim) - { - return new PGtokenizer(getToken(n), delim); - } - - /* - * This removes the lead/trailing strings from a string - * @param s Source string - * @param l Leading string to remove - * @param t Trailing string to remove - * @return String without the lead/trailing strings - */ - public static String remove(String s, String l, String t) - { - if (s.startsWith(l)) - s = s.substring(l.length()); - if (s.endsWith(t)) - s = s.substring(0, s.length() - t.length()); - return s; - } - - /* - * This removes the lead/trailing strings from all tokens - * @param l Leading string to remove - * @param t Trailing string to remove - */ - public void remove(String l, String t) - { - for (int i = 0;i < tokens.size();i++) - { - tokens.setElementAt(remove((String)tokens.elementAt(i), l, t), i); - } - } - - /* - * Removes ( and ) from the beginning and end of a string - * @param s String to remove from - * @return String without the ( or ) - */ - public static String removePara(String s) - { - return remove(s, "(", ")"); - } - - /* - * Removes ( and ) from the beginning and end of all tokens - * @return String without the ( or ) - */ - public void removePara() - { - remove("(", ")"); - } - - /* - * Removes [ and ] from the beginning and end of a string - * @param s String to remove from - * @return String without the [ or ] - */ - public static String removeBox(String s) - { - return remove(s, "[", "]"); - } - - /* - * Removes [ and ] from the beginning and end of all tokens - * @return String without the [ or ] - */ - public void removeBox() - { - remove("[", "]"); - } - - /* - * Removes < and > from the beginning and end of a string - * @param s String to remove from - * @return String without the < or > - */ - public static String removeAngle(String s) - { - return remove(s, "<", ">"); - } - - /* - * Removes < and > from the beginning and end of all tokens - * @return String without the < or > - */ - public void removeAngle() - { - remove("<", ">"); - } -} diff --git a/src/interfaces/jdbc/org/postgresql/util/PSQLException.java b/src/interfaces/jdbc/org/postgresql/util/PSQLException.java deleted file mode 100644 index c085139acf3..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/PSQLException.java +++ /dev/null @@ -1,231 +0,0 @@ -/*------------------------------------------------------------------------- - * - * PSQLException.java - * This class extends SQLException, and provides our internationalisation - * handling - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/PSQLException.java,v 1.15 2003/12/12 18:36:20 davec Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -import java.io.ByteArrayOutputStream; -import java.io.PrintWriter; -import java.sql.SQLException; -import java.util.Hashtable; -import org.postgresql.Driver; - -public class PSQLException extends SQLException -{ - private String message; - private PSQLState state; - - //-------start new constructors------- - - public PSQLException(String msg, PSQLState state) - { - this.state = state; - translate(msg, null); - if (Driver.logDebug) - Driver.debug("Exception: " + this); - } - - public PSQLException(String msg, PSQLState state, Object[] argv) - { - this.state = state; - translate(msg, argv); - if (Driver.logDebug) - Driver.debug("Exception: " + this); - } - - //Helper version for one arg - public PSQLException(String msg, PSQLState state, Object arg1) - { - this.state = state; - Object[] argv = new Object[1]; - argv[0] = arg1; - translate(msg, argv); - if (Driver.logDebug) - Driver.debug("Exception: " + this); - } - - //Helper version for two args - public PSQLException(String msg, PSQLState state, Object arg1, Object arg2) - { - this.state = state; - Object[] argv = new Object[2]; - argv[0] = arg1; - argv[1] = arg2; - translate(msg, argv); - if (Driver.logDebug) - Driver.debug("Exception: " + this); - } - - //-------end new constructors------- - - public static PSQLException parseServerError(String p_serverError) - { - if (Driver.logDebug) - Driver.debug("Constructing exception from server message: " + p_serverError); - char[] l_chars = p_serverError.toCharArray(); - int l_pos = 0; - int l_length = l_chars.length; - Hashtable l_mesgParts = new Hashtable(); - while (l_pos < l_length) { - char l_mesgType = l_chars[l_pos]; - if (l_mesgType != '\0') { - l_pos++; - int l_startString = l_pos; - while (l_chars[l_pos] != '\0' && l_pos < l_length) { - l_pos++; - } - String l_mesgPart = new String(l_chars, l_startString, l_pos - l_startString); - l_mesgParts.put(new Character(l_mesgType),l_mesgPart); - } - l_pos++; - } - - //Now construct the message from what the server sent - //The general format is: - //SEVERITY: Message \n - // Detail: \n - // Hint: \n - // Position: \n - // Where: \n - // Location: File:Line:Routine \n - // SQLState: \n - // - //Normally only the message and detail is included. - //If INFO level logging is enabled then detail, hint, position and where are - //included. If DEBUG level logging is enabled then all information - //is included. - - StringBuffer l_totalMessage = new StringBuffer(); - String l_message = (String)l_mesgParts.get(MESSAGE_TYPE_S); - if (l_message != null) - l_totalMessage.append(l_message).append(": "); - l_message = (String)l_mesgParts.get(MESSAGE_TYPE_M); - if (l_message != null) - l_totalMessage.append(l_message).append('\n'); - if (Driver.logInfo) { - l_message = (String)l_mesgParts.get(MESSAGE_TYPE_D); - if (l_message != null) - l_totalMessage.append(" ").append(MessageTranslator.translate("postgresql.error.detail", l_message)).append('\n'); - l_message = (String)l_mesgParts.get(MESSAGE_TYPE_H); - if (l_message != null) - l_totalMessage.append(" ").append(MessageTranslator.translate("postgresql.error.hint", l_message)).append('\n'); - l_message = (String)l_mesgParts.get(MESSAGE_TYPE_P); - if (l_message != null) - l_totalMessage.append(" ").append(MessageTranslator.translate("postgresql.error.position", l_message)).append('\n'); - l_message = (String)l_mesgParts.get(MESSAGE_TYPE_W); - if (l_message != null) - l_totalMessage.append(" ").append(MessageTranslator.translate("postgresql.error.where", l_message)).append('\n'); - } - if (Driver.logDebug) { - String l_file = (String)l_mesgParts.get(MESSAGE_TYPE_F); - String l_line = (String)l_mesgParts.get(MESSAGE_TYPE_L); - String l_routine = (String)l_mesgParts.get(MESSAGE_TYPE_R); - if (l_file != null || l_line != null || l_routine != null) - l_totalMessage.append(" ").append(MessageTranslator.translate("postgresql.error.location", l_file+":"+l_line+":"+l_routine)).append('\n'); - l_message = (String)l_mesgParts.get(MESSAGE_TYPE_C); - if (l_message != null) - l_totalMessage.append(" ").append("ServerSQLState: " + l_message).append('\n'); - } - - PSQLException l_return = new PSQLException(l_totalMessage.toString(), PSQLState.UNKNOWN_STATE); - l_return.state = new PSQLState((String)l_mesgParts.get(MESSAGE_TYPE_C)); - return l_return; - } - - private static final Character MESSAGE_TYPE_S = new Character('S'); - private static final Character MESSAGE_TYPE_M = new Character('M'); - private static final Character MESSAGE_TYPE_D = new Character('D'); - private static final Character MESSAGE_TYPE_H = new Character('H'); - private static final Character MESSAGE_TYPE_P = new Character('P'); - private static final Character MESSAGE_TYPE_W = new Character('W'); - private static final Character MESSAGE_TYPE_F = new Character('F'); - private static final Character MESSAGE_TYPE_L = new Character('L'); - private static final Character MESSAGE_TYPE_R = new Character('R'); - private static final Character MESSAGE_TYPE_C = new Character('C'); - - /* - * This provides the same functionality to SQLException - * @param error Error string - */ - public PSQLException(String error) - { - translate(error, null); - if (Driver.logDebug) - Driver.debug("Exception: " + this); - } - - /* - * Helper version for 1 arg - */ - public PSQLException(String error, Object arg) - { - Object[] argv = new Object[1]; - argv[0] = arg; - translate(error, argv); - if (Driver.logDebug) - Driver.debug("Exception: " + this); - } - - - private void translate(String error, Object[] args) { - //We convert exception objects to Strings that - //contain the full stack trace - if (args != null) { - for (int i = 0; i < args.length; i++) { - if (args[i] instanceof Exception && !(args[i] instanceof PSQLException)) { - Exception ex = (Exception) args[i]; - try { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - PrintWriter pw = new PrintWriter(baos); - pw.println("Exception: " + ex.toString() + "\nStack Trace:\n"); - ex.printStackTrace(pw); - pw.println("End of Stack Trace"); - pw.flush(); - args[i] = baos.toString(); - pw.close(); - baos.close(); - } - catch (Exception ioe) - { - args[i] = ex.toString() + "\nIO Error on stack trace generation! " + ioe.toString(); - } - } - } - } - - message = MessageTranslator.translate(error, args); - - } - - /* - * Overides Throwable - */ - public String getLocalizedMessage() - { - return message; - } - - /* - * Overides Throwable - */ - public String getMessage() - { - return message; - } - - public String getSQLState() - { - if (state == null) - return PSQLState.UNKNOWN_STATE.getState(); - return state.getState(); - } -} diff --git a/src/interfaces/jdbc/org/postgresql/util/PSQLState.java b/src/interfaces/jdbc/org/postgresql/util/PSQLState.java deleted file mode 100644 index b1d1efa63e3..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/PSQLState.java +++ /dev/null @@ -1,51 +0,0 @@ -/*------------------------------------------------------------------------- - * - * PSQLState.java - * This class is used for holding SQLState codes. - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - *------------------------------------------------------------------------- - */ - - package org.postgresql.util; - - public class PSQLState implements java.io.Serializable - { - private String state; - - public String getState() - { - return this.state; - } - - public PSQLState(String state) - { - this.state = state; - } - - - // begin constant state codes - public final static PSQLState UNKNOWN_STATE = new PSQLState(""); - public final static PSQLState NO_DATA = new PSQLState("02000"); - public final static PSQLState INVALID_PARAMETER_TYPE = new PSQLState("07006"); - public final static PSQLState CONNECTION_UNABLE_TO_CONNECT = new PSQLState("08001"); - public final static PSQLState CONNECTION_DOES_NOT_EXIST = new PSQLState("08003"); - public final static PSQLState CONNECTION_REJECTED = new PSQLState("08004"); - public final static PSQLState CONNECTION_FAILURE = new PSQLState("08006"); - public final static PSQLState CONNECTION_FAILURE_DURING_TRANSACTION = new PSQLState("08007"); - public final static PSQLState COMMUNICATION_ERROR = new PSQLState("08S01"); - public final static PSQLState NOT_IMPLEMENTED = new PSQLState("0A000"); - public final static PSQLState DATA_ERROR = new PSQLState("22000"); - public final static PSQLState NUMERIC_VALUE_OUT_OF_RANGE = new PSQLState("22003"); - public final static PSQLState BAD_DATETIME_FORMAT = new PSQLState("22007"); - public final static PSQLState MOST_SPECIFIC_TYPE_DOES_NOT_MATCH = new PSQLState("2200G"); - public final static PSQLState INVALID_PARAMETER_VALUE = new PSQLState("22023"); - public final static PSQLState TRANSACTION_STATE_INVALID = new PSQLState("25000"); - public final static PSQLState STATEMENT_NOT_ALLOWED_IN_FUNCTION_CALL = new PSQLState("2F003"); - public final static PSQLState NUMERIC_CONSTANT_OUT_OF_RANGE = new PSQLState("42820'"); - public final static PSQLState DATA_TYPE_MISMATCH = new PSQLState("42821"); - public final static PSQLState SYSTEM_ERROR = new PSQLState("60000"); - public final static PSQLState UNEXPECTED_ERROR = new PSQLState("99999"); - -} diff --git a/src/interfaces/jdbc/org/postgresql/util/UnixCrypt.java b/src/interfaces/jdbc/org/postgresql/util/UnixCrypt.java deleted file mode 100644 index b7fa9ce60f8..00000000000 --- a/src/interfaces/jdbc/org/postgresql/util/UnixCrypt.java +++ /dev/null @@ -1,691 +0,0 @@ -/*------------------------------------------------------------------------- - * - * UnixCrypt.java - * Contains static methods to encrypt and compare - * passwords with Unix encrypted passwords. - * - * Copyright (c) 2003, PostgreSQL Global Development Group - * - * IDENTIFICATION - * $PostgreSQL: pgsql/src/interfaces/jdbc/org/postgresql/util/UnixCrypt.java,v 1.5 2003/11/29 19:52:11 pgsql Exp $ - * - *------------------------------------------------------------------------- - */ -package org.postgresql.util; - -/* - * <P>See <A HREF="http://www.zeh.com/local/jfd/crypt.html"> - * John Dumas's Java Crypt page</A> for the original source.</P> - * - * @author jdumas@zgs.com (John Dumas) - */ -public class UnixCrypt extends Object -{ - // - // Null constructor - can't instantiate class - private UnixCrypt() - {} - - private static final char[] saltChars = - ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./".toCharArray()); - - private static final int ITERATIONS = 16; - - private static final int con_salt[] = - { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, - 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, - 0x0A, 0x0B, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, - 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, - 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, - 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, - 0x23, 0x24, 0x25, 0x20, 0x21, 0x22, 0x23, 0x24, - 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, - 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, - 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, - 0x3D, 0x3E, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, - }; - - private static final boolean shifts2[] = - { - false, false, true, true, true, true, true, true, - false, true, true, true, true, true, true, false - }; - - private static final int skb[][] = - { - { - /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ - 0x00000000, 0x00000010, 0x20000000, 0x20000010, - 0x00010000, 0x00010010, 0x20010000, 0x20010010, - 0x00000800, 0x00000810, 0x20000800, 0x20000810, - 0x00010800, 0x00010810, 0x20010800, 0x20010810, - 0x00000020, 0x00000030, 0x20000020, 0x20000030, - 0x00010020, 0x00010030, 0x20010020, 0x20010030, - 0x00000820, 0x00000830, 0x20000820, 0x20000830, - 0x00010820, 0x00010830, 0x20010820, 0x20010830, - 0x00080000, 0x00080010, 0x20080000, 0x20080010, - 0x00090000, 0x00090010, 0x20090000, 0x20090010, - 0x00080800, 0x00080810, 0x20080800, 0x20080810, - 0x00090800, 0x00090810, 0x20090800, 0x20090810, - 0x00080020, 0x00080030, 0x20080020, 0x20080030, - 0x00090020, 0x00090030, 0x20090020, 0x20090030, - 0x00080820, 0x00080830, 0x20080820, 0x20080830, - 0x00090820, 0x00090830, 0x20090820, 0x20090830, - }, - { - /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */ - 0x00000000, 0x02000000, 0x00002000, 0x02002000, - 0x00200000, 0x02200000, 0x00202000, 0x02202000, - 0x00000004, 0x02000004, 0x00002004, 0x02002004, - 0x00200004, 0x02200004, 0x00202004, 0x02202004, - 0x00000400, 0x02000400, 0x00002400, 0x02002400, - 0x00200400, 0x02200400, 0x00202400, 0x02202400, - 0x00000404, 0x02000404, 0x00002404, 0x02002404, - 0x00200404, 0x02200404, 0x00202404, 0x02202404, - 0x10000000, 0x12000000, 0x10002000, 0x12002000, - 0x10200000, 0x12200000, 0x10202000, 0x12202000, - 0x10000004, 0x12000004, 0x10002004, 0x12002004, - 0x10200004, 0x12200004, 0x10202004, 0x12202004, - 0x10000400, 0x12000400, 0x10002400, 0x12002400, - 0x10200400, 0x12200400, 0x10202400, 0x12202400, - 0x10000404, 0x12000404, 0x10002404, 0x12002404, - 0x10200404, 0x12200404, 0x10202404, 0x12202404, - }, - { - /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */ - 0x00000000, 0x00000001, 0x00040000, 0x00040001, - 0x01000000, 0x01000001, 0x01040000, 0x01040001, - 0x00000002, 0x00000003, 0x00040002, 0x00040003, - 0x01000002, 0x01000003, 0x01040002, 0x01040003, - 0x00000200, 0x00000201, 0x00040200, 0x00040201, - 0x01000200, 0x01000201, 0x01040200, 0x01040201, - 0x00000202, 0x00000203, 0x00040202, 0x00040203, - 0x01000202, 0x01000203, 0x01040202, 0x01040203, - 0x08000000, 0x08000001, 0x08040000, 0x08040001, - 0x09000000, 0x09000001, 0x09040000, 0x09040001, - 0x08000002, 0x08000003, 0x08040002, 0x08040003, - 0x09000002, 0x09000003, 0x09040002, 0x09040003, - 0x08000200, 0x08000201, 0x08040200, 0x08040201, - 0x09000200, 0x09000201, 0x09040200, 0x09040201, - 0x08000202, 0x08000203, 0x08040202, 0x08040203, - 0x09000202, 0x09000203, 0x09040202, 0x09040203, - }, - { - /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */ - 0x00000000, 0x00100000, 0x00000100, 0x00100100, - 0x00000008, 0x00100008, 0x00000108, 0x00100108, - 0x00001000, 0x00101000, 0x00001100, 0x00101100, - 0x00001008, 0x00101008, 0x00001108, 0x00101108, - 0x04000000, 0x04100000, 0x04000100, 0x04100100, - 0x04000008, 0x04100008, 0x04000108, 0x04100108, - 0x04001000, 0x04101000, 0x04001100, 0x04101100, - 0x04001008, 0x04101008, 0x04001108, 0x04101108, - 0x00020000, 0x00120000, 0x00020100, 0x00120100, - 0x00020008, 0x00120008, 0x00020108, 0x00120108, - 0x00021000, 0x00121000, 0x00021100, 0x00121100, - 0x00021008, 0x00121008, 0x00021108, 0x00121108, - 0x04020000, 0x04120000, 0x04020100, 0x04120100, - 0x04020008, 0x04120008, 0x04020108, 0x04120108, - 0x04021000, 0x04121000, 0x04021100, 0x04121100, - 0x04021008, 0x04121008, 0x04021108, 0x04121108, - }, - { - /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */ - 0x00000000, 0x10000000, 0x00010000, 0x10010000, - 0x00000004, 0x10000004, 0x00010004, 0x10010004, - 0x20000000, 0x30000000, 0x20010000, 0x30010000, - 0x20000004, 0x30000004, 0x20010004, 0x30010004, - 0x00100000, 0x10100000, 0x00110000, 0x10110000, - 0x00100004, 0x10100004, 0x00110004, 0x10110004, - 0x20100000, 0x30100000, 0x20110000, 0x30110000, - 0x20100004, 0x30100004, 0x20110004, 0x30110004, - 0x00001000, 0x10001000, 0x00011000, 0x10011000, - 0x00001004, 0x10001004, 0x00011004, 0x10011004, - 0x20001000, 0x30001000, 0x20011000, 0x30011000, - 0x20001004, 0x30001004, 0x20011004, 0x30011004, - 0x00101000, 0x10101000, 0x00111000, 0x10111000, - 0x00101004, 0x10101004, 0x00111004, 0x10111004, - 0x20101000, 0x30101000, 0x20111000, 0x30111000, - 0x20101004, 0x30101004, 0x20111004, 0x30111004, - }, - { - /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */ - 0x00000000, 0x08000000, 0x00000008, 0x08000008, - 0x00000400, 0x08000400, 0x00000408, 0x08000408, - 0x00020000, 0x08020000, 0x00020008, 0x08020008, - 0x00020400, 0x08020400, 0x00020408, 0x08020408, - 0x00000001, 0x08000001, 0x00000009, 0x08000009, - 0x00000401, 0x08000401, 0x00000409, 0x08000409, - 0x00020001, 0x08020001, 0x00020009, 0x08020009, - 0x00020401, 0x08020401, 0x00020409, 0x08020409, - 0x02000000, 0x0A000000, 0x02000008, 0x0A000008, - 0x02000400, 0x0A000400, 0x02000408, 0x0A000408, - 0x02020000, 0x0A020000, 0x02020008, 0x0A020008, - 0x02020400, 0x0A020400, 0x02020408, 0x0A020408, - 0x02000001, 0x0A000001, 0x02000009, 0x0A000009, - 0x02000401, 0x0A000401, 0x02000409, 0x0A000409, - 0x02020001, 0x0A020001, 0x02020009, 0x0A020009, - 0x02020401, 0x0A020401, 0x02020409, 0x0A020409, - }, - { - /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */ - 0x00000000, 0x00000100, 0x00080000, 0x00080100, - 0x01000000, 0x01000100, 0x01080000, 0x01080100, - 0x00000010, 0x00000110, 0x00080010, 0x00080110, - 0x01000010, 0x01000110, 0x01080010, 0x01080110, - 0x00200000, 0x00200100, 0x00280000, 0x00280100, - 0x01200000, 0x01200100, 0x01280000, 0x01280100, - 0x00200010, 0x00200110, 0x00280010, 0x00280110, - 0x01200010, 0x01200110, 0x01280010, 0x01280110, - 0x00000200, 0x00000300, 0x00080200, 0x00080300, - 0x01000200, 0x01000300, 0x01080200, 0x01080300, - 0x00000210, 0x00000310, 0x00080210, 0x00080310, - 0x01000210, 0x01000310, 0x01080210, 0x01080310, - 0x00200200, 0x00200300, 0x00280200, 0x00280300, - 0x01200200, 0x01200300, 0x01280200, 0x01280300, - 0x00200210, 0x00200310, 0x00280210, 0x00280310, - 0x01200210, 0x01200310, 0x01280210, 0x01280310, - }, - { - /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */ - 0x00000000, 0x04000000, 0x00040000, 0x04040000, - 0x00000002, 0x04000002, 0x00040002, 0x04040002, - 0x00002000, 0x04002000, 0x00042000, 0x04042000, - 0x00002002, 0x04002002, 0x00042002, 0x04042002, - 0x00000020, 0x04000020, 0x00040020, 0x04040020, - 0x00000022, 0x04000022, 0x00040022, 0x04040022, - 0x00002020, 0x04002020, 0x00042020, 0x04042020, - 0x00002022, 0x04002022, 0x00042022, 0x04042022, - 0x00000800, 0x04000800, 0x00040800, 0x04040800, - 0x00000802, 0x04000802, 0x00040802, 0x04040802, - 0x00002800, 0x04002800, 0x00042800, 0x04042800, - 0x00002802, 0x04002802, 0x00042802, 0x04042802, - 0x00000820, 0x04000820, 0x00040820, 0x04040820, - 0x00000822, 0x04000822, 0x00040822, 0x04040822, - 0x00002820, 0x04002820, 0x00042820, 0x04042820, - 0x00002822, 0x04002822, 0x00042822, 0x04042822, - }, - }; - - private static final int SPtrans[][] = - { - { - /* nibble 0 */ - 0x00820200, 0x00020000, 0x80800000, 0x80820200, - 0x00800000, 0x80020200, 0x80020000, 0x80800000, - 0x80020200, 0x00820200, 0x00820000, 0x80000200, - 0x80800200, 0x00800000, 0x00000000, 0x80020000, - 0x00020000, 0x80000000, 0x00800200, 0x00020200, - 0x80820200, 0x00820000, 0x80000200, 0x00800200, - 0x80000000, 0x00000200, 0x00020200, 0x80820000, - 0x00000200, 0x80800200, 0x80820000, 0x00000000, - 0x00000000, 0x80820200, 0x00800200, 0x80020000, - 0x00820200, 0x00020000, 0x80000200, 0x00800200, - 0x80820000, 0x00000200, 0x00020200, 0x80800000, - 0x80020200, 0x80000000, 0x80800000, 0x00820000, - 0x80820200, 0x00020200, 0x00820000, 0x80800200, - 0x00800000, 0x80000200, 0x80020000, 0x00000000, - 0x00020000, 0x00800000, 0x80800200, 0x00820200, - 0x80000000, 0x80820000, 0x00000200, 0x80020200, - }, - { - /* nibble 1 */ - 0x10042004, 0x00000000, 0x00042000, 0x10040000, - 0x10000004, 0x00002004, 0x10002000, 0x00042000, - 0x00002000, 0x10040004, 0x00000004, 0x10002000, - 0x00040004, 0x10042000, 0x10040000, 0x00000004, - 0x00040000, 0x10002004, 0x10040004, 0x00002000, - 0x00042004, 0x10000000, 0x00000000, 0x00040004, - 0x10002004, 0x00042004, 0x10042000, 0x10000004, - 0x10000000, 0x00040000, 0x00002004, 0x10042004, - 0x00040004, 0x10042000, 0x10002000, 0x00042004, - 0x10042004, 0x00040004, 0x10000004, 0x00000000, - 0x10000000, 0x00002004, 0x00040000, 0x10040004, - 0x00002000, 0x10000000, 0x00042004, 0x10002004, - 0x10042000, 0x00002000, 0x00000000, 0x10000004, - 0x00000004, 0x10042004, 0x00042000, 0x10040000, - 0x10040004, 0x00040000, 0x00002004, 0x10002000, - 0x10002004, 0x00000004, 0x10040000, 0x00042000, - }, - { - /* nibble 2 */ - 0x41000000, 0x01010040, 0x00000040, 0x41000040, - 0x40010000, 0x01000000, 0x41000040, 0x00010040, - 0x01000040, 0x00010000, 0x01010000, 0x40000000, - 0x41010040, 0x40000040, 0x40000000, 0x41010000, - 0x00000000, 0x40010000, 0x01010040, 0x00000040, - 0x40000040, 0x41010040, 0x00010000, 0x41000000, - 0x41010000, 0x01000040, 0x40010040, 0x01010000, - 0x00010040, 0x00000000, 0x01000000, 0x40010040, - 0x01010040, 0x00000040, 0x40000000, 0x00010000, - 0x40000040, 0x40010000, 0x01010000, 0x41000040, - 0x00000000, 0x01010040, 0x00010040, 0x41010000, - 0x40010000, 0x01000000, 0x41010040, 0x40000000, - 0x40010040, 0x41000000, 0x01000000, 0x41010040, - 0x00010000, 0x01000040, 0x41000040, 0x00010040, - 0x01000040, 0x00000000, 0x41010000, 0x40000040, - 0x41000000, 0x40010040, 0x00000040, 0x01010000, - }, - { - /* nibble 3 */ - 0x00100402, 0x04000400, 0x00000002, 0x04100402, - 0x00000000, 0x04100000, 0x04000402, 0x00100002, - 0x04100400, 0x04000002, 0x04000000, 0x00000402, - 0x04000002, 0x00100402, 0x00100000, 0x04000000, - 0x04100002, 0x00100400, 0x00000400, 0x00000002, - 0x00100400, 0x04000402, 0x04100000, 0x00000400, - 0x00000402, 0x00000000, 0x00100002, 0x04100400, - 0x04000400, 0x04100002, 0x04100402, 0x00100000, - 0x04100002, 0x00000402, 0x00100000, 0x04000002, - 0x00100400, 0x04000400, 0x00000002, 0x04100000, - 0x04000402, 0x00000000, 0x00000400, 0x00100002, - 0x00000000, 0x04100002, 0x04100400, 0x00000400, - 0x04000000, 0x04100402, 0x00100402, 0x00100000, - 0x04100402, 0x00000002, 0x04000400, 0x00100402, - 0x00100002, 0x00100400, 0x04100000, 0x04000402, - 0x00000402, 0x04000000, 0x04000002, 0x04100400, - }, - { - /* nibble 4 */ - 0x02000000, 0x00004000, 0x00000100, 0x02004108, - 0x02004008, 0x02000100, 0x00004108, 0x02004000, - 0x00004000, 0x00000008, 0x02000008, 0x00004100, - 0x02000108, 0x02004008, 0x02004100, 0x00000000, - 0x00004100, 0x02000000, 0x00004008, 0x00000108, - 0x02000100, 0x00004108, 0x00000000, 0x02000008, - 0x00000008, 0x02000108, 0x02004108, 0x00004008, - 0x02004000, 0x00000100, 0x00000108, 0x02004100, - 0x02004100, 0x02000108, 0x00004008, 0x02004000, - 0x00004000, 0x00000008, 0x02000008, 0x02000100, - 0x02000000, 0x00004100, 0x02004108, 0x00000000, - 0x00004108, 0x02000000, 0x00000100, 0x00004008, - 0x02000108, 0x00000100, 0x00000000, 0x02004108, - 0x02004008, 0x02004100, 0x00000108, 0x00004000, - 0x00004100, 0x02004008, 0x02000100, 0x00000108, - 0x00000008, 0x00004108, 0x02004000, 0x02000008, - }, - { - /* nibble 5 */ - 0x20000010, 0x00080010, 0x00000000, 0x20080800, - 0x00080010, 0x00000800, 0x20000810, 0x00080000, - 0x00000810, 0x20080810, 0x00080800, 0x20000000, - 0x20000800, 0x20000010, 0x20080000, 0x00080810, - 0x00080000, 0x20000810, 0x20080010, 0x00000000, - 0x00000800, 0x00000010, 0x20080800, 0x20080010, - 0x20080810, 0x20080000, 0x20000000, 0x00000810, - 0x00000010, 0x00080800, 0x00080810, 0x20000800, - 0x00000810, 0x20000000, 0x20000800, 0x00080810, - 0x20080800, 0x00080010, 0x00000000, 0x20000800, - 0x20000000, 0x00000800, 0x20080010, 0x00080000, - 0x00080010, 0x20080810, 0x00080800, 0x00000010, - 0x20080810, 0x00080800, 0x00080000, 0x20000810, - 0x20000010, 0x20080000, 0x00080810, 0x00000000, - 0x00000800, 0x20000010, 0x20000810, 0x20080800, - 0x20080000, 0x00000810, 0x00000010, 0x20080010, - }, - { - /* nibble 6 */ - 0x00001000, 0x00000080, 0x00400080, 0x00400001, - 0x00401081, 0x00001001, 0x00001080, 0x00000000, - 0x00400000, 0x00400081, 0x00000081, 0x00401000, - 0x00000001, 0x00401080, 0x00401000, 0x00000081, - 0x00400081, 0x00001000, 0x00001001, 0x00401081, - 0x00000000, 0x00400080, 0x00400001, 0x00001080, - 0x00401001, 0x00001081, 0x00401080, 0x00000001, - 0x00001081, 0x00401001, 0x00000080, 0x00400000, - 0x00001081, 0x00401000, 0x00401001, 0x00000081, - 0x00001000, 0x00000080, 0x00400000, 0x00401001, - 0x00400081, 0x00001081, 0x00001080, 0x00000000, - 0x00000080, 0x00400001, 0x00000001, 0x00400080, - 0x00000000, 0x00400081, 0x00400080, 0x00001080, - 0x00000081, 0x00001000, 0x00401081, 0x00400000, - 0x00401080, 0x00000001, 0x00001001, 0x00401081, - 0x00400001, 0x00401080, 0x00401000, 0x00001001, - }, - { - /* nibble 7 */ - 0x08200020, 0x08208000, 0x00008020, 0x00000000, - 0x08008000, 0x00200020, 0x08200000, 0x08208020, - 0x00000020, 0x08000000, 0x00208000, 0x00008020, - 0x00208020, 0x08008020, 0x08000020, 0x08200000, - 0x00008000, 0x00208020, 0x00200020, 0x08008000, - 0x08208020, 0x08000020, 0x00000000, 0x00208000, - 0x08000000, 0x00200000, 0x08008020, 0x08200020, - 0x00200000, 0x00008000, 0x08208000, 0x00000020, - 0x00200000, 0x00008000, 0x08000020, 0x08208020, - 0x00008020, 0x08000000, 0x00000000, 0x00208000, - 0x08200020, 0x08008020, 0x08008000, 0x00200020, - 0x08208000, 0x00000020, 0x00200020, 0x08008000, - 0x08208020, 0x00200000, 0x08200000, 0x08000020, - 0x00208000, 0x00008020, 0x08008020, 0x08200000, - 0x00000020, 0x08208000, 0x00208020, 0x00000000, - 0x08000000, 0x08200020, 0x00008000, 0x00208020 - } - }; - - private static final int cov_2char[] = - { - 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, - 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, - 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, - 0x4D, 0x4E, 0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, - 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, - 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, - 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, - 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A - }; - - private static final int byteToUnsigned(byte b) - { - int value = (int)b; - - return (value >= 0 ? value : value + 256); - } - - private static int fourBytesToInt(byte b[], int offset) - { - int value; - - value = byteToUnsigned(b[offset++]); - value |= (byteToUnsigned(b[offset++]) << 8); - value |= (byteToUnsigned(b[offset++]) << 16); - value |= (byteToUnsigned(b[offset++]) << 24); - - return (value); - } - - private static final void intToFourBytes(int iValue, byte b[], int offset) - { - b[offset++] = (byte)((iValue) & 0xff); - b[offset++] = (byte)((iValue >>> 8 ) & 0xff); - b[offset++] = (byte)((iValue >>> 16) & 0xff); - b[offset++] = (byte)((iValue >>> 24) & 0xff); - } - - private static final void PERM_OP(int a, int b, int n, int m, int results[]) - { - int t; - - t = ((a >>> n) ^ b) & m; - a ^= t << n; - b ^= t; - - results[0] = a; - results[1] = b; - } - - private static final int HPERM_OP(int a, int n, int m) - { - int t; - - t = ((a << (16 - n)) ^ a) & m; - a = a ^ t ^ (t >>> (16 - n)); - - return (a); - } - - private static int [] des_set_key(byte key[]) - { - int schedule[] = new int[ITERATIONS * 2]; - - int c = fourBytesToInt(key, 0); - int d = fourBytesToInt(key, 4); - - int results[] = new int[2]; - - PERM_OP(d, c, 4, 0x0f0f0f0f, results); - d = results[0]; - c = results[1]; - - c = HPERM_OP(c, -2, 0xcccc0000); - d = HPERM_OP(d, -2, 0xcccc0000); - - PERM_OP(d, c, 1, 0x55555555, results); - d = results[0]; - c = results[1]; - - PERM_OP(c, d, 8, 0x00ff00ff, results); - c = results[0]; - d = results[1]; - - PERM_OP(d, c, 1, 0x55555555, results); - d = results[0]; - c = results[1]; - - d = (((d & 0x000000ff) << 16) | (d & 0x0000ff00) | - ((d & 0x00ff0000) >>> 16) | ((c & 0xf0000000) >>> 4)); - c &= 0x0fffffff; - - int s, t; - int j = 0; - - for (int i = 0; i < ITERATIONS; i ++) - { - if (shifts2[i]) - { - c = (c >>> 2) | (c << 26); - d = (d >>> 2) | (d << 26); - } - else - { - c = (c >>> 1) | (c << 27); - d = (d >>> 1) | (d << 27); - } - - c &= 0x0fffffff; - d &= 0x0fffffff; - - s = skb[0][ (c ) & 0x3f ] | - skb[1][((c >>> 6) & 0x03) | ((c >>> 7) & 0x3c)] | - skb[2][((c >>> 13) & 0x0f) | ((c >>> 14) & 0x30)] | - skb[3][((c >>> 20) & 0x01) | ((c >>> 21) & 0x06) | - ((c >>> 22) & 0x38)]; - - t = skb[4][ (d ) & 0x3f ] | - skb[5][((d >>> 7) & 0x03) | ((d >>> 8) & 0x3c)] | - skb[6][ (d >>> 15) & 0x3f ] | - skb[7][((d >>> 21) & 0x0f) | ((d >>> 22) & 0x30)]; - - schedule[j++] = ((t << 16) | (s & 0x0000ffff)) & 0xffffffff; - s = ((s >>> 16) | (t & 0xffff0000)); - - s = (s << 4) | (s >>> 28); - schedule[j++] = s & 0xffffffff; - } - return (schedule); - } - - private static final int D_ENCRYPT - ( - int L, int R, int S, int E0, int E1, int s[] - ) - { - int t, u, v; - - v = R ^ (R >>> 16); - u = v & E0; - v = v & E1; - u = (u ^ (u << 16)) ^ R ^ s[S]; - t = (v ^ (v << 16)) ^ R ^ s[S + 1]; - t = (t >>> 4) | (t << 28); - - L ^= SPtrans[1][(t ) & 0x3f] | - SPtrans[3][(t >>> 8) & 0x3f] | - SPtrans[5][(t >>> 16) & 0x3f] | - SPtrans[7][(t >>> 24) & 0x3f] | - SPtrans[0][(u ) & 0x3f] | - SPtrans[2][(u >>> 8) & 0x3f] | - SPtrans[4][(u >>> 16) & 0x3f] | - SPtrans[6][(u >>> 24) & 0x3f]; - - return (L); - } - - private static final int [] body(int schedule[], int Eswap0, int Eswap1) - { - int left = 0; - int right = 0; - int t = 0; - - for (int j = 0; j < 25; j ++) - { - for (int i = 0; i < ITERATIONS * 2; i += 4) - { - left = D_ENCRYPT(left, right, i, Eswap0, Eswap1, schedule); - right = D_ENCRYPT(right, left, i + 2, Eswap0, Eswap1, schedule); - } - t = left; - left = right; - right = t; - } - - t = right; - - right = (left >>> 1) | (left << 31); - left = (t >>> 1) | (t << 31); - - left &= 0xffffffff; - right &= 0xffffffff; - - int results[] = new int[2]; - - PERM_OP(right, left, 1, 0x55555555, results); - right = results[0]; - left = results[1]; - - PERM_OP(left, right, 8, 0x00ff00ff, results); - left = results[0]; - right = results[1]; - - PERM_OP(right, left, 2, 0x33333333, results); - right = results[0]; - left = results[1]; - - PERM_OP(left, right, 16, 0x0000ffff, results); - left = results[0]; - right = results[1]; - - PERM_OP(right, left, 4, 0x0f0f0f0f, results); - right = results[0]; - left = results[1]; - - int out[] = new int[2]; - - out[0] = left; - out[1] = right; - - return (out); - } - - /* - * <P>Encrypt a password given the cleartext password and a "salt".</P> - * @param salt A two-character string representing the salt used to - * iterate the encryption engine in lots of different ways. If you - * are generating a new encryption then this value should be - * randomised. - * @param original The password to be encrypted. - * @return A string consisting of the 2-character salt followed by the - * encrypted password. - */ - public static final String crypt(String salt, String original) - { - while (salt.length() < 2) - salt += "A"; - - StringBuffer buffer = new StringBuffer(" "); - - char charZero = salt.charAt(0); - char charOne = salt.charAt(1); - - buffer.setCharAt(0, charZero); - buffer.setCharAt(1, charOne); - - int Eswap0 = con_salt[(int)charZero]; - int Eswap1 = con_salt[(int)charOne] << 4; - - byte key[] = new byte[8]; - - for (int i = 0; i < key.length; i ++) - key[i] = (byte)0; - - for (int i = 0; i < key.length && i < original.length(); i ++) - { - int iChar = (int)original.charAt(i); - - key[i] = (byte)(iChar << 1); - } - - int schedule[] = des_set_key(key); - int out[] = body(schedule, Eswap0, Eswap1); - - byte b[] = new byte[9]; - - intToFourBytes(out[0], b, 0); - intToFourBytes(out[1], b, 4); - b[8] = 0; - - for (int i = 2, y = 0, u = 0x80; i < 13; i ++) - { - for (int j = 0, c = 0; j < 6; j ++) - { - c <<= 1; - - if (((int)b[y] & u) != 0) - c |= 1; - - u >>>= 1; - - if (u == 0) - { - y++; - u = 0x80; - } - buffer.setCharAt(i, (char)cov_2char[c]); - } - } - return (buffer.toString()); - } - - /* - * <P>Encrypt a password given the cleartext password. This method - * generates a random salt using the 'java.util.Random' class.</P> - * @param original The password to be encrypted. - * @return A string consisting of the 2-character salt followed by the - * encrypted password. - */ - public static final String crypt(String original) - { - java.util.Random randomGenerator = new java.util.Random(); - int numSaltChars = saltChars.length; - String salt; - - salt = (new StringBuffer()).append(saltChars[Math.abs(randomGenerator.nextInt()) % numSaltChars]).append(saltChars[Math.abs(randomGenerator.nextInt()) % numSaltChars]).toString(); - - return crypt(salt, original); - } - - /* - * <P>Check that <I>enteredPassword</I> encrypts to - * <I>encryptedPassword</I>.</P> - * @param encryptedPassword The <I>encryptedPassword</I>. The first - * two characters are assumed to be the salt. This string would - * be the same as one found in a Unix <U>/etc/passwd</U> file. - * @param enteredPassword The password as entered by the user (or - * otherwise aquired). - * @return <B>true</B> if the password should be considered correct. - */ - public final static boolean matches(String encryptedPassword, String enteredPassword) - { - String salt = encryptedPassword.substring(0, 3); - String newCrypt = crypt(salt, enteredPassword); - - return newCrypt.equals(encryptedPassword); - } -} - |