db-derby-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From banda...@apache.org
Subject svn commit: r165178 [22/26] - in /incubator/derby/code/trunk: ./ java/client/ java/client/org/ java/client/org/apache/ java/client/org/apache/derby/ java/client/org/apache/derby/client/ java/client/org/apache/derby/client/am/ java/client/org/apache/derby/client/net/ java/client/org/apache/derby/client/resources/ java/client/org/apache/derby/jdbc/ tools/ant/properties/
Date Thu, 28 Apr 2005 19:05:45 GMT
Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionReply.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionReply.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionReply.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionReply.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,328 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.NetXAConnectionReply
+
+   Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors, where applicable.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+*/
+
+package org.apache.derby.client.net;
+
+import org.apache.derby.client.am.DisconnectException;
+import org.apache.derby.client.am.ConnectionCallbackInterface;
+import javax.transaction.xa.*;
+
+public class NetXAConnectionReply extends NetResultSetReply
+{
+  NetXAConnectionReply (NetAgent netAgent, int bufferSize)
+  {
+    super (netAgent, bufferSize);
+  }
+  //----------------------------- entry points ---------------------------------
+
+
+  public void readLocalXAStart (ConnectionCallbackInterface connection) throws DisconnectException
+  {
+  }
+
+  public void readLocalXACommit (ConnectionCallbackInterface connection) throws DisconnectException
+  {
+
+    startSameIdChainParse();
+    parseSYNCCTLreply(connection);
+    endOfSameIdChainData();
+
+    NetXACallInfo callInfo =
+      netAgent_.netConnection_.xares_.callInfoArray_[netAgent_.netConnection_.currXACallInfoOffset_];
+    callInfo.xaInProgress_ = false;
+    callInfo.xaWasSuspended = false;
+    connection.completeLocalCommit();
+  }
+
+  public void readLocalXARollback (ConnectionCallbackInterface connection) throws DisconnectException
+  {
+    startSameIdChainParse();
+    parseSYNCCTLreply(connection);
+    endOfSameIdChainData();
+    connection.completeLocalRollback();
+  }
+
+  protected void readXaStartUnitOfWork(NetConnection conn) throws DisconnectException
+  {
+    startSameIdChainParse();
+    parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+  }
+
+  protected int readXaEndUnitOfWork(NetConnection conn) throws DisconnectException
+  {
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    int xaFlags = callInfo.xaFlags_;
+
+    startSameIdChainParse();
+    parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+    if (xaFlags == XAResource.TMFAIL)
+      return javax.transaction.xa.XAException.XA_RBROLLBACK;
+    return javax.transaction.xa.XAResource.XA_OK;
+  }
+
+  protected int readXaPrepare(NetConnection conn) throws DisconnectException
+  {
+    startSameIdChainParse();
+    int synctype = parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    if( synctype == NetXAResource.XARETVAL_XARDONLY )
+    { // xaretval of read-only, make sure flag agrees
+      callInfo.setReadOnlyTransactionFlag( true );
+    }
+    else
+    { // xaretval NOT read-only, make sure flag agrees
+      callInfo.setReadOnlyTransactionFlag( false );
+    }
+    return synctype;
+  }
+
+  protected void readXaCommit(NetConnection conn) throws DisconnectException
+  {
+    startSameIdChainParse();
+    parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    callInfo.xaInProgress_ = false;
+    conn.completeLocalCommit();
+  }
+
+  protected int readXaRollback(NetConnection conn) throws DisconnectException
+  {
+    startSameIdChainParse();
+    parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    callInfo.xaInProgress_ = false;
+    callInfo.xaWasSuspended = false;
+    conn.completeLocalRollback();
+
+    return javax.transaction.xa.XAResource.XA_OK;
+    }
+
+  protected void readXaRecover(NetConnection conn) throws DisconnectException
+  {
+    startSameIdChainParse();
+    parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+  }
+
+  protected void readXaForget(NetConnection conn) throws DisconnectException
+  {
+    startSameIdChainParse();
+    parseSYNCCTLreply(conn);
+    endOfSameIdChainData();
+  }
+  //----------------------helper methods----------------------------------------
+
+  //--------------------- parse DDM Reply Data--------------------------------------
+
+
+    // The SYNCCRD Reply Mesage
+  //
+  // Returned from Server:
+  //   XARETVAL - required
+  int parseSYNCCRD (ConnectionCallbackInterface connection) throws DisconnectException
+  {
+    boolean svrcodReceived = false;
+    int svrcod = CodePoint.SVRCOD_INFO;
+    int xaretval = 0;
+    int synctype = 0;
+    java.util.Hashtable indoubtTransactions = null;
+    NetConnection conn = netAgent_.netConnection_;
+
+    parseLengthAndMatchCodePoint (CodePoint.SYNCCRD);
+    pushLengthOnCollectionStack();
+    int peekCP = peekCodePoint();
+
+    while (peekCP != Reply.END_OF_COLLECTION) {
+
+      boolean foundInPass = false;
+
+      if (peekCP == CodePoint.SVRCOD) {
+        foundInPass = true;
+        svrcodReceived = checkAndGetReceivedFlag (svrcodReceived);
+        svrcod = parseSVRCOD (CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
+        peekCP = peekCodePoint();
+      }
+
+      if (peekCP == CodePoint.XARETVAL) {
+        foundInPass = true;
+        xaretval = parseXARETVAL();
+        conn.xares_.callInfoArray_[conn.currXACallInfoOffset_].xaRetVal_ =
+            xaretval;
+        peekCP = peekCodePoint();
+      }
+
+      if (peekCP == CodePoint.SYNCTYPE) {
+        foundInPass = true;
+        synctype = parseSYNCTYPE();
+        peekCP = peekCodePoint();
+      }
+
+      if (peekCP == CodePoint.PRPHRCLST) {
+        foundInPass = true;
+        indoubtTransactions = parseIndoubtList();
+        conn.setIndoubtTransactions(indoubtTransactions);
+        peekCP = peekCodePoint();
+      }
+
+      if (!foundInPass)
+        doPrmnsprmSemantics (peekCP);
+    }
+    popCollectionStack();
+
+
+    return xaretval;
+
+  }
+
+  // Process XA return value
+  protected int parseXARETVAL() throws DisconnectException
+  {
+    parseLengthAndMatchCodePoint (CodePoint.XARETVAL);
+    return readInt();
+  }
+
+  // Process XA return value
+  protected byte parseSYNCTYPE() throws DisconnectException
+  {
+    parseLengthAndMatchCodePoint (CodePoint.SYNCTYPE);
+    return readByte();
+  }
+
+  // This method handles the parsing of all command replies and reply data
+  // for the SYNNCTL command.
+  protected int parseSYNCCTLreply (ConnectionCallbackInterface connection) throws DisconnectException
+  {
+    int retval = 0;
+    int peekCP = peekCodePoint();
+
+    if (peekCP != CodePoint.SYNCCRD) {
+      parseSYNCCTLError (peekCP);
+      return -1;
+    }
+    retval =  parseSYNCCRD (connection);
+
+    peekCP = peekCodePoint();
+    while (peekCP == CodePoint.SQLSTT) {
+      String s = parseSQLSTT ();
+      //JCFTMP, need to null out the client list?
+      netAgent_.netConnection_.xares_.addSpecialRegisters(s);
+      peekCP = peekCodePoint();
+    }
+
+    return retval;
+  }
+
+
+  //------------------------parse DDM Scalars-----------------------------
+
+
+
+
+  private String parseSQLSTT () throws DisconnectException {
+    parseLengthAndMatchCodePoint (CodePoint.SQLSTT);
+      return parseSQLSTTGRPNOCMorNOCS ();
+  }
+
+  private String parseSQLSTTGRPNOCMorNOCS () throws DisconnectException
+  {
+    int mixedNullInd = readUnsignedByte();
+    int singleNullInd = 0;
+    String sqlsttString = null;
+    int stringLength = 0;
+
+    if (mixedNullInd == CodePoint.NULLDATA) {
+      singleNullInd = readUnsignedByte();
+      if (singleNullInd == CodePoint.NULLDATA) {
+        // throw DTAMCHRM
+        doDtamchrmSemantics();
+      }
+      // read 4-byte length
+      stringLength = readInt();
+      // read sqlstt string
+      sqlsttString = readString (stringLength, netAgent_.targetTypdef_.getCcsidSbcEncoding());
+    }
+    else {
+      // read 4-byte length
+      stringLength = readInt();
+      // read sqlstt string
+      sqlsttString = readString (stringLength, netAgent_.targetTypdef_.getCcsidMbcEncoding());
+      // read null indicator
+      singleNullInd = readUnsignedByte();
+    }
+    return sqlsttString;
+  }
+
+
+  protected int parseXIDCNT () throws DisconnectException
+  {
+    parseLengthAndMatchCodePoint (CodePoint.XIDCNT);
+    return readUnsignedShort();
+  }
+
+  protected Xid parseXID () throws DisconnectException
+  {
+    parseLengthAndMatchCodePoint (CodePoint.XID);
+    int formatId = readInt();
+    int gtridLen = readInt();
+    int bqualLen = readInt();
+    byte[] gtrid = readBytes(gtridLen);
+    byte[] bqual = readBytes(bqualLen);
+
+    return new org.apache.derby.client.ClientXid(formatId, gtrid, bqual);
+  }
+
+  protected java.util.Hashtable parseIndoubtList() throws DisconnectException
+  {
+    boolean found = false;
+    int port = 0;
+    int numXid = 0;
+    String sIpAddr = null;
+    int peekCP = peekCodePoint();
+    parseLengthAndMatchCodePoint (CodePoint.PRPHRCLST);
+    peekCP = peekCodePoint();
+    if (peekCP == CodePoint.XIDCNT) {
+      found = true;
+      numXid = parseXIDCNT();
+      peekCP = peekCodePoint();
+    }
+
+    java.util.Hashtable indoubtTransactions = new java.util.Hashtable();
+    while( peekCP == CodePoint.XID )
+    {
+      Xid xid = parseXID();
+      indoubtTransactions.put(xid, new NetIndoubtTransaction(xid, null, null, null, sIpAddr, port));
+      peekCP = peekCodePoint();
+    }
+
+    return indoubtTransactions;
+  }
+
+}
+
+
+

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionReply.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionRequest.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionRequest.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionRequest.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionRequest.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,318 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.NetXAConnectionRequest
+
+   Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors, where applicable.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+*/
+
+package org.apache.derby.client.net;
+
+import org.apache.derby.client.am.SqlException;
+import javax.transaction.xa.XAResource;
+import javax.transaction.xa.Xid;
+
+public class NetXAConnectionRequest extends NetResultSetRequest
+{
+  NetXAConnectionRequest (NetAgent netAgent, CcsidManager ccsidManager, int bufferSize)
+  {
+    super (netAgent, ccsidManager, bufferSize);
+  }
+
+  //----------------------------- entry points ---------------------------------
+
+
+  //Build the SYNNCTL commit command
+  public void writeLocalXACommit (NetConnection conn) throws SqlException
+  {
+    NetXACallInfo callInfo =
+          conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    Xid xid = callInfo.xid_;
+    buildSYNCCTLMigrate();   // xa migrate to resync server
+    buildSYNCCTLCommit(CodePoint.TMLOCAL, xid);   // xa local commit
+  }
+
+  //Build the SYNNCTL rollback command
+  public void writeLocalXARollback (NetConnection conn) throws SqlException
+  {
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    buildSYNCCTLRollback(CodePoint.TMLOCAL);   // xa local rollback
+  }
+
+  public void writeXaStartUnitOfWork(NetConnection conn) throws SqlException
+  {
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    Xid xid = callInfo.xid_;
+    int xaFlags = callInfo.xaFlags_;
+
+    // create DSS command with reply.
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_NEW_UOW);
+
+    if (xid.getFormatId() != -1)
+      writeXID(CodePoint.XID, xid);
+    else
+      // write the null XID for local transaction on XA connection
+      writeNullXID(CodePoint.XID);
+
+    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+    updateLengthBytes();
+  }
+
+  public void writeXaEndUnitOfWork(NetConnection conn) throws SqlException
+  {
+    NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+    Xid xid = callInfo.xid_;
+    int xaFlags = callInfo.xaFlags_;
+
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_END_UOW);
+
+    if (xid.getFormatId() != -1)
+      writeXID(CodePoint.XID, xid);
+    else
+      // write the null XID for local transaction on XA connection
+      writeNullXID(CodePoint.XID);
+
+    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+
+    updateLengthBytes();
+  }
+
+ protected void writeXaPrepare(NetConnection conn) throws SqlException
+ {
+   NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+   Xid xid = callInfo.xid_;
+  // don't forget that xars.prepare() does not have flags, assume TMNOFLAGS
+   int xaFlags = XAResource.TMNOFLAGS;
+
+   createCommand ();
+
+   // save the length bytes for later update
+   markLengthBytes (CodePoint.SYNCCTL);
+
+   // SYNCTYPE
+   writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_PREPARE);
+
+   if (xid.getFormatId() != -1)
+     writeXID(CodePoint.XID, xid);
+   else
+     // write the null XID for local transaction on XA connection
+     writeNullXID(CodePoint.XID);
+
+   writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+   updateLengthBytes();
+  }
+
+  protected void writeXaCommit(NetConnection conn, Xid xid) throws SqlException
+  {
+   NetXACallInfo callInfo = conn.xares_.callInfoArray_[conn.currXACallInfoOffset_];
+   int xaFlags = callInfo.xaFlags_;
+
+   // create DSS command with no reply.
+   createCommand ();
+
+   // save the length bytes for later update
+   markLengthBytes (CodePoint.SYNCCTL);
+
+   // SYNCTYPE
+   writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_COMMITTED);
+
+   if (xid.getFormatId() != -1)
+     writeXID(CodePoint.XID, xid);
+   else
+     // write the null XID for local transaction on XA connection
+     writeNullXID(CodePoint.XID);
+
+   writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+   updateLengthBytes();
+ }
+
+  protected void writeXaRollback(NetConnection conn, Xid xid) throws SqlException
+  {
+    int xaFlags = XAResource.TMNOFLAGS;
+
+    // create DSS command with no reply.
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_ROLLBACK);
+
+    if (xid.getFormatId() != -1)
+      writeXID(CodePoint.XID, xid);
+    else
+      // write the null XID for local transaction on XA connection
+      writeNullXID(CodePoint.XID);
+
+    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+    updateLengthBytes();
+ }
+
+ protected void writeXaRecover(NetConnection conn, int flag) throws SqlException
+ {
+   // create DSS command with no reply.
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_INDOUBT);
+    writeXAFlags(CodePoint.XAFLAGS, flag);
+    updateLengthBytes();
+ }
+
+ protected void writeXaForget(NetConnection conn, Xid xid) throws SqlException
+ {
+
+   // create DSS command with no reply.
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_REQ_FORGET);
+
+    writeXID(CodePoint.XID, xid);
+
+    updateLengthBytes();
+ }
+
+  public void writeSYNCType(int codepoint, int syncType)
+  {
+    writeScalar1Byte (codepoint, syncType);
+  }
+
+  public void writeForget(int codepoint, int value)
+  {
+    writeScalar1Byte (codepoint, value);
+  }
+
+  public void writeReleaseConversation(int codepoint, int value)
+  {
+    writeScalar1Byte (codepoint, value);
+  }
+
+  void writeNullXID(int codepoint)
+  {
+    int nullXID = -1;
+    writeScalar4Bytes (codepoint, nullXID);
+  }
+
+  void writeXID(int codepoint, Xid xid) throws SqlException
+  {
+    int len = 0;
+    int formatId = xid.getFormatId();
+    byte[] gtrid = xid.getGlobalTransactionId();
+    byte[] bqual = xid.getBranchQualifier();
+
+    markLengthBytes(codepoint);
+
+    len = 4;                    // length of formatId
+    len += (bqual.length + 4);  // bqual length
+    len += (gtrid.length + 4);  // gtrid length
+
+    write4Bytes(formatId);
+    write4Bytes(gtrid.length);
+    write4Bytes(bqual.length);
+
+    // Mare sure request buffer has enough space to write this byte array.
+    ensureLength (offset_ + gtrid.length);
+    System.arraycopy(gtrid, 0, bytes_, offset_, gtrid.length);
+    offset_ += gtrid.length;
+
+    ensureLength (offset_ + bqual.length);
+    System.arraycopy(bqual, 0, bytes_, offset_, bqual.length);
+    offset_ += bqual.length;
+
+    updateLengthBytes();
+
+  }
+
+
+  void writeXAFlags(int codepoint, int xaFlags)
+  {
+    writeScalar4Bytes (codepoint, xaFlags);
+  }
+
+
+  //----------------------helper methods----------------------------------------
+  // These methods are "private protected", which is not a recognized java privilege,
+  // but means that these methods are private to this class and to subclasses,
+  // and should not be used as package-wide friendly methods.
+
+
+
+
+
+  void buildSYNCCTLMigrate() throws SqlException
+  {
+  }
+
+  void buildSYNCCTLCommit (int xaFlags, Xid xid) throws SqlException
+  {
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_COMMITTED);
+
+    if (xid.getFormatId() != -1)
+      writeXID(CodePoint.XID, xid);
+    else
+      // write the null XID for local transaction on XA connection
+      writeNullXID(CodePoint.XID);
+
+    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+
+    updateLengthBytes();
+  }
+
+  void buildSYNCCTLRollback (int xaFlags) throws SqlException
+  {
+    createCommand ();
+
+    // save the length bytes for later update
+    markLengthBytes (CodePoint.SYNCCTL);
+
+    // SYNCTYPE
+    writeSYNCType(CodePoint.SYNCTYPE, CodePoint.SYNCTYPE_ROLLBACK);
+
+    // write the null XID for local transaction on XA connection
+    writeNullXID(CodePoint.XID);
+    writeXAFlags(CodePoint.XAFLAGS, xaFlags);
+    updateLengthBytes();
+  }
+
+}
+
+
+

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAConnectionRequest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAResource.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAResource.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAResource.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAResource.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,1193 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.NetXAResource
+
+   Copyright (c) 2003, 2005 The Apache Software Foundation or its licensors, where applicable.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+*/
+/**********************************************************************
+ *
+ *
+ *  Component Name =
+ *
+ *      Package Name = org.apache.derby.client.net
+ *
+ *  Descriptive Name = class implements XAResource
+ *
+ *  Status = New code
+ *
+ *  Function = Handle XA methods
+ *
+ *  List of Classes
+ *              - NetXAResource
+ *
+ *  Restrictions : None
+ *
+ **********************************************************************/
+package org.apache.derby.client.net;
+
+import org.apache.derby.client.net.NetXACallInfo;
+import org.apache.derby.client.am.Connection;
+import org.apache.derby.client.am.SqlException;
+import java.util.*;
+import org.apache.derby.client.ClientXid;
+import javax.transaction.xa.*;
+import javax.sql.*;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+public class NetXAResource implements XAResource
+{
+  public static final int TMTIMEOUT = 0x00000100;
+  public static final int ACTIVE_ONLY = -1;
+  public static final int XA_NULL_XID = -1; // null Xid has Format Id of -1
+  public static final int INITIAL_CALLINFO_ELEMENTS = 1;
+  public static final int RECOVER_XID_ARRAY_LENGTH  = 10;
+  public static final ClientXid nullXid = new ClientXid();
+
+  // xaretval defines
+  public static final int XARETVAL_XALCSNOTSUPP	= 99; // Loosely Coupled Not Supported
+  public static final int XARETVAL_RBROLLBACK   = 100; // Rollback
+  public static final int XARETVAL_RBCOMMFAIL   = 101; // Rollback Communication Failure
+  public static final int XARETVAL_RBDEADLOCK   = 102; // Rollback Deadlock
+  public static final int XARETVAL_RBINTEGRITY  = 103; // Rollback integrity violation
+  public static final int XARETVAL_RBOTHER      = 104; // Rollback Other
+  public static final int XARETVAL_RBPROTO      = 105; // Rollback Protocol
+  public static final int XARETVAL_RBTIMEOUT    = 106; // Rollback Timeout
+  public static final int XARETVAL_RBTRANSIENT  = 107; // Rollback Transaction branch
+  public static final int XARETVAL_NODISSOCIATE = 108; // Unable to Dissociate resources from connection
+  public static final int XARETVAL_XATWOPHASE   = 13; // TwoPhase commit required
+  public static final int XARETVAL_XAPROMOTED   = 12; // Promoted - unused
+  public static final int XARETVAL_XADEFERRED   = 11; // Deferred - unused
+  public static final int XARETVAL_XACOMMFAIL   = 10; // Communication Failure
+  public static final int XARETVAL_XANOMIGRATE  = 9; // No Migration
+  public static final int XARETVAL_XAHEURHAZ    = 8; // Heuristically completed
+  public static final int XARETVAL_XAHEURCOM    = 7; // Heuristically Commited
+  public static final int XARETVAL_XAHEURRB     = 6; // Heuristically Rolledback
+  public static final int XARETVAL_XAHEURMIX    = 5; // Branch heuristically commit and rollback
+  public static final int XARETVAL_XARETRY      = 4; // Retry Commit
+  public static final int XARETVAL_XARDONLY     = 3; // Read Only
+  public static final int XARETVAL_XAOK         = 0; // OK
+  public static final int XARETVAL_XAERASYNC    = -2; // Async Request not possible
+  public static final int XARETVAL_XAERRMERR    = -3; // RM Error
+  public static final int XARETVAL_XAERNOTA     = -4; // XID does not exist
+  public static final int XARETVAL_XAERINVAL    = -5; // Invalid arguments
+  public static final int XARETVAL_XAERPROTO    = -6; // Protocol Violation
+  public static final int XARETVAL_XAERRMFAIL   = -7; // RM Failed
+  public static final int XARETVAL_XAERDUPID    = -8; // Duplicate XID
+  public static final int XARETVAL_XAEROUTSIDE  = -9; // Local tansaction active
+  public static final int XARETVAL_XAEROPENRES  = -10; // Open resources
+
+  // xaFunction defines, shows which queued XA function is being performed
+  public static final int XAFUNC_NONE           = 0;
+  public static final int XAFUNC_COMMIT         = 1;
+  public static final int XAFUNC_END            = 2;
+  public static final int XAFUNC_FORGET         = 3;
+  public static final int XAFUNC_PREPARE        = 4;
+  public static final int XAFUNC_RECOVER        = 5;
+  public static final int XAFUNC_ROLLBACK       = 6;
+  public static final int XAFUNC_START          = 7;
+  public static final String XAFUNCSTR_NONE     = "No XA Function";
+  public static final String XAFUNCSTR_COMMIT   = "XAResource.commit()";
+  public static final String XAFUNCSTR_END      = "XAResource.end()";
+  public static final String XAFUNCSTR_FORGET   = "XAResource.forget()";
+  public static final String XAFUNCSTR_PREPARE  = "XAResource.prepare()";
+  public static final String XAFUNCSTR_RECOVER  = "XAResource.recover()";
+  public static final String XAFUNCSTR_ROLLBACK = "XAResource.rollback()";
+  public static final String XAFUNCSTR_START    = "XAResource.start()";
+
+  public int nextElement = 0;
+
+  // XAResources with same RM group list
+  protected static Vector xaResourceSameRMGroup_ = new Vector();
+  protected int sameRMGroupIndex_ = 0;
+  protected NetXAResource nextSameRM_ = null;
+  protected boolean ignoreMe_ = false;
+
+  /* KATHEY CHECK THIS COMMENT TOO. 
+   * Need to remove NetXAResource objects from this group when they are
+   *  freed.
+   */
+
+  public org.apache.derby.client.am.SqlException exceptionsOnXA = null;
+
+  XAConnection xaconn_;
+  org.apache.derby.client.net.NetXAConnection conn_;
+  int rmId_; // unique RmId generated by XAConnection
+	// KATHEY change to a single callInfo field (not an array)
+  NetXACallInfo callInfoArray_[] =
+      new NetXACallInfo[INITIAL_CALLINFO_ELEMENTS];
+  int numXACallInfo_ = INITIAL_CALLINFO_ELEMENTS;
+  int connectionCount_ = 1;
+  int activeXATransCount_ = 0;
+  String rmIdx_; // userid in case we need to create a secondary connection
+  String rmIdy_; // password in case we need to create a secondary connection
+	// KATHEY remove port and ipaddr_
+  int port_;     // port needed to make secondary connection for recover in DS mode.
+  String ipaddr_;  // ip address needed to make secondary connection for recover in DS mode.
+
+  private List specialRegisters_ = Collections.synchronizedList(new LinkedList());
+  public NetXAResource( XAConnection xaconn, int rmId,
+                       String userId, String password,
+                       org.apache.derby.client.net.NetXAConnection conn )
+  {
+    xaconn_ = xaconn;
+    rmId_ = rmId;
+    conn_ = conn;
+    rmIdx_ = userId;
+    rmIdy_ = password;
+    port_ = conn.netAgent_.getPort();
+    ipaddr_ = conn.netAgent_.socket_.getLocalAddress().getHostAddress();
+    conn.setNetXAResource(this);
+
+    // link the primary connection to the first XACallInfo element
+    conn_.currXACallInfoOffset_ = 0;
+
+    // construct the NetXACallInfo object for the array.
+    for (int i = 0; i < INITIAL_CALLINFO_ELEMENTS; ++i)
+      callInfoArray_[i] = new NetXACallInfo(null,XAResource.TMNOFLAGS,
+                                           Connection.XA_OPEN_IDLE, this,
+                                           null);
+
+    // initialize the first XACallInfo element with the information from the
+    //  primary connection
+    callInfoArray_[0].actualConn_ = conn_;
+    callInfoArray_[0].currConnection_ = true;
+    callInfoArray_[0].freeEntry_ = false;
+    // ~~~ save conn_ connection variables in callInfoArray_[0]
+    callInfoArray_[0].saveConnectionVariables();
+
+    // add this new XAResource to the list of other XAResources for the Same RM
+    initForReuse();
+  }
+
+  public void commit( Xid xid, boolean onePhase ) throws XAException
+  {
+	NetAgent netAgent = conn_.netAgent_;
+	int rc = XAResource.XA_OK;
+
+	exceptionsOnXA = null;
+	if (conn_.agent_.loggingEnabled())
+	  conn_.agent_.logWriter_.traceEntry (this, "commit", xid, onePhase);
+	if( conn_.isClosed() )
+	  connectionClosedFailure();
+
+	// update the XACallInfo
+	NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+	callInfo.xaFlags_ = ( onePhase ? XAResource.TMONEPHASE:
+						  XAResource.TMNOFLAGS);
+	callInfo.xid_ = xid;
+	callInfo.xaResource_ = this;
+	callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try {
+	  netAgent.beginWriteChainOutsideUOW();
+	  netAgent.netConnectionRequest_.writeXaCommit(conn_, xid);
+	  netAgent.flowOutsideUOW();
+	  netAgent.netConnectionReply_.readXaCommit(conn_);
+	  if( callInfo.xaRetVal_ != XARETVAL_XAOK )
+          { // xaRetVal has possible error, format it
+            callInfo.xaFunction_ = XAFUNC_COMMIT;
+            rc = xaRetValErrorAccumSQL( callInfo, rc );
+            callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+          }
+	  netAgent.endReadChain();
+	}
+	catch( SqlException sqle )
+	{
+	  rc = XAException.XAER_RMERR;
+	  exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+		(sqle, exceptionsOnXA);
+	}
+	finally
+	{
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+		throwXAException(rc, false);
+  }
+
+  /** Ends the work performed on behalf of a transaction branch.
+   * The resource manager dissociates the XA resource from the
+   * transaction branch specified and let the transaction be
+   * completed.
+   *
+   * If TMSUSPEND is specified in flags, the transaction branch
+   * is temporarily suspended in incomplete state. The transaction
+   * context is in suspened state and must be resumed via start
+   * with TMRESUME specified.
+   *
+   * If TMFAIL is specified, the portion of work has failed.
+   * The resource manager may mark the transaction as rollback-only
+   *
+   * If TMSUCCESS is specified, the portion of work has completed
+   * successfully.
+   *
+   * @param xid A global transaction identifier that is the same as
+   * what was used previously in the start method.
+   *
+   * @param flags One of TMSUCCESS, TMFAIL, or TMSUSPEND
+   *
+   * @exception XAException An error has occurred. Possible XAException
+   * values are XAER_RMERR, XAER_RMFAILED, XAER_NOTA, XAER_INVAL,
+   * XAER_PROTO, or XA_RB*.
+   */
+
+  public void end( Xid xid, int flags ) throws XAException
+  {
+
+	NetAgent netAgent = conn_.netAgent_;
+	int rc = XAResource.XA_OK;
+    exceptionsOnXA = null;
+	if (conn_.agent_.loggingEnabled())
+      conn_.agent_.logWriter_.traceEntry (this, "end", xid, flags);
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+
+    NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+    callInfo.setReadOnlyTransactionFlag(conn_.readOnlyTransaction_);
+	callInfo.xaFlags_ = flags;
+	callInfo.xid_ = xid;
+	callInfo.xaResource_ = this;
+    callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try
+	{
+	  netAgent.beginWriteChainOutsideUOW();
+	  netAgent.netConnectionRequest_.writeXaEndUnitOfWork(conn_);
+	  netAgent.flowOutsideUOW();
+	  rc = netAgent.netConnectionReply_.readXaEndUnitOfWork(conn_);
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending end
+	  if( callInfo.xaRetVal_ != XARETVAL_XAOK )
+	  { // xaRetVal has possible error, format it
+		callInfo.xaFunction_ = XAFUNC_END;
+		rc = xaRetValErrorAccumSQL( callInfo, rc );
+		callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+	  }
+	  netAgent.endReadChain();
+	}
+	catch( SqlException sqle )
+	{
+	  rc = XAException.XAER_RMERR;
+	  exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+		(sqle, exceptionsOnXA);
+	}
+	finally
+	{
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+	  throwXAException(rc, false);
+	else
+		conn_.setXAState(Connection.XA_ENDED);
+
+  }
+
+  /** Tell the resource manager to forget about a heuristically (MANUALLY)
+   * completed transaction branch.
+   *
+   * @param xid A global transaction identifier
+   *
+   * @exception XAException An error has occurred. Possible exception
+   * values are XAER_RMERR, XAER_RMFAIL, XAER_NOTA, XAER_INVAL, or
+   * XAER_PROTO.
+   */
+
+  public void forget (Xid xid) throws XAException
+  {
+	NetAgent netAgent = conn_.netAgent_;
+	int rc = XAResource.XA_OK;
+    exceptionsOnXA = null;
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry (this, "forget", xid);
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+	NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+	callInfo.xid_ = xid;
+	callInfo.xaResource_ = this;
+	callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try
+    {
+	  // flow the required PROTOCOL to the server
+      netAgent.beginWriteChainOutsideUOW();
+
+      // sent the commit PROTOCOL
+      netAgent.netConnectionRequest_.writeXaForget(netAgent.netConnection_, xid);
+
+      netAgent.flowOutsideUOW();
+
+      // read the reply to the commit
+      netAgent.netConnectionReply_.readXaForget(netAgent.netConnection_);
+
+      netAgent.endReadChain();
+	  if( callInfo.xaRetVal_ != XARETVAL_XAOK )
+	  { // xaRetVal has possible error, format it
+		callInfo.xaFunction_ = XAFUNC_FORGET;
+		rc = xaRetValErrorAccumSQL( callInfo, rc );
+		callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+	  }
+    }
+    catch( SqlException sqle )
+    {
+      exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+                      (sqle, exceptionsOnXA);
+      throwXAException(XAException.XAER_RMERR);
+    }
+    finally {
+	conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+	  throwXAException(rc, false);
+
+  }
+
+  /** Obtain the current transaction timeout value set for this
+   * XAResource instance. If <CODE>XAResource.setTransactionTimeout</CODE>
+   * was not use prior to invoking this method, the return value
+   * is the default timeout set for the resource manager; otherwise,
+   * the value used in the previous <CODE>setTransactionTimeout</CODE> call is
+   * returned.
+   *
+   * @return the transaction timeout value in seconds.
+   *
+   * @exception XAException An error has occurred. Possible exception
+   * values are XAER_RMERR, XAER_RMFAIL.
+   */
+  public int getTransactionTimeout() throws XAException
+  {
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry (this, "getTransactionTimeout");
+    exceptionsOnXA = null;
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceExit (this, "getTransactionTimeout", 0);
+    return 0; // we don't support transaction timeout
+  }
+
+  /** Ask the resource manager to prepare for a transaction commit
+   * of the transaction specified in xid.
+   *
+   * @param xid A global transaction identifier
+   *
+   * @exception XAException An error has occurred. Possible exception
+   * values are: XA_RB*, XAER_RMERR, XAER_RMFAIL, XAER_NOTA, XAER_INVAL,
+   * or XAER_PROTO.
+   *
+   * @return A value indicating the resource manager's vote on the
+   * outcome of the transaction. The possible values are: XA_RDONLY
+   * or XA_OK. If the resource manager wants to roll back the
+   * transaction, it should do so by raising an appropriate XAException
+   * in the prepare method.
+   */
+  public int prepare(Xid xid) throws XAException
+  { // public interface for prepare
+    // just call prepareX with the recursion flag set to true
+    exceptionsOnXA = null;
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry (this, "prepare", xid);
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+
+	/// update the XACallInfo
+	NetAgent netAgent = conn_.netAgent_;
+	int rc = XAResource.XA_OK;
+	NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+	callInfo.xid_ = xid;
+	callInfo.xaResource_ = this;
+	callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try {
+	     netAgent.beginWriteChainOutsideUOW();
+		  // sent the prepare PROTOCOL
+		 netAgent.netConnectionRequest_.writeXaPrepare(conn_);
+		 netAgent.flowOutsideUOW();
+
+		 // read the reply to the prepare
+		 rc = netAgent.netConnectionReply_.readXaPrepare(conn_);
+		 if( (callInfo.xaRetVal_ != XARETVAL_XAOK) &&
+			 (callInfo.xaRetVal_ != XARETVAL_XARDONLY) )
+		 { // xaRetVal has possible error, format it
+		   callInfo.xaFunction_ = XAFUNC_PREPARE;
+		   rc = xaRetValErrorAccumSQL( callInfo, rc );
+		   callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+		 }
+
+		 netAgent.endReadChain();
+	}
+	catch( SqlException sqle )
+	{
+	  rc = XAException.XAER_RMERR;
+	  exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+		(sqle, exceptionsOnXA);
+	}
+	finally
+	{
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+		throwXAException(rc, false);
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceExit (this, "prepare", rc);
+    return rc;
+  }
+
+  /** Obtain a list of prepared transaction branches from a resource
+   * manager. The transaction manager calls this method during recovery
+   * to obtain the list of transaction branches that are currently in
+   * prepared or heuristically completed states.
+   *
+   * @param flag One of TMSTARTRSCAN, TMENDRSCAN, TMNOFLAGS. TMNOFLAGS
+   * must be used when no other flags are set in flags.
+   *
+   * @exception XAException An error has occurred. Possible values are
+   * XAER_RMERR, XAER_RMFAIL, XAER_INVAL, and XAER_PROTO.
+   *
+   * @return The resource manager returns zero or more XIDs for the
+   * transaction branches that are currently in a prepared or
+   * heuristically completed state. If an error occurs during the
+   * operation, the resource manager should raise the appropriate
+   * XAException.
+   *
+   */
+  public Xid[] recover(int flag) throws XAException
+  {
+    int rc = XAResource.XA_OK;
+    NetAgent netAgent = conn_.netAgent_;
+
+	if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry (this, "recover", flag);
+    exceptionsOnXA = null;
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+
+	Xid[] xidList = null;
+    int numXid = 0;
+
+	NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+	callInfo.xaFlags_ = flag;
+	callInfo.xaResource_ = this;
+	callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try {
+	  netAgent.beginWriteChainOutsideUOW();
+      // sent the recover PROTOCOL
+      netAgent.netConnectionRequest_.writeXaRecover(conn_, flag);
+      netAgent.flowOutsideUOW();
+	  netAgent.netConnectionReply_.readXaRecover(conn_);
+      if( callInfo.xaRetVal_ != XARETVAL_XAOK )
+      { // xaRetVal has possible error, format it
+        callInfo.xaFunction_ = XAFUNC_RECOVER;
+        rc = xaRetValErrorAccumSQL( callInfo, rc );
+        callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+      }
+      netAgent.endReadChain();
+	  if (conn_.indoubtTransactions_ != null)
+	  {
+		numXid = conn_.indoubtTransactions_.size();
+		xidList = new Xid[numXid];
+		int i=0;
+		nextElement = 0;
+		for (Enumeration e = conn_.indoubtTransactions_.keys() ;
+			 e.hasMoreElements(); i++)
+		{
+		  xidList[i] = (Xid) e.nextElement();
+		}
+	  }
+	}
+	catch( SqlException sqle )
+	{
+	  rc = XAException.XAER_RMERR;
+	  exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+		(sqle, exceptionsOnXA);
+	}
+	finally
+	{
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+		throwXAException(rc, false);
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceExit (this, "recover", xidList);
+    return xidList;
+  }
+
+  /** Inform the resource manager to roll back work done on behalf
+   * of a transaction branch
+   *
+   * @param xid A global transaction identifier
+   *
+   * @exception XAException An error has occurred
+   */
+  public void rollback(Xid xid) throws XAException
+  {
+	NetAgent netAgent = conn_.netAgent_;
+	int rc = XAResource.XA_OK;
+    exceptionsOnXA = null;
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry (this, "rollback", xid);
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+
+	// update the XACallInfo
+	NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+	callInfo.xid_ = xid;
+	callInfo.xaResource_ = this;
+	callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try {
+	  netAgent.beginWriteChainOutsideUOW();
+	  netAgent.netConnectionRequest_.writeXaRollback(conn_, xid);
+	  netAgent.flowOutsideUOW();
+	  // read the reply to the rollback
+	  rc = netAgent.netConnectionReply_.readXaRollback(conn_);
+	  netAgent.endReadChain();
+	  if(callInfo.xaRetVal_ != XARETVAL_XAOK )
+	  { // xaRetVal has possible error, format it
+		callInfo.xaFunction_ = XAFUNC_END;
+		rc = xaRetValErrorAccumSQL(callInfo, rc );
+		callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+	  }
+	}
+	catch( SqlException sqle )
+	{
+	  rc = XAException.XAER_RMERR;
+	  exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+		(sqle, exceptionsOnXA);
+	}
+	finally
+	{
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+		throwXAException(rc, false);
+
+  }
+
+  /** <P>Set the current transaction timeout value for this <CODE>XAResource</CODE>
+   * instance. This value overwrites the default transaction timeout
+   * value in the resource manager. The newly assigned timeout value
+   * is effective for the life of this <CODE>XAResource</CODE> instance unless
+   * a new value is set.<P>
+   *
+   * @param the transaction timeout value in seconds.
+   *
+   * @exception XAException An error has occurred. Possible exception values
+   * are XAER_RMERR, XAER_RMFAIL, or XAER_INVAL.
+   */
+  public boolean setTransactionTimeout(int seconds) throws XAException
+  {
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceExit (this, "setTransactionTimeout", false);
+    exceptionsOnXA = null;
+    return false; // we don't support transaction timeout in our layer.
+    /* int rc = xaSetTransTimeOut(seconds);
+       if (rc != XAResource.XA_OK)
+         throwXAException(rc); */
+  }
+
+  /** Start work on behalf of a transaction branch specified in xid
+   *
+   * @param xid A global transaction identifier to be associated
+   * with the resource
+   *
+   * @param flags One of TMNOFLAGS, TMJOIN, or TMRESUME
+   *
+   * @exception XAException An error has occurred. Possible exceptions   * are XA_RB*, XAER_RMERR, XAER_RMFAIL, XAER_DUPID, XAER_OUTSIDE,
+   * XAER_NOTA, XAER_INVAL, or XAER_PROTO.
+   *
+   */
+  public synchronized void start(Xid xid, int flags) throws XAException
+  {
+
+	NetAgent netAgent = conn_.netAgent_;
+	int rc = XAResource.XA_OK;
+	exceptionsOnXA = null;
+	if (conn_.agent_.loggingEnabled())
+	  conn_.agent_.logWriter_.traceEntry (this, "start", xid, flags);
+	if( conn_.isClosed() )
+	  connectionClosedFailure();
+
+	// update the XACallInfo
+	NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+	callInfo.xaFlags_ = flags;
+	callInfo.xaInProgress_ = true;
+	callInfo.xid_ = xid;
+	callInfo.xaResource_ = this;
+	callInfo.xaRetVal_ = XARETVAL_XAOK; // initialize XARETVAL
+	try {
+	  netAgent.beginWriteChainOutsideUOW();
+	  netAgent.netConnectionRequest_.writeXaStartUnitOfWork(conn_);
+	  netAgent.flowOutsideUOW();
+	  netAgent.netConnectionReply_.readXaStartUnitOfWork(conn_);
+	  if( callInfo.xaRetVal_ != XARETVAL_XAOK )
+	  { // xaRetVal has possible error, format it
+		callInfo.xaFunction_ = XAFUNC_START;
+		rc = xaRetValErrorAccumSQL( callInfo, rc );
+		callInfo.xaRetVal_ = XARETVAL_XAOK; // re-initialize XARETVAL
+	  }
+	  // Setting this is currently required to avoid client from sending
+	  // commit for autocommit.
+	  if (rc == XARETVAL_XAOK)
+		  conn_.setXAState(Connection.XA_ACTIVE);
+
+	}
+	catch( SqlException sqle )
+	{
+	  rc = XAException.XAER_RMERR;
+	  exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+		(sqle, exceptionsOnXA);
+	}
+	finally
+	{
+	  conn_.pendingEndXACallinfoOffset_ = -1; // indicate no pending callinfo
+	}
+	if (rc != XAResource.XA_OK)
+		throwXAException(rc, false);
+  }
+
+
+
+  protected void throwXAException(int rc) throws XAException
+  {
+    // By default, throwXAException will reset the state of the failed connection
+    throwXAException(rc, rc!=XAException.XAER_NOTA);
+  }
+
+  private String getXAExceptionText( int rc )
+  {
+    String xaExceptionText;
+    switch( rc )
+    {
+      case javax.transaction.xa.XAException.XA_RBROLLBACK:
+        xaExceptionText = "XA_RBROLLBACK";
+        break;
+      case javax.transaction.xa.XAException.XA_RBCOMMFAIL:
+        xaExceptionText = "XA_RBCOMMFAIL";
+        break;
+      case javax.transaction.xa.XAException.XA_RBDEADLOCK:
+        xaExceptionText = "XA_RBDEADLOCK";
+        break;
+      case javax.transaction.xa.XAException.XA_RBINTEGRITY:
+        xaExceptionText = "XA_RBINTEGRITY";
+        break;
+      case javax.transaction.xa.XAException.XA_RBOTHER:
+        xaExceptionText = "XA_RBOTHER";
+        break;
+      case javax.transaction.xa.XAException.XA_RBPROTO:
+        xaExceptionText = "XA_RBPROTO";
+        break;
+      case javax.transaction.xa.XAException.XA_RBTIMEOUT:
+        xaExceptionText = "XA_RBTIMEOUT";
+        break;
+      case javax.transaction.xa.XAException.XA_RBTRANSIENT:
+        xaExceptionText = "XA_RBTRANSIENT";
+        break;
+      case javax.transaction.xa.XAException.XA_NOMIGRATE:
+        xaExceptionText = "XA_NOMIGRATE";
+        break;
+      case javax.transaction.xa.XAException.XA_HEURHAZ:
+        xaExceptionText = "XA_HEURHAZ";
+        break;
+      case javax.transaction.xa.XAException.XA_HEURCOM:
+        xaExceptionText = "XA_HEURCOM";
+        break;
+      case javax.transaction.xa.XAException.XA_HEURRB:
+        xaExceptionText = "XA_HEURRB";
+        break;
+      case javax.transaction.xa.XAException.XA_HEURMIX:
+        xaExceptionText = "XA_HEURMIX";
+        break;
+      case javax.transaction.xa.XAException.XA_RETRY:
+        xaExceptionText = "XA_RETRY";
+        break;
+      case javax.transaction.xa.XAException.XA_RDONLY:
+        xaExceptionText = "XA_RDONLY";
+        break;
+      case javax.transaction.xa.XAException.XAER_ASYNC:
+        xaExceptionText = "XAER_ASYNC";
+        break;
+      case javax.transaction.xa.XAException.XAER_RMERR:
+        xaExceptionText = "XAER_RMERR";
+        break;
+      case javax.transaction.xa.XAException.XAER_NOTA:
+        xaExceptionText = "XAER_NOTA";
+        break;
+      case javax.transaction.xa.XAException.XAER_INVAL:
+        xaExceptionText = "XAER_INVAL";
+        break;
+      case javax.transaction.xa.XAException.XAER_PROTO:
+        xaExceptionText = "XAER_PROTO";
+        break;
+      case javax.transaction.xa.XAException.XAER_RMFAIL:
+        xaExceptionText = "XAER_RMFAIL";
+        break;
+      case javax.transaction.xa.XAException.XAER_DUPID:
+        xaExceptionText = "XAER_DUPID";
+        break;
+      case javax.transaction.xa.XAException.XAER_OUTSIDE:
+        xaExceptionText = "XAER_OUTSIDE";
+        break;
+      case XAResource.XA_OK:
+        xaExceptionText = "XA_OK";
+        break;
+      default:
+        xaExceptionText = "Unknown Error";
+        break;
+    }
+    return xaExceptionText;
+  }
+
+  protected void throwXAException(int rc, boolean resetFlag) throws XAException
+  { // ~~~
+    String xaExceptionText;
+    if (resetFlag)
+    {
+    // reset the state of the failed connection
+    NetXACallInfo callInfo = callInfoArray_[conn_.currXACallInfoOffset_];
+    callInfo.xaInProgress_ = false;
+    callInfo.xaWasSuspended = false;
+    callInfo.xaState_ = Connection.XA_OPEN_IDLE;
+    conn_.setXAState( Connection.XA_OPEN_IDLE );
+    }
+
+    xaExceptionText = getXAExceptionText( rc );
+    // save the SqlException chain to add it to the XAException
+    org.apache.derby.client.am.SqlException sqlExceptions = exceptionsOnXA;
+
+    while( exceptionsOnXA != null )
+    { // one or more SqlExceptions received, format them
+      xaExceptionText = xaExceptionText + " : " + exceptionsOnXA.getMessage();
+      exceptionsOnXA = (org.apache.derby.client.am.SqlException)
+                           exceptionsOnXA.getNextException();
+    }
+    org.apache.derby.client.am.XaException xaException =
+        new org.apache.derby.client.am.XaException( conn_.agent_.logWriter_,
+                                            sqlExceptions,
+                                            xaExceptionText );
+    xaException.errorCode = rc;
+    throw xaException;
+  }
+
+  public boolean isSameRM(XAResource xares) throws XAException
+  {
+    boolean isSame = false; // preset that the RMs are NOT the same
+    exceptionsOnXA = null;
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry (this, "isSameRM", xares);
+    if( conn_.isClosed() )
+      connectionClosedFailure();
+
+    if ( xares instanceof org.apache.derby.client.net.NetXAResource )
+    { // both are NetXAResource so check to see if this is the same RM
+      // remember, isSame is initialized to false
+      NetXAResource derbyxares = (NetXAResource) xares;
+      while( true )
+      {
+        if( !conn_.databaseName_.equalsIgnoreCase(derbyxares.conn_.databaseName_) )
+          break; // database names are not equal, not same RM
+        if( !conn_.netAgent_.server_.equalsIgnoreCase
+            (derbyxares.conn_.netAgent_.server_) )
+        { // server name strings not equal, compare IP addresses
+          try
+          {
+            // 1st convert "localhost" to actual server name
+            String server1 = this.processLocalHost( conn_.netAgent_.server_ );
+            String server2 =
+                this.processLocalHost( derbyxares.conn_.netAgent_.server_ );
+            // now convert the server name to ip address
+            InetAddress serverIP1 = InetAddress.getByName( server1 );
+            InetAddress serverIP2 = InetAddress.getByName( server2 );
+            if( !serverIP1.equals( serverIP2 ) )
+              break; // server IPs are not equal, not same RM
+          }
+          catch(  UnknownHostException ue ) {break;}
+        }
+        if( conn_.netAgent_.port_ != derbyxares.conn_.netAgent_.port_ )
+          break; // ports are not equal, not same RM
+        isSame = true; // everything the same, set RMs are the same
+        break;
+      }
+    }
+
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceExit
+      (this, "isSameRM", isSame);
+    return isSame;
+  }
+
+  public static boolean xidsEqual( Xid xid1, Xid xid2 )
+  { // determine if the 2 xids contain the same values even if not same object
+    // comapre the format ids
+    if( xid1.getFormatId() != xid2.getFormatId() )
+      return false; // format ids are not the same
+
+    // compare the global transaction ids
+    int xid1Length = xid1.getGlobalTransactionId().length;
+    if( xid1Length != xid2.getGlobalTransactionId().length )
+      return false; // length of the global trans ids are not the same
+    byte[] xid1Bytes = xid1.getGlobalTransactionId();
+    byte[] xid2Bytes = xid2.getGlobalTransactionId();
+    int i;
+    for( i=0; i<xid1Length; ++i )
+    { // check all bytes are the same
+      if( xid1Bytes[i] != xid2Bytes[i] )
+        return false; // bytes in the global trans ids are not the same
+    }
+
+    // compare the branch qualifiers
+    xid1Length = xid1.getBranchQualifier().length;
+    if( xid1Length != xid2.getBranchQualifier().length )
+      return false; // length of the global trans ids are not the same
+    xid1Bytes = xid1.getBranchQualifier();
+    xid2Bytes = xid2.getBranchQualifier();
+    for( i=0; i<xid1Length; ++i )
+    { // check all bytes are the same
+      if( xid1Bytes[i] != xid2Bytes[i] )
+        return false; // bytes in the global trans ids are not the same
+    }
+
+    return true; // all of the fields are the same, xid1 == xid2
+  }
+
+
+	// KATHEY remove
+  protected void makeEntryCurrent( int offset ) throws SqlException
+  {
+    int currOffset = conn_.currXACallInfoOffset_; // offset of current XACallInfo
+    NetXACallInfo newCallInfo = callInfoArray_[offset];
+    if (conn_.agent_.loggingEnabled()) conn_.agent_.logWriter_.traceEntry
+      (this, "makeEntryCurrent", offset, currOffset);
+
+    if( currOffset == offset )
+    { // entry is already current
+      if( newCallInfo.convReleased_ &&
+          !newCallInfo.xaInProgress_ )
+      { // connection reuse, XA is not in Progress, reset connection
+        // transaction pooling
+        newCallInfo.convReleased_ = false;
+        if( !conn_.resetConnectionAtFirstSql_ )
+        { // resetConnectionAtFirstSql_ is false
+          /*
+            * at this point we have determined that a reset of this connection
+            * is required. We are already inside beginWriteChain() where a
+            * deferred reset would be done, however we might have switched
+            * connection to a connection that needed reset from a connection
+            * that didn't need reset. It is too late for the test for deferred
+            * reset in beginWriteChain so we call writeDeferredReset here.
+            * by setting the resetConnectionAtFirstSql_ flag we trigger the
+            * readDeferredReset in beginReadChain. This is done ONLY if
+            * resetConnectionAtFirstSql_ is not set, if it is then
+            * writeDeferredReset() has already been done.
+            */
+          conn_.resetConnectionAtFirstSql_ = true;
+          conn_.writeDeferredReset();
+        }
+      }
+      return; // entry is already current, nothing to do
+    }
+
+    callInfoArray_[currOffset].currConnection_ = false; // reset old current conn
+    callInfoArray_[currOffset].xaState_ = conn_.getXAState(); // save XA state
+    callInfoArray_[currOffset].freeEntry_ = false; // set entry in use
+
+    // set the new entry as the current entry, update conn_
+    newCallInfo.currConnection_ = true;
+    conn_.currXACallInfoOffset_ = offset;
+    conn_.setXAState(newCallInfo.xaState_);
+
+    if( newCallInfo.convReleased_ &&
+        !newCallInfo.xaInProgress_ )
+    { // connection reuse, XA is not in Progress, reset connection
+      // transaction pooling
+      newCallInfo.convReleased_ = false;
+      if( !conn_.resetConnectionAtFirstSql_ )
+      { // resetConnectionAtFirstSql_ is false
+        /*
+          * at this point we have determined that a reset of this connection
+          * is required. We are already inside beginWriteChain() where a
+          * deferred reset would be done, however we might have switched
+          * connection to a connection that needed reset from a connection
+          * that didn't need reset. It is too late for the test for deferred
+          * reset in beginWriteChain so we call writeDeferredReset here.
+          * by setting the resetConnectionAtFirstSql_ flag we trigger the
+          * readDeferredReset in beginReadChain. This is done ONLY if
+          * resetConnectionAtFirstSql_ is not set, if it is then
+          * writeDeferredReset() has already been done.
+          */
+        conn_.resetConnectionAtFirstSql_ = true;
+        conn_.writeDeferredReset();
+      }
+    }
+
+    if( conn_.agent_.loggingEnabled() )
+    { // logging enabled
+      conn_.agent_.logWriter_.traceExit (this, "makeEntryCurrent", offset);
+    }
+  }
+
+
+  public List getSpecialRegisters()
+  {
+    return specialRegisters_;
+  }
+
+  public void addSpecialRegisters(String s)
+  {
+    if (s.substring(0,1).equals("@"))
+    {
+      // SET statement is coming from Client
+      if (specialRegisters_.remove(s.substring(1)))
+      {
+        specialRegisters_.remove(s);
+        specialRegisters_.add(s.substring(1));
+        }
+        else
+        {
+        specialRegisters_.remove(s);
+        specialRegisters_.add(s);
+        }
+      }
+      else
+    { // SET statement is coming from Server
+    specialRegisters_.remove(s);
+    specialRegisters_.add(s);
+    }
+  }
+
+  private void connectionClosedFailure() throws XAException
+  { // throw an XAException XAER_RMFAIL, with a chained SqlException - closed
+    exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+                    (new SqlException( null, "Connection is Closed."),
+                     exceptionsOnXA);
+    throwXAException(javax.transaction.xa.XAException.XAER_RMFAIL);
+  }
+
+  private String getXAFuncStr( int xaFunc )
+  {
+    switch( xaFunc )
+    {
+      case XAFUNC_COMMIT:
+        return XAFUNCSTR_COMMIT;
+      case XAFUNC_END:
+        return XAFUNCSTR_END;
+      case XAFUNC_FORGET:
+        return XAFUNCSTR_FORGET;
+      case XAFUNC_PREPARE:
+        return XAFUNCSTR_PREPARE;
+      case XAFUNC_RECOVER:
+        return XAFUNCSTR_RECOVER;
+      case XAFUNC_ROLLBACK:
+        return XAFUNCSTR_ROLLBACK;
+      case XAFUNC_START:
+        return XAFUNCSTR_START;
+    }
+    return XAFUNCSTR_NONE;
+  }
+
+  protected int xaRetValErrorAccumSQL( NetXACallInfo callInfo, int currentRC )
+  {
+    int rc;
+    switch (callInfo.xaRetVal_)
+    {
+      case XARETVAL_XAOK:
+      case XARETVAL_NODISSOCIATE:
+        rc = XAResource.XA_OK;
+        break;
+      case XARETVAL_XALCSNOTSUPP:
+        rc = XAResource.XA_OK;
+        break;
+      case XARETVAL_RBROLLBACK:
+        rc = XAException.XA_RBROLLBACK;
+        break;
+      case XARETVAL_RBOTHER:
+        rc = XAException.XA_RBOTHER;
+        break;
+      case XARETVAL_RBDEADLOCK:
+        rc = XAException.XA_RBDEADLOCK;
+        break;
+      case XARETVAL_RBPROTO:
+        rc = XAException.XA_RBPROTO;
+        break;
+      case XARETVAL_XAERPROTO:
+        rc = XAException.XAER_PROTO;
+        break;
+      case XARETVAL_XARDONLY:
+        rc = XAException.XA_RDONLY;
+        break;
+      case XARETVAL_XAHEURCOM:
+        rc = XAException.XA_HEURCOM;
+        break;
+      case XARETVAL_XAHEURRB:
+        rc = XAException.XA_HEURRB;
+        break;
+      case XARETVAL_XAERDUPID:
+        rc = XAException.XAER_DUPID;
+        break;
+      case XARETVAL_XAERNOTA:
+        rc = XAException.XAER_NOTA;
+        break;
+      case XARETVAL_XAERRMERR:
+        rc = XAException.XAER_RMERR;
+        break;
+      case XARETVAL_XAERRMFAIL:
+        rc = XAException.XAER_RMFAIL;
+        break;
+      case XARETVAL_XAERINVAL:
+        rc = XAException.XAER_INVAL;
+        break;
+      default:
+        rc = XAException.XAER_RMFAIL;
+        break;
+    }
+
+    if( rc != XAResource.XA_OK )
+    { // error was detected
+      // create an SqlException to report this error within
+      String xaRetValStr = "Error executing a " +
+          getXAFuncStr( callInfo.xaFunction_ ) + ", " +
+          "Server returned " + getXAExceptionText( rc );
+      SqlException accumSql = new SqlException( conn_.netAgent_.logWriter_,
+          xaRetValStr, org.apache.derby.client.am.SqlState.undefined,
+          org.apache.derby.client.am.SqlCode.queuedXAError );
+      exceptionsOnXA = org.apache.derby.client.am.Utils.accumulateSQLException
+                                                    (accumSql, exceptionsOnXA);
+
+      if( currentRC != XAResource.XA_OK )
+      { // the rc passed into this function had an error also, prioritize error
+        if( currentRC < 0 )
+        { // rc passed in was a major error use it instead of current error
+          return currentRC;
+        }
+      }
+    }
+    return rc;
+  }
+
+  private String processLocalHost( String serverName )
+  {
+    if( serverName.equalsIgnoreCase("localhost") )
+    { // this is a localhost, find hostname
+      try
+      {
+        InetAddress localhostNameIA = InetAddress.getLocalHost();
+        String localhostName = localhostNameIA.getHostName();
+        return localhostName;
+      }
+      catch( SecurityException se ) {return serverName;}
+      catch( UnknownHostException ue ) {return serverName;}
+    }
+    // not "localhost", return original server name
+    return serverName;
+  }
+
+  protected void removeXaresFromSameRMchain()
+  {
+    // check all NetXAResources on the same RM for the NetXAResource to remove
+    try
+    {
+      this.ignoreMe_ = true; // use the ignoreMe_ flag to indicate the
+      // XAResource to remove
+      NetXAResource prevXAResource = null;
+      NetXAResource currXAResource;
+      synchronized( xaResourceSameRMGroup_ )
+      { // make sure no one changes this vector list
+        currXAResource = (NetXAResource) xaResourceSameRMGroup_.elementAt(
+                                                           sameRMGroupIndex_ );
+        while( currXAResource != null )
+        { // is this the XAResource to remove?
+          if( currXAResource.ignoreMe_ )
+          { // this NetXAResource is the one to remove
+            if( prevXAResource != null )
+            { // this XAResource is not first in chain, just move next to prev
+              prevXAResource.nextSameRM_ = currXAResource.nextSameRM_;
+            }
+            else
+            { // this XAResource is  first in chain, just move next to root
+              xaResourceSameRMGroup_.set( sameRMGroupIndex_,
+                  currXAResource.nextSameRM_ );
+            }
+            return;
+          }
+          // this is not the NetXAResource to remove, try the next one
+          prevXAResource = currXAResource;
+          currXAResource = currXAResource.nextSameRM_;
+        }
+      }
+    }
+    finally
+    {
+      this.ignoreMe_ = false;
+    }
+  }
+
+
+  public void initForReuse()
+  {
+    // add this new XAResource to the list of other XAResources for the Same RM
+    // first find out if there are any other XAResources for the same RM
+    // then check to make sure it is not already in the chain
+    synchronized(xaResourceSameRMGroup_)
+    { // make sure no one changes this vector list
+      int groupCount = xaResourceSameRMGroup_.size();
+      int index = 0;
+      int firstFreeElement = -1;
+      NetXAResource xaResourceGroup = null;
+
+      for( ; index<groupCount; ++index )
+      { // check if this group is the same RM
+        xaResourceGroup = (NetXAResource) xaResourceSameRMGroup_.elementAt( index );
+        if( xaResourceGroup == null )
+        { // this is a free element, save its index if first found
+          if( firstFreeElement == -1 )
+          { // first free element, save index
+            firstFreeElement = index;
+          }
+          continue; // go to next element
+        }
+        try
+        {
+          if( xaResourceGroup.isSameRM(this) )
+          { // it is the same RM add this XAResource to the chain if not there
+            NetXAResource nextXares = (NetXAResource)
+                          xaResourceSameRMGroup_.elementAt( sameRMGroupIndex_ );
+            while( nextXares != null )
+            { // is this NetXAResource the one we are trying to add?
+              if( nextXares.equals( this ) )
+              { // the XAResource to be added already is in chain, don't add
+                break;
+              }
+              // Xid was not on that NetXAResource, try the next one
+              nextXares = nextXares.nextSameRM_;
+            }
+
+            if( nextXares == null )
+            { // XAResource to be added is not in the chain already, add it
+              // add it at the head of the chain
+              sameRMGroupIndex_ = index;
+              this.nextSameRM_ = xaResourceGroup.nextSameRM_;
+              xaResourceGroup.nextSameRM_ = this;
+            }
+            return; // done
+          }
+        }
+        catch( XAException xae )
+        {}  
+      }
+
+      // no other same RM was found, add this as first of new group
+      if( firstFreeElement == -1 )
+      { // no free element found, add new element to end
+        xaResourceSameRMGroup_.add(this);
+        sameRMGroupIndex_ = groupCount;
+      }
+      else
+      { // use first free element found
+        xaResourceSameRMGroup_.setElementAt( this, firstFreeElement );
+        sameRMGroupIndex_ = firstFreeElement;
+      }
+    }
+  }
+}

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/NetXAResource.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/OpenSocketAction.java
URL: http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/OpenSocketAction.java?rev=165178&view=auto
==============================================================================
--- incubator/derby/code/trunk/java/client/org/apache/derby/client/net/OpenSocketAction.java (added)
+++ incubator/derby/code/trunk/java/client/org/apache/derby/client/net/OpenSocketAction.java Thu Apr 28 12:05:42 2005
@@ -0,0 +1,38 @@
+/*
+
+   Derby - Class org.apache.derby.client.net.OpenSocketAction
+
+   Copyright (c) 2002, 2005 The Apache Software Foundation or its licensors, where applicable.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+*/
+
+package org.apache.derby.client.net;
+
+public class OpenSocketAction implements java.security.PrivilegedExceptionAction
+{
+  private String server_;
+  private int port_;
+  
+  public OpenSocketAction (String server, int port)
+  {
+    server_ = server;
+    port_ = port;
+  }
+
+  public Object run () throws java.net.UnknownHostException, java.io.IOException
+  {
+    return new java.net.Socket (server_, port_);
+  }
+}

Propchange: incubator/derby/code/trunk/java/client/org/apache/derby/client/net/OpenSocketAction.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message