Source code: com/mysql/jdbc/MysqlIO.java

   /*
    Copyright (C) 2002-2004 MySQL AB
   
    This program is free software; you can redistribute it and/or modify
    it under the terms of version 2 of the GNU General Public License as
    published by the Free Software Foundation.
    
   
    There are special exceptions to the terms and conditions of the GPL 
   as it is applied to this software. View the full text of the 
   exception exception in file EXCEPTIONS-CONNECTOR-J in the directory of this 
   software distribution.
  
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
   */
  package com.mysql.jdbc;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.ByteArrayOutputStream;
  import java.io.EOFException;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStreamWriter;
  import java.lang.ref.SoftReference;
  import java.net.Socket;
  import java.security.NoSuchAlgorithmException;
  import java.sql.SQLException;
  import java.sql.SQLWarning;
  import java.util.ArrayList;
  import java.util.Properties;
  import java.util.zip.Deflater;
  import java.util.zip.Inflater;
  
  
  /**
   * This class is used by Connection for communicating with the MySQL server.
   *
   * @author Mark Matthews
   * @version $Id: MysqlIO.java,v 1.32.2.61 2004/08/27 21:50:12 mmatthew Exp $
   *
   * @see java.sql.Connection
   */
  public class MysqlIO {
      static final int NULL_LENGTH = ~0;
      static final int COMP_HEADER_LENGTH = 3;
      static final int MIN_COMPRESS_LEN = 50;
      static final int HEADER_LENGTH = 4;
      private static int maxBufferSize = 65535;
      private static final int CLIENT_COMPRESS = 32; /* Can use compression
      protcol */
      private static final int CLIENT_CONNECT_WITH_DB = 8;
      private static final int CLIENT_FOUND_ROWS = 2;
      private static final int CLIENT_IGNORE_SPACE = 256; /* Ignore spaces
      before '(' */
      private static final int CLIENT_LOCAL_FILES = 128; /* Can use LOAD DATA
      LOCAL */
  
      /* Found instead of
         affected rows */
      private static final int CLIENT_LONG_FLAG = 4; /* Get all column flags */
      private static final int CLIENT_LONG_PASSWORD = 1; /* new more secure
      passwords */
      private static final int CLIENT_PROTOCOL_41 = 512; // for > 4.1.1
      private static final int CLIENT_INTERACTIVE = 1024;
      private static final int CLIENT_SSL = 2048;
      private static final int CLIENT_RESERVED = 16384; // for 4.1.0 only
      private static final int CLIENT_SECURE_CONNECTION = 32768;
      private static final String FALSE_SCRAMBLE = "xxxxxxxx";
  
      /**
       * We store the platform 'encoding' here, only used to avoid munging
       * filenames for LOAD DATA LOCAL INFILE...
       */
      private static String jvmPlatformCharset = null;
  
      static {
          OutputStreamWriter outWriter = null;
  
          //
          // Use the I/O system to get the encoding (if possible), to avoid
          // security restrictions on System.getProperty("file.encoding") in
          // applets (why is that restricted?)
          //
          try {
              outWriter = new OutputStreamWriter(new ByteArrayOutputStream());
              jvmPlatformCharset = outWriter.getEncoding();
          } finally {
              try {
                if (outWriter != null) {
                 outWriter.close();
               }
             } catch (IOException ioEx) {
                 // ignore
             }
         }
     }
 
     //
     // Use this when reading in rows to avoid thousands of new()
     // calls, because the byte arrays just get copied out of the
     // packet anyway
     //
     private Buffer reusablePacket = null;
     private Buffer sendPacket = null;
     private Buffer sharedSendPacket = null;
 
     /** Data to the server */
 
     //private DataOutputStream     _Mysql_Output             = null;
     private BufferedOutputStream mysqlOutput = null;
     private com.mysql.jdbc.Connection connection;
     private Deflater deflater = null;
     private Inflater inflater = null;
 
     /** Buffered data from the server */
 
     //private BufferedInputStream  _Mysql_Buf_Input          = null;
 
     /** Buffered data to the server */
 
     //private BufferedOutputStream _Mysql_Buf_Output         = null;
 
     /** Data from the server */
 
     //private DataInputStream      _Mysql_Input              = null;
     private InputStream mysqlInput = null;
     private RowData streamingData = null;
 
     //
     // For SQL Warnings
     //
     private SQLWarning warningChain = null;
 
     /** The connection to the server */
     private Socket mysqlConnection = null;
     private SocketFactory socketFactory = null;
 
     //
     // Packet used for 'LOAD DATA LOCAL INFILE'
     //
     // We use a SoftReference, so that we don't penalize intermittent
     // use of this feature
     //
     private SoftReference loadFileBufRef;
 
     //
     // Used to send large packets to the server versions 4+
     // We use a SoftReference, so that we don't penalize intermittent
     // use of this feature
     //
     private SoftReference splitBufRef;
     private String host = null;
     private String seed;
     private String serverVersion = null;
     private String socketFactoryClassName = null;
     private byte[] packetHeaderBuf = new byte[4];
     private boolean clearStreamBeforeEachQuery = false;
     private boolean colDecimalNeedsBump = false; // do we need to increment the colDecimal flag?
     private boolean has41NewNewProt = false;
 
     /** Does the server support long column info? */
     private boolean hasLongColumnInfo = false;
     private boolean isInteractiveClient = false;
 
     /**
      * Does the character set of this connection match the character set of the
      * platform
      */
     private boolean platformDbCharsetMatches = true;
     private boolean profileSql = false;
 
     /** Should we use 4.1 protocol extensions? */
     private boolean use41Extensions = false;
     private boolean useCompression = false;
     private boolean useNewLargePackets = false;
     private boolean useNewUpdateCounts = false; // should we use the new larger update counts?
     private byte packetSequence = 0;
     private byte protocolVersion = 0;
     private int clientParam = 0;
 
     // changed once we've connected.
     private int maxAllowedPacket = 1024 * 1024;
     private int maxThreeBytes = 255 * 255 * 255;
     private int port = 3306;
     private int serverCapabilities;
     private int serverMajorVersion = 0;
     private int serverMinorVersion = 0;
     private int serverSubMinorVersion = 0;
   protected int serverCharsetIndex;
   private static final int MAX_QUERY_LENGTH_TO_LOG =  4 * 1024; // 4K
 
     /**
      * Constructor:  Connect to the MySQL server and setup a stream connection.
      *
      * @param host the hostname to connect to
      * @param port the port number that the server is listening on
      * @param socketFactoryClassName the socket factory to use
      * @param props the Properties from DriverManager.getConnection()
      * @param conn the Connection that is creating us
      * @param socketTimeout the timeout to set for the socket (0 means no
      *        timeout)
      *
      * @throws IOException if an IOException occurs during connect.
      * @throws java.sql.SQLException if a database access error occurs.
      */
     protected MysqlIO(String host, int port, String socketFactoryClassName,
         Properties props, com.mysql.jdbc.Connection conn, int socketTimeout)
         throws IOException, java.sql.SQLException {
         this.connection = conn;
         this.reusablePacket = new Buffer(this.connection.getNetBufferLength());
         this.port = port;
         this.host = host;
         this.socketFactoryClassName = socketFactoryClassName;
         this.socketFactory = createSocketFactory();
         this.mysqlConnection = socketFactory.connect(this.host, this.port, props);
         this.clearStreamBeforeEachQuery = this.connection.alwaysClearStream();
 
         if (socketTimeout != 0) {
             try {
                 this.mysqlConnection.setSoTimeout(socketTimeout);
             } catch (Exception ex) {
                 /* Ignore if the platform does not support it */
             }
         }
 
         this.mysqlConnection = this.socketFactory.beforeHandshake();
 
         if (!this.connection.isUsingUnbufferedInput()) {
             this.mysqlInput = new BufferedInputStream(this.mysqlConnection
                     .getInputStream(), 16384);
         } else {
             this.mysqlInput = this.mysqlConnection.getInputStream();
         }
 
         this.mysqlOutput = new BufferedOutputStream(this.mysqlConnection
                 .getOutputStream(), 16384);
         this.isInteractiveClient = this.connection.isInteractiveClient();
     }
 
     /**
      * Should the driver generate SQL statement profiles?
      *
      * @param flag should the driver enable profiling?
      */
     protected void setProfileSql(boolean flag) {
         this.profileSql = flag;
     }
 
     /**
      * Build a result set. Delegates to buildResultSetWithRows() to build a
      * JDBC-version-specific ResultSet, given rows as byte data, and field
      * information.
      *
      * @param columnCount the number of columns in the result set
      * @param maxRows the maximum number of rows to read (-1 means all rows)
      * @param resultSetType the type of result set (CONCUR_UPDATABLE or
      *        READ_ONLY)
      * @param streamResults should the result set be read all at once, or
      *        streamed?
      * @param catalog the database name in use when the result set was created
      *
      * @return a result set
      *
      * @throws Exception if a database access error occurs
      */
     protected ResultSet getResultSet(long columnCount, int maxRows,
         int resultSetType, boolean streamResults, String catalog)
         throws Exception {
         Buffer packet; // The packet from the server
         Field[] fields = new Field[(int) columnCount];
 
         // Read in the column information
         for (int i = 0; i < columnCount; i++) {
             packet = readPacket();
             fields[i] = unpackField(packet, false);
         }
 
         packet = reuseAndReadPacket(this.reusablePacket);
 
         RowData rowData = null;
 
         if (!streamResults) {
             ArrayList rows = new ArrayList();
 
             // Now read the data
             byte[][] rowBytes = nextRow((int) columnCount);
             int rowCount = 0;
 
             if (rowBytes != null) {
                 rows.add(rowBytes);
                 rowCount = 1;
             }
 
             while ((rowBytes != null) && (rowCount < maxRows)) {
                 rowBytes = nextRow((int) columnCount);
 
                 if (rowBytes != null) {
                     rows.add(rowBytes);
                     rowCount++;
                 } else {
                     if (Driver.TRACE) {
                         Debug.msg(this, "* NULL Row *");
                     }
                 }
             }
 
             //
             // Clear any outstanding data left on the wire
             // when we've artifically limited the number of 
             // rows we retrieve (fix for BUG#1695)
             //
             if (rowCount <= maxRows) {
                 clearInputStream();
             }
 
             if (Driver.TRACE) {
                 Debug.msg(this,
                     "* Fetched " + rows.size() + " rows from server *");
             }
 
             rowData = new RowDataStatic(rows);
             reclaimLargeReusablePacket();
         } else {
             rowData = new RowDataDynamic(this, (int) columnCount);
             this.streamingData = rowData;
         }
 
         return buildResultSetWithRows(catalog, fields, rowData, resultSetType);
     }
 
     /**
      * Forcibly closes the underlying socket to MySQL.
      */
     protected final void forceClose() {
         try {
             if (this.mysqlInput != null) {
                 this.mysqlInput.close();
             }
         } catch (IOException ioEx) {
             // we can't do anything constructive about this
             // Let the JVM clean it up later
             this.mysqlInput = null;
         }
 
         try {
             if (this.mysqlOutput != null) {
                 this.mysqlOutput.close();
             }
         } catch (IOException ioEx) {
             // we can't do anything constructive about this
             // Let the JVM clean it up later
             this.mysqlOutput = null;
         }
 
         try {
             if (this.mysqlConnection != null) {
                 this.mysqlConnection.close();
             }
         } catch (IOException ioEx) {
             // we can't do anything constructive about this
             // Let the JVM clean it up later
             this.mysqlConnection = null;
         }
     }
 
     /**
      * Re-authenticates as the given user and password
      *
      * @param userName DOCUMENT ME!
      * @param password DOCUMENT ME!
      *
      * @throws SQLException DOCUMENT ME!
      */
     protected void changeUser(String userName, String password, String database)
         throws SQLException {
         this.packetSequence = -1;
 
         int passwordLength = 16;
         int userLength = 0;
 
         if (userName != null) {
             userLength = userName.length();
         }
 
         int packLength = (userLength + passwordLength) + 7 + HEADER_LENGTH;
 
         if ((this.serverCapabilities & CLIENT_SECURE_CONNECTION) != 0) {
             Buffer changeUserPacket = new Buffer(packLength + 1);
             changeUserPacket.writeByte((byte) MysqlDefs.COM_CHANGE_USER);
 
             if (versionMeetsMinimum(4, 1, 1)) {
                 secureAuth411(changeUserPacket, packLength, userName, password,
                     database, false);
             } else {
                 secureAuth(changeUserPacket, packLength, userName, password,
                     database, false);
             }
         } else {
             // Passwords can be 16 chars long
             Buffer packet = new Buffer(packLength + 1);
             packet.writeByte((byte) MysqlDefs.COM_CHANGE_USER);
 
             // User/Password data
             packet.writeString(userName);
 
             if (this.protocolVersion > 9) {
                 packet.writeString(Util.newCrypt(password, this.seed));
             } else {
                 packet.writeString(Util.oldCrypt(password, this.seed));
             }
 
             if (((serverCapabilities & CLIENT_CONNECT_WITH_DB) != 0)
                     && (database != null) && (database.length() > 0)) {
                 packet.writeString(database);
             }
             
             send(packet);
             checkErrorPacket();
         }
     }
 
     /**
      * Does the server send back extra column info?
      *
      * @return true if so
      */
     protected boolean hasLongColumnInfo() {
         return this.hasLongColumnInfo;
     }
 
     /**
      * Unpacks the Field information from the given packet. Understands pre 4.1
      * and post 4.1 server version field packet structures.
      *
      * @param packet the packet containing the field information
      * @param extractDefaultValues should default values be extracted?
      *
      * @return the unpacked field
      */
     protected final Field unpackField(Buffer packet,
         boolean extractDefaultValues) throws SQLException {
         if (this.use41Extensions) {
             // we only store the position of the string and
             // materialize only if needed...
             if (this.has41NewNewProt) {
                 int catalogNameStart = packet.getPosition() + 1;
                 int catalogNameLength = packet.fastSkipLenString();
             }
 
             int databaseNameStart = packet.getPosition() + 1;
             int databaseNameLength = packet.fastSkipLenString();
 
             int tableNameStart = packet.getPosition() + 1;
             int tableNameLength = packet.fastSkipLenString();
 
             // orgTableName is never used so skip
             int originalTableNameStart = packet.getPosition() + 1;
             int originalTableNameLength = packet.fastSkipLenString();
 
             // we only store the position again...
             int nameStart = packet.getPosition() + 1;
             int nameLength = packet.fastSkipLenString();
 
             // orgColName is not required so skip...
             int originalColumnNameStart = packet.getPosition() + 1;
             int originalColumnNameLength = packet.fastSkipLenString();
 
             packet.readByte();
 
             int charSetNumber = packet.readInt();
 
             long colLength = 0;
 
             if (this.has41NewNewProt) {
                 colLength = packet.readLong();
             } else {
                 colLength = packet.readLongInt();
             }
 
             int colType = packet.readByte() & 0xff;
 
             short colFlag = 0;
 
             if (this.hasLongColumnInfo) {
                 colFlag = (short) (packet.readInt());
             } else {
                 colFlag = (short) (packet.readByte() & 0xff);
             }
 
             int colDecimals = packet.readByte() & 0xff;
 
             int defaultValueStart = -1;
             int defaultValueLength = -1;
 
             if (extractDefaultValues) {
                 defaultValueStart = packet.getPosition() + 1;
                 defaultValueLength = packet.fastSkipLenString();
             }
 
             Field field = new Field(this.connection, packet.getByteBuffer(),
                     databaseNameStart, databaseNameLength, tableNameStart,
                     tableNameLength, originalTableNameStart,
                     originalTableNameLength, nameStart, nameLength,
                     originalColumnNameStart, originalColumnNameLength,
                     colLength, colType, colFlag, colDecimals,
                     defaultValueStart, defaultValueLength, charSetNumber);
 
             return field;
         } else {
             int tableNameStart = packet.getPosition() + 1;
             int tableNameLength = packet.fastSkipLenString();
             int nameStart = packet.getPosition() + 1;
             int nameLength = packet.fastSkipLenString();
             int colLength = packet.readnBytes();
             int colType = packet.readnBytes();
             packet.readByte(); // We know it's currently 2
 
             short colFlag = 0;
 
             if (this.hasLongColumnInfo) {
                 colFlag = (short) (packet.readInt());
             } else {
                 colFlag = (short) (packet.readByte() & 0xff);
             }
 
             int colDecimals = (packet.readByte() & 0xff);
 
             if (this.colDecimalNeedsBump) {
                 colDecimals++;
             }
 
             Field field = new Field(this.connection, packet.getBufferSource(),
                     nameStart, nameLength, tableNameStart, tableNameLength,
                     colLength, colType, colFlag, colDecimals);
 
             return field;
         }
     }
 
     /**
      * Determines if the database charset is the same as the platform charset
      */
     protected void checkForCharsetMismatch() {
         if (this.connection.useUnicode()
                 && (this.connection.getEncoding() != null)) {
             String encodingToCheck = jvmPlatformCharset;
 
             if (encodingToCheck == null) {
                 encodingToCheck = System.getProperty("file.encoding");
             }
 
             if (encodingToCheck == null) {
                 this.platformDbCharsetMatches = false;
             } else {
                 this.platformDbCharsetMatches = encodingToCheck.equals(this.connection
                         .getEncoding());
             }
         }
     }
 
     static int getMaxBuf() {
         return maxBufferSize;
     }
 
     /**
      * Get the major version of the MySQL server we are talking to.
      *
      * @return DOCUMENT ME!
      */
     final int getServerMajorVersion() {
         return this.serverMajorVersion;
     }
 
     /**
      * Get the minor version of the MySQL server we are talking to.
      *
      * @return DOCUMENT ME!
      */
     final int getServerMinorVersion() {
         return this.serverMinorVersion;
     }
 
     /**
      * Get the sub-minor version of the MySQL server we are talking to.
      *
      * @return DOCUMENT ME!
      */
     final int getServerSubMinorVersion() {
         return this.serverSubMinorVersion;
     }
 
     /**
      * Get the version string of the server we are talking to
      *
      * @return DOCUMENT ME!
      */
     String getServerVersion() {
         return this.serverVersion;
     }
 
     /**
      * Initialize communications with the MySQL server. Handles logging on, and
      * handling initial connection errors.
      *
      * @param user DOCUMENT ME!
      * @param password DOCUMENT ME!
      * @param database DOCUMENT ME!
      *
      * @throws java.sql.SQLException DOCUMENT ME!
      * @throws SQLException DOCUMENT ME!
      */
     void doHandshake(String user, String password, String database)
         throws java.sql.SQLException {
         // Read the first packet
         Buffer buf = readPacket();
 
         // Get the protocol version
         this.protocolVersion = buf.readByte();
 
         if (this.protocolVersion == -1) {
             try {
                 this.mysqlConnection.close();
             } catch (Exception e) {
                 ; // ignore
             }
 
             int errno = 2000;
 
             errno = buf.readInt();
 
             String serverErrorMessage = buf.readString();
 
             StringBuffer errorBuf = new StringBuffer(" message from server: \"");
             errorBuf.append(serverErrorMessage);
             errorBuf.append("\"");
 
             String xOpen = SQLError.mysqlToXOpen(errno);
 
             throw new SQLException(SQLError.get(xOpen) + ", "
                 + errorBuf.toString(), xOpen, errno);
         }
 
         this.serverVersion = buf.readString();
 
         // Parse the server version into major/minor/subminor
         int point = this.serverVersion.indexOf(".");
 
         if (point != -1) {
             try {
                 int n = Integer.parseInt(this.serverVersion.substring(0, point));
                 this.serverMajorVersion = n;
             } catch (NumberFormatException NFE1) {
                 ;
             }
 
             String remaining = this.serverVersion.substring(point + 1,
                     this.serverVersion.length());
             point = remaining.indexOf(".");
 
             if (point != -1) {
                 try {
                     int n = Integer.parseInt(remaining.substring(0, point));
                     this.serverMinorVersion = n;
                 } catch (NumberFormatException nfe) {
                     ;
                 }
 
                 remaining = remaining.substring(point + 1, remaining.length());
 
                 int pos = 0;
 
                 while (pos < remaining.length()) {
                     if ((remaining.charAt(pos) < '0')
                             || (remaining.charAt(pos) > '9')) {
                         break;
                     }
 
                     pos++;
                 }
 
                 try {
                     int n = Integer.parseInt(remaining.substring(0, pos));
                     this.serverSubMinorVersion = n;
                 } catch (NumberFormatException nfe) {
                     ;
                 }
             }
         }
 
         if (versionMeetsMinimum(4, 0, 8)) {
             this.maxThreeBytes = (256 * 256 * 256) - 1;
             this.useNewLargePackets = true;
         } else {
             this.maxThreeBytes = 255 * 255 * 255;
             this.useNewLargePackets = false;
         }
 
         this.colDecimalNeedsBump = versionMeetsMinimum(3, 23, 0);
         this.colDecimalNeedsBump = !versionMeetsMinimum(3, 23, 15); // guess? Not noted in changelog
         this.useNewUpdateCounts = versionMeetsMinimum(3, 22, 5);
 
         long threadId = buf.readLong();
         seed = buf.readString();
 
         if (Driver.TRACE) {
             Debug.msg(this, "Protocol Version: " + (int) this.protocolVersion);
             Debug.msg(this, "Server Version: " + this.serverVersion);
             Debug.msg(this, "Thread ID: " + threadId);
             Debug.msg(this, "Crypt Seed: " + seed);
         }
 
         this.serverCapabilities = 0;
 
         if (buf.getPosition() < buf.getBufLength()) {
             serverCapabilities = buf.readInt();
         }
 
         if (versionMeetsMinimum(4, 1, 1)) {
             int position = buf.getPosition();
             
             this.serverCharsetIndex = buf.readByte() & 0xff;
       //not used this.serverStatus = buf.readInt();
       
             buf.setPosition(position + 16);
 
             String seedPart2 = buf.readString();
             StringBuffer newSeed = new StringBuffer(20);
             newSeed.append(seed);
             newSeed.append(seedPart2);
             this.seed = newSeed.toString();
         }
 
         if (((serverCapabilities & CLIENT_COMPRESS) != 0)
                 && this.connection.useCompression()) {
             clientParam |= CLIENT_COMPRESS;
         }
 
         if ((database != null) && (database.length() > 0)) {
             clientParam |= CLIENT_CONNECT_WITH_DB;
         }
 
         if (((serverCapabilities & CLIENT_SSL) == 0)
                 && this.connection.useSSL()) {
             this.connection.setUseSSL(false);
         }
 
         if ((serverCapabilities & CLIENT_LONG_FLAG) != 0) {
             // We understand other column flags, as well
             clientParam |= CLIENT_LONG_FLAG;
             this.hasLongColumnInfo = true;
         }
 
         // return FOUND rows
         clientParam |= CLIENT_FOUND_ROWS;
 
         if (this.connection.allowLoadLocalInfile()) {
             clientParam |= CLIENT_LOCAL_FILES;
         }
 
         if (isInteractiveClient) {
             clientParam |= CLIENT_INTERACTIVE;
         }
 
         // Authenticate
         if (this.protocolVersion > 9) {
             clientParam |= CLIENT_LONG_PASSWORD; // for long passwords
         } else {
             clientParam &= ~CLIENT_LONG_PASSWORD;
         }
 
         //
         // 4.1 has some differences in the protocol
         //
         if (versionMeetsMinimum(4, 1, 0)) {
             if (versionMeetsMinimum(4, 1, 1)) {
                 clientParam |= CLIENT_PROTOCOL_41;
                 this.has41NewNewProt = true;
             } else {
                 clientParam |= CLIENT_RESERVED;
                 this.has41NewNewProt = false;
             }
 
             this.use41Extensions = true;
         }
 
         int passwordLength = 16;
         int userLength = 0;
         int databaseLength = 0;
 
         if (user != null) {
             userLength = user.length();
         }
 
         if (database != null) {
             databaseLength = database.length();
         }
 
         int packLength = (userLength + passwordLength + databaseLength) + 7
             + HEADER_LENGTH;
         Buffer packet = null;
 
         if (!connection.useSSL()) {
             if ((serverCapabilities & CLIENT_SECURE_CONNECTION) != 0) {
                 clientParam |= CLIENT_SECURE_CONNECTION;
 
                 if (versionMeetsMinimum(4, 1, 1)) {
                     secureAuth411(null, packLength, user, password, database,
                         true);
                 } else {
                     secureAuth(null, packLength, user, password, database, true);
                 }
             } else {
                 packet = new Buffer(packLength);
 
                 if ((clientParam & CLIENT_RESERVED) != 0) {
                     if (versionMeetsMinimum(4, 1, 1)) {
                         packet.writeLong(clientParam);
                         packet.writeLong(this.maxThreeBytes);
 
                         // charset, JDBC will connect as 'latin1',
                         // and use 'SET NAMES' to change to the desired
                         // charset after the connection is established.
                         packet.writeByte((byte) 8);
 
                         // Set of bytes reserved for future use.
                         packet.writeBytesNoNull(new byte[23]);
                     } else {
                         packet.writeLong(clientParam);
                         packet.writeLong(this.maxThreeBytes);
                     }
                 } else {
                     packet.writeInt((int) clientParam);
                     packet.writeLongInt(this.maxThreeBytes);
                 }
 
                 // User/Password data
                 packet.writeString(user);
 
                 if (this.protocolVersion > 9) {
                     packet.writeString(Util.newCrypt(password, this.seed));
                 } else {
                     packet.writeString(Util.oldCrypt(password, this.seed));
                 }
 
                 if (((serverCapabilities & CLIENT_CONNECT_WITH_DB) != 0)
                         && (database != null) && (database.length() > 0)) {
                     packet.writeString(database);
                 }
 
                 send(packet);
             }
         } else {
             boolean doSecureAuth = false;
 
             if ((serverCapabilities & CLIENT_SECURE_CONNECTION) != 0) {
                 clientParam |= CLIENT_SECURE_CONNECTION;
                 doSecureAuth = true;
             }
 
             clientParam |= CLIENT_SSL;
             packet = new Buffer(packLength);
 
             if ((clientParam & CLIENT_RESERVED) != 0) {
                 packet.writeLong(clientParam);
             } else {
                 packet.writeInt((int) clientParam);
             }
 
             send(packet);
 
             javax.net.ssl.SSLSocketFactory sslFact = (javax.net.ssl.SSLSocketFactory) javax.net.ssl.SSLSocketFactory
                 .getDefault();
 
             try {
                 this.mysqlConnection = sslFact.createSocket(this.mysqlConnection,
                         this.host, this.port, true);
 
                 // need to force TLSv1, or else JSSE tries to do a SSLv2 handshake
                 // which MySQL doesn't understand
                 ((javax.net.ssl.SSLSocket) this.mysqlConnection)
                 .setEnabledProtocols(new String[] { "TLSv1" });
                 ((javax.net.ssl.SSLSocket) this.mysqlConnection).startHandshake();
                 this.mysqlInput = new BufferedInputStream(this.mysqlConnection
                         .getInputStream(), 16384);
                 this.mysqlOutput = new BufferedOutputStream(this.mysqlConnection
                         .getOutputStream(), 16384);
                 this.mysqlOutput.flush();
             } catch (IOException ioEx) {
                 StringBuffer message = new StringBuffer(SQLError.get(
                             SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE));
                 message.append(": ");
                 message.append(ioEx.getClass().getName());
                 message.append(", underlying cause: ");
                 message.append(ioEx.getMessage());
 
                 if (!this.connection.useParanoidErrorMessages()) {
                     message.append(Util.stackTraceToString(ioEx));
                 }
 
                 throw new java.sql.SQLException(message.toString(),
                     SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE, 0);
             }
 
             packet.clear();
 
             if (doSecureAuth) {
                 if (versionMeetsMinimum(4, 1, 1)) {
                     secureAuth411(null, packLength, user, password, database,
                         true);
                 } else {
                     secureAuth(null, packLength, user, password, database, true);
                 }
             } else {
                 if ((clientParam & CLIENT_RESERVED) != 0) {
                     packet.writeLong(clientParam);
                     packet.writeLong(this.maxThreeBytes);
                 } else {
                     packet.writeInt((int) clientParam);
                     packet.writeLongInt(this.maxThreeBytes);
                 }
 
                 // User/Password data
                 packet.writeString(user);
 
                 if (this.protocolVersion > 9) {
                     packet.writeString(Util.newCrypt(password, seed));
                 } else {
                     packet.writeString(Util.oldCrypt(password, seed));
                 }
 
                 if (((serverCapabilities & CLIENT_CONNECT_WITH_DB) != 0)
                         && (database != null) && (database.length() > 0)) {
                     packet.writeString(database);
                 }
 
                 send(packet);
             }
         }
 
         // Check for errors, not for 4.1.1 or newer,
         // as the new auth protocol doesn't work that way
         // (see secureAuth411() for more details...)
         if (!versionMeetsMinimum(4, 1, 1)) {
             checkErrorPacket();
         }
 
         //
         // Can't enable compression until after handshake
         //
         if (((serverCapabilities & CLIENT_COMPRESS) != 0)
                 && this.connection.useCompression()) {
             // The following matches with ZLIB's
             // compress()
             this.deflater = new Deflater();
             this.useCompression = true;
             this.mysqlInput = new CompressedInputStream(this.mysqlInput);
         }
 
         if (((serverCapabilities & CLIENT_CONNECT_WITH_DB) == 0)
                 && (database != null) && (database.length() > 0)) {
             try {
                 sendCommand(MysqlDefs.INIT_DB, database, null);
             } catch (Exception ex) {
                 throw new SQLException(ex.toString()
                     + (this.connection.useParanoidErrorMessages() ? ""
                                                                   : Util
                     .stackTraceToString(ex)),
                     SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE);
             }
         }
     }
 
     /**
      * Retrieve one row from the MySQL server. Note: this method is not
      * thread-safe, but it is only called from methods that are guarded by
      * synchronizing on this object.
      *
      * @param columnCount DOCUMENT ME!
      *
      * @return DOCUMENT ME!
      *
      * @throws Exception DOCUMENT ME!
      */
     final byte[][] nextRow(int columnCount) throws Exception {
         // Get the next incoming packet, re-using the packet because
         // all the data we need gets copied out of it.
         Buffer rowPacket = checkErrorPacket();
 
         //
        // Didn't read an error, so re-position to beginning
        // of packet in order to read result set data
        //
        int offset = 0;

        //if (rowPacket.wasMultiPacket()) {
        //    if (this.useNewLargePackets) {
        //        offset = HEADER_LENGTH;
        //    } else {
        //        offset = HEADER_LENGTH + 1;
        //   }
        //}
        rowPacket.setPosition(rowPacket.getPosition() - 1);

        byte[][] rowData = new byte[columnCount][];

        if (!rowPacket.isLastDataPacket()) {
            for (int i = 0; i < columnCount; i++) {
                rowData[i] = rowPacket.readLenByteArray(offset);

                if (Driver.TRACE) {
                    if (rowData[i] == null) {
                        Debug.msg(this, "Field value: NULL");
                    } else {
                        Debug.msg(this, "Field value: " + rowData[i].toString());
                    }
                }
            }

            return rowData;
        }

        return null;
    }

    /**
     * Log-off of the MySQL server and close the socket.
     *
     * @throws SQLException DOCUMENT ME!
     */
    final void quit() throws SQLException {
        Buffer packet = new Buffer(6);
        this.packetSequence = -1;
        packet.writeByte((byte) MysqlDefs.QUIT);
        send(packet);
        forceClose();
    }

    /**
     * Returns the packet used for sending data (used by PreparedStatement)
     * Guarded by external synchronization on a mutex.
     *
     * @return A packet to send data with
     */
    Buffer getSharedSendPacket() {
        if (this.sharedSendPacket == null) {
            this.sharedSendPacket = new Buffer(this.connection
                    .getNetBufferLength());
        }

        return this.sharedSendPacket;
    }

    void closeStreamer(RowData streamer) throws SQLException {
        if (this.streamingData == null) {
            throw new SQLException("Attempt to close streaming result set "
                + streamer
                + " when no streaming  result set was registered. This is an internal error.");
        }

        if (streamer != this.streamingData) {
            throw new SQLException("Attempt to close streaming result set "
                + streamer + " that was not registered."
                + " Only one streaming result set may be open and in use per-connection. Ensure that you have called .close() on "
                + " any active result sets before attempting more queries.");
        }

        this.streamingData = null;
    }

    /**
     * Sets the buffer size to max-buf
     */
    void resetMaxBuf() {
        this.maxAllowedPacket = this.connection.getMaxAllowedPacket();
    }

    /**
     * Send a command to the MySQL server If data is to be sent with command,
     * it should be put in ExtraData Raw packets can be sent by setting
     * QueryPacket to something other than null.
     *
     * @param command DOCUMENT ME!
     * @param extraData DOCUMENT ME!
     * @param queryPacket DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     *
     * @throws Exception DOCUMENT ME!
     * @throws java.sql.SQLException DOCUMENT ME!
     */
    final Buffer sendCommand(int command, String extraData, Buffer queryPacket)
        throws Exception {
        checkForOutstandingStreamingData();

        try {
            if (this.clearStreamBeforeEachQuery) {
                clearInputStream();
            }

            //
            // PreparedStatements construct their own packets,
            // for efficiency's sake.
            //
            // If this is a generic query, we need to re-use
            // the sending packet.
            //
            if (queryPacket == null) {
                int packLength = HEADER_LENGTH + COMP_HEADER_LENGTH + 1
                    + ((extraData != null) ? extraData.length() : 0) + 2;

                if (this.sendPacket == null) {
                    this.sendPacket = new Buffer(packLength);
                }

                this.packetSequence = -1;
                this.sendPacket.clear();

                this.sendPacket.writeByte((byte) command);

                if ((command == MysqlDefs.INIT_DB)
                        || (command == MysqlDefs.CREATE_DB)
                        || (command == MysqlDefs.DROP_DB)
                        || (command == MysqlDefs.QUERY)) {
                    this.sendPacket.writeStringNoNull(extraData);
                } else if (command == MysqlDefs.PROCESS_KILL) {
                    long id = new Long(extraData).longValue();
                    this.sendPacket.writeLong(id);
                } else if ((command == MysqlDefs.RELOAD)
                        && (this.protocolVersion > 9)) {
                    Debug.msg(this, "Reload");

                    //Packet.writeByte(reloadParam);
                }

                send(this.sendPacket);
            } else {
                this.packetSequence = -1;
                send(queryPacket); // packet passed by PreparedStatement
            }
        } catch (SQLException sqlEx) {
            // don't wrap SQLExceptions
            throw sqlEx;
        } catch (Exception ex) {
            String underlyingMessage = ex.getMessage();

            throw new java.sql.SQLException(SQLError.get(
                    SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE) + ": "
                + ex.getClass().getName() + ", "
                + ((underlyingMessage != null) ? underlyingMessage
                                               : "no message given by JVM")
                + (this.connection.useParanoidErrorMessages() ? ""
                                                              : Util
                .stackTraceToString(ex)),
                SQLError.SQL_STATE_COMMUNICATION_LINK_FAILURE, 0);
        }

        return checkErrorPacket(command);
    }

    /**
     * Send a query specified in the String "Query" to the MySQL server. This
     * method uses the specified character encoding to get the bytes from the
     * query string.
     *
     * @param query DOCUMENT ME!
     * @param maxRows DOCUMENT ME!
     * @param characterEncoding DOCUMENT ME!
     * @param conn DOCUMENT ME!
     * @param resultSetType DOCUMENT ME!
     * @param streamResults DOCUMENT ME!
     * @param catalog DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     *
     * @throws Exception DOCUMENT ME!
     */
    final ResultSet sqlQuery(String query, int maxRows,
        String characterEncoding, Connection conn, int resultSetType,
        boolean streamResults, String catalog) throws Exception {
        // We don't know exactly how many bytes we're going to get
        // from the query. Since we're dealing with Unicode, the
        // max is 2, so pad it (2 * query) + space for headers
        int packLength = HEADER_LENGTH + 1 + (query.length() * 2) + 2;

        if (this.sendPacket == null) {
            this.sendPacket = new Buffer(packLength);
        } else {
            this.sendPacket.clear();
        }

        this.sendPacket.writeByte((byte) MysqlDefs.QUERY);

        if (characterEncoding != null) {
            SingleByteCharsetConverter converter = this.connection
                .getCharsetConverter(characterEncoding);

            if (this.platformDbCharsetMatches) {
                this.sendPacket.writeStringNoNull(query, characterEncoding,
                    this.connection.getServerCharacterEncoding(), converter, 
          this.connection.parserKnowsUnicode());
            } else {
                if (StringUtils.startsWithIgnoreCaseAndWs(query, "LOAD DATA")) {
                    this.sendPacket.writeBytesNoNull(query.getBytes());
                } else {
                    this.sendPacket.writeStringNoNull(query, characterEncoding,
                        this.connection.getServerCharacterEncoding(), converter, 
              this.connection.parserKnowsUnicode());
                }
            }
        } else {
            this.sendPacket.writeStringNoNull(query);
        }

        return sqlQueryDirect(this.sendPacket, maxRows, conn, resultSetType,
            streamResults, catalog);
    }

    /**
     * Send a query stored in a packet directly to the server.
     *
     * @param queryPacket DOCUMENT ME!
     * @param maxRows DOCUMENT ME!
     * @param conn DOCUMENT ME!
     * @param resultSetType DOCUMENT ME!
     * @param streamResults DOCUMENT ME!
     * @param catalog DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     *
     * @throws Exception DOCUMENT ME!
     */
    final ResultSet sqlQueryDirect(Buffer queryPacket, int maxRows,
        Connection conn, int resultSetType, boolean streamResults,
        String catalog) throws Exception {
        StringBuffer profileMsgBuf = null; // used if profiling
        long queryStartTime = 0;

        if (this.profileSql) {
            profileMsgBuf = new StringBuffer();
            queryStartTime = System.currentTimeMillis();

            byte[] queryBuf = queryPacket.getByteBuffer();

            int queryLength = queryPacket.getPosition();
            
            boolean queryTruncated = false;
            
            if (queryLength > MAX_QUERY_LENGTH_TO_LOG) {
              queryLength = MAX_QUERY_LENGTH_TO_LOG;
              
              queryTruncated = true;
            }
            
            // Extract the actual query from the network packet
            String query = new String(queryBuf, 5,
                    (queryLength - 5));
            profileMsgBuf.append("Query\t\"");
            profileMsgBuf.append(query);
            
            if (queryTruncated) {
              profileMsgBuf.append(" ... (long query truncated)");
            }
            
            profileMsgBuf.append("\"\texecution time:\t");
        }

        // Send query command and sql query string
        Buffer resultPacket = sendCommand(MysqlDefs.QUERY, null, queryPacket);

        if (this.profileSql) {
            long executionTime = System.currentTimeMillis() - queryStartTime;
            profileMsgBuf.append(executionTime);
            profileMsgBuf.append("\t");
        }

        resultPacket.setPosition(resultPacket.getPosition() - 1);

        long columnCount = resultPacket.readFieldLength();

        if (Driver.TRACE) {
            Debug.msg(this, "Column count: " + columnCount);
        }

        if (columnCount == 0) {
            if (this.profileSql) {
                System.err.println(profileMsgBuf.toString());
            }

            return buildResultSetWithUpdates(resultPacket);
        } else if (columnCount == Buffer.NULL_LENGTH) {
            String charEncoding = null;

            if (this.connection.useUnicode()) {
                charEncoding = this.connection.getEncoding();
            }

            String fileName = null;

            if (this.platformDbCharsetMatches) {
                fileName = ((charEncoding != null)
                    ? resultPacket.readString(charEncoding)
                    : resultPacket.readString());
            } else {
                fileName = resultPacket.readString();
            }

            return sendFileToServer(fileName);
        } else {
            long fetchStartTime = 0;

            if (this.profileSql) {
                fetchStartTime = System.currentTimeMillis();
            }

            com.mysql.jdbc.ResultSet results = getResultSet(columnCount,
                    maxRows, resultSetType, streamResults, catalog);

            if (this.profileSql) {
                long fetchElapsedTime = System.currentTimeMillis()
                    - fetchStartTime;
                profileMsgBuf.append("result set fetch time:\t");
                profileMsgBuf.append(fetchElapsedTime);
                System.err.println(profileMsgBuf.toString());
            }

            return results;
        }
    }

    /**
     * Returns the host this IO is connected to
     *
     * @return DOCUMENT ME!
     */
    String getHost() {
        return this.host;
    }

    /**
     * Does the version of the MySQL server we are connected to meet the given
     * minimums?
     *
     * @param major DOCUMENT ME!
     * @param minor DOCUMENT ME!
     * @param subminor DOCUMENT ME!
     *
     * @return DOCUMENT ME!
     */
    boolean versionMeetsMinimum(int major, int minor, int subminor) {
        if (getServerMajorVersion() >= major) {
            if (getServerMajorVersion() == major) {
                if (getServerMinorVersion() >= minor) {
                    if (getServerMinorVersion() == minor) {
                        return (getServerSubMinorVersion() >= subminor);
                    } else {
                        // newer than major.minor
                        return true;