Added:
incubator/derby/code/trunk/java/client/org/apache/derby/client/net/Reply.java
URL:
http://svn.apache.org/viewcvs/incubator/derby/code/trunk/java/client/org/apache/derby/client/net/Reply.java?rev=165178&view=auto
==============================================================================
---
incubator/derby/code/trunk/java/client/org/apache/derby/client/net/Reply.java
(added)
+++
incubator/derby/code/trunk/java/client/org/apache/derby/client/net/Reply.java
Thu Apr 28 12:05:42 2005
@@ -0,0 +1,1501 @@
+/*
+
+ Derby - Class org.apache.derby.client.net.Reply
+
+ 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.SqlState;
+import org.apache.derby.client.am.SqlException;
+import org.apache.derby.client.am.SignedBinary;
+import java.io.ByteArrayOutputStream;
+
+public class Reply
+{
+ protected org.apache.derby.client.am.Agent agent_;
+ protected NetAgent netAgent_; //cheat-link to (NetAgent) agent_
+
+ private CcsidManager ccsidManager_;
+ protected final static int DEFAULT_BUFFER_SIZE = 32767;
+ protected byte[] buffer_;
+ protected int pos_;
+ protected int count_;
+
+ private int topDdmCollectionStack_;
+ private final static int MAX_MARKS_NESTING = 10;
+ private int[] ddmCollectionLenStack_;
+ private int ddmScalarLen_; // a value of -1 -> streamed ddm -> length unknown
+ private final static int EMPTY_STACK = -1;
+
+ protected boolean ensuredLengthForDecryption_ = false; // A layer lengths
have already been ensured in decrypt method.
+ protected byte[] longBufferForDecryption_ = null;
+ protected int longPosForDecryption_ = 0;
+ protected byte[] longValueForDecryption_ = null;
+ protected int longCountForDecryption_ = 0;
+
+ protected int dssLength_;
+ protected boolean dssIsContinued_;
+ private boolean dssIsChainedWithSameID_;
+ private boolean dssIsChainedWithDiffID_;
+ protected int dssCorrelationID_;
+
+ protected int peekedLength_ = 0;
+ protected int peekedCodePoint_ = END_OF_COLLECTION; // saves the peeked
codept
+ private int peekedNumOfExtendedLenBytes_ = 0;
+ private int currentPos_ = 0;
+
+ public final static int END_OF_COLLECTION = -1;
+ public final static int END_OF_SAME_ID_CHAIN = -2;
+ Reply (NetAgent netAgent, int bufferSize)
+ {
+ buffer_ = new byte[bufferSize];
+ agent_ = netAgent_ = netAgent;
+ ccsidManager_ = netAgent.targetCcsidManager_;
+ ddmCollectionLenStack_ = new int[Reply.MAX_MARKS_NESTING];
+ initialize ();
+ }
+
+ final void initialize ()
+ {
+ pos_ = 0;
+ count_ = 0;
+ topDdmCollectionStack_ = Reply.EMPTY_STACK;
+ for (int i = 0; i < Reply.MAX_MARKS_NESTING; i++) {
+ ddmCollectionLenStack_[i] = 0;
+ }
+ ddmScalarLen_ = 0;
+ dssLength_ = 0;
+ dssIsContinued_ = false;
+ dssIsChainedWithSameID_ = false;
+ dssIsChainedWithDiffID_ = false;
+ dssCorrelationID_ = 1;
+ }
+
+ final int getDdmLength()
+ {
+ return ddmScalarLen_;
+ }
+
+ // This is a helper method which shifts the buffered bytes from
+ // wherever they are in the current buffer to the beginning of
+ // different buffer (note these buffers could be the same).
+ // State information is updated as needed after the shift.
+ private final void shiftBuffer (byte[] destinationBuffer)
+ {
+ // calculate the size of the data in the current buffer.
+ int sz = count_ - pos_;
+
+ // copy this data to the new buffer starting at position 0.
+ System.arraycopy (buffer_, pos_, destinationBuffer, 0, sz);
+
+ // update the state information for data in the new buffer.
+ pos_ = 0;
+ count_ = sz;
+
+ // replace the old buffer with the new buffer.
+ buffer_ = destinationBuffer;
+ }
+
+ // This method makes sure there is enough room in the buffer
+ // for a certain number of bytes. This method will allocate
+ // a new buffer if needed and shift the bytes in the current buffer
+ // to make ensure space is available for a fill. Right now
+ // this method will shift bytes as needed to make sure there is
+ // as much room as possible in the buffer before trying to
+ // do the read. The idea is to try to have space to get as much data as
possible
+ // if we need to do a read on the socket's stream.
+ protected final void ensureSpaceInBufferForFill (int desiredSpace)
+ {
+ // calculate the total unused space in the buffer.
+ // this includes any space at the end of the buffer and any free
+ // space at the beginning resulting from bytes already read.
+ int currentAvailableSpace = (buffer_.length - count_) + pos_;
+
+ // check to see if there is enough free space.
+ if (currentAvailableSpace < desiredSpace) {
+
+ // there is not enough free space so we need more storage.
+ // we are going to double the buffer unless that happens to still be too
small.
+ // if more than double the buffer is needed, use the smallest amount
over this as possible.
+ int doubleBufferSize = (2 * buffer_.length);
+
+ int minumNewBufferSize = (desiredSpace - currentAvailableSpace) +
buffer_.length;
+ int newsz = minumNewBufferSize <= doubleBufferSize ? doubleBufferSize :
minumNewBufferSize;
+
+ byte[] newBuffer = new byte[newsz];
+
+ // shift everything from the old buffer to the new buffer
+ shiftBuffer (newBuffer);
+ }
+ else {
+
+ // there is enough free space in the buffer but let's make sure it is
all at the end.
+ // this is also important because if we are going to do a read, it would
be nice
+ // to get as much data as possible and making room at the end if the
buffer helps to
+ // ensure this.
+ if (pos_ != 0) {
+ shiftBuffer (buffer_);
+ }
+ }
+ }
+
+ // This method will attempt to read a minimum number of bytes
+ // from the underlying stream. This method will keep trying to
+ // read bytes until it has obtained at least the minimum number.
+ // Now returns the total bytes read for decryption, use to return void.
+ protected int fill (int minimumBytesNeeded) throws
org.apache.derby.client.am.DisconnectException
+ {
+ // make sure that there is enough space in the buffer to hold
+ // the minimum number of bytes needed.
+ ensureSpaceInBufferForFill (minimumBytesNeeded);
+
+ // read until the minimum number of bytes needed is now in the buffer.
+ // hopefully the read method will return as many bytes as it can.
+ int totalBytesRead = 0;
+ int actualBytesRead = 0;
+ do {
+ try {
+ // oops, we shouldn't expose the agent's input stream here, collapse
this into a read method on the agent
+ actualBytesRead = netAgent_.getInputStream().read (buffer_, count_,
buffer_.length - count_);
+ }
+ catch (java.io.IOException ioe) {
+ netAgent_.throwCommunicationsFailure ("Reply.fill()",
+ "InputStream.read()",
+ ioe.getMessage(),
+ "*");
+ }
+ finally {
+ if (agent_.loggingEnabled())
+ ((NetLogWriter) netAgent_.logWriter_).traceProtocolFlow (buffer_,
+ count_,
+ actualBytesRead,
+ NetLogWriter.TYPE_TRACE_RECEIVE,
+ "Reply",
+ "fill",
+ 2); // tracepoint
+ }
+ count_ += actualBytesRead;
+ totalBytesRead += actualBytesRead;
+
+ }
+ while ((totalBytesRead < minimumBytesNeeded) && (actualBytesRead != -1));
+
+ if (actualBytesRead == -1) {
+ if (totalBytesRead < minimumBytesNeeded) {
+ netAgent_.throwCommunicationsFailure ("Reply.fill()",
+ "InputStream.read()",
+ "insufficient data",
+ "*");
+ }
+ }
+ return totalBytesRead;
+ }
+
+ // Make sure a certain amount of Layer A data is in the buffer.
+ // The data will be in the buffer after this method is called.
+ // Now returns the total bytes read for decryption, use to return void.
+ protected final int ensureALayerDataInBuffer (int desiredDataSize) throws
org.apache.derby.client.am.DisconnectException
+ {
+ int totalBytesRead = 0;
+ // calulate the the number of bytes in the buffer.
+ int avail = count_ - pos_;
+
+ // read more bytes off the network if the data is not in the buffer
already.
+ if (avail < desiredDataSize) {
+ totalBytesRead = fill (desiredDataSize - avail);
+ }
+ return totalBytesRead;
+ }
+
+ protected final void ensureBLayerDataInBuffer (int desiredDataSize) throws
org.apache.derby.client.am.DisconnectException
+ {
+ if (dssIsContinued_ && (desiredDataSize > dssLength_)) {
+ int continueDssHeaderCount =
+ (((desiredDataSize - dssLength_) / 32767) + 1);
+ ensureALayerDataInBuffer (desiredDataSize + (continueDssHeaderCount *
2));
+ compressBLayerData (continueDssHeaderCount);
+ return;
+ }
+ ensureALayerDataInBuffer (desiredDataSize);
+ }
+
+ // this will probably never be called.
+ // it is included here in the highly unlikely event that a reply object
+ // exceeds 32K. for opimization purposes, we should consider
+ // removing this. removing this should be ok since we handle most
+ // big stuff returned from the server (qrydta's for example) by
+ // copying out the data into some other storage. any extended dss header
+ // info will be removed in the copying process.
+ private final void compressBLayerData (int continueDssHeaderCount) throws
org.apache.derby.client.am.DisconnectException
+ {
+ int tempPos = 0;
+
+ // jump to the last continuation header.
+ for (int i = 0; i < continueDssHeaderCount; i++) {
+ // the first may be less than the size of a full dss
+ if (i == 0) {
+ // only jump by the number of bytes remaining in the current dss
+ tempPos = pos_ + dssLength_;
+ }
+ else {
+ // all other jumps are for a full continued dss
+ tempPos += 32767;
+ }
+ }
+
+ // for each of the dss headers to remove,
+ // read out the continuation header and increment the dss length by the
+ // size of the conitnation bytes, then shift the continuation data as
needed.
+ int shiftSize = 0;
+ int bytesToShift = 0;
+ int continueHeaderLength = 0;
+ int newDssLength = 0;
+ for (int i = 0; i < continueDssHeaderCount; i++) {
+
+ continueHeaderLength = ((buffer_[tempPos]&0xFF) << 8) +
+ ((buffer_[tempPos + 1]&0xFF) << 0);
+
+ if (i == 0) {
+ // if this is the last one (farthest down stream and first to strip
out)
+
+ if ((continueHeaderLength & 0x8000) == 0x8000) {
+ // the last dss header is again continued
+ continueHeaderLength = 32767;
+ dssIsContinued_ = true;
+ }
+ else {
+ // the last dss header was not contiued so update continue state flag
+ dssIsContinued_ = false;
+ }
+ // the very first shift size is 2
+ shiftSize = 2;
+ }
+ else {
+ // already removed the last header so make sure the chaining flag is on
+ if ((continueHeaderLength & 0x8000) == 0x8000) {
+ continueHeaderLength = 32767;
+ }
+ else {
+ // this is a syntax error but not really certain which one.
+ // for now pick 0x02 which is Dss header Length does not match the
number
+ // of bytes of data found.
+ doSyntaxrmSemantics
(CodePoint.SYNERRCD_DSS_LENGTH_BYTE_NUMBER_MISMATCH);
+ }
+ // increase the shift size by 2
+ shiftSize += 2;
+ }
+
+ // it is a syntax error if the dss continuation is less than or equal to
two
+ if (continueHeaderLength <= 2) {
+ doSyntaxrmSemantics (CodePoint.SYNERRCD_DSS_CONT_LESS_OR_EQUAL_2);
+ }
+
+ newDssLength += (continueHeaderLength - 2);
+
+ // calculate the number of bytes to shift
+ if (i != (continueDssHeaderCount - 1))
+ bytesToShift = 32767;
+ else
+ bytesToShift = dssLength_;
+
+ tempPos -= (shiftSize - 1);
+ // perform the compress
+ for (int j = 0; j < bytesToShift; j++) {
+ buffer_[tempPos + shiftSize] = buffer_[tempPos];
+ tempPos--;
+ }
+ tempPos += (shiftSize + 1);
+ }
+ // reposition the start of the data after the final dss shift.
+ pos_ = tempPos;
+ dssLength_ = dssLength_ + newDssLength;
+ }
+
+ protected final void readDssHeader () throws
org.apache.derby.client.am.DisconnectException
+ {
+ int correlationID = 0;
+ int nextCorrelationID = 0;
+ ensureALayerDataInBuffer (6);
+
+ // read out the dss length
+ dssLength_ =
+ ((buffer_[pos_++]&0xFF) << 8) +
+ ((buffer_[pos_++]&0xFF) << 0);
+
+ // Remember the old dss length for decryption only.
+ int oldDssLength = dssLength_;
+
+ // check for the continuation bit and update length as needed.
+ if ((dssLength_ & 0x8000) == 0x8000) {
+ dssLength_ = 32767;
+ dssIsContinued_ = true;
+ }
+ else {
+ dssIsContinued_ = false;
+ }
+
+ if (dssLength_ < 6)
+ doSyntaxrmSemantics (CodePoint.SYNERRCD_DSS_LESS_THAN_6);
+
+ // If the GDS id is not valid, or
+ // if the reply is not an RPYDSS nor
+ // a OBJDSS, then throw an exception.
+ if ((buffer_[pos_++]&0xFF) != 0xd0)
+ doSyntaxrmSemantics (CodePoint.SYNERRCD_CBYTE_NOT_D0);
+
+ int gdsFormatter = buffer_[pos_++]&0xFF;
+ if (((gdsFormatter & 0x02) != 0x02)
+ &&((gdsFormatter & 0x03) != 0x03)
+ &&((gdsFormatter & 0x04) != 0x04)) {
+ doSyntaxrmSemantics (CodePoint.SYNERRCD_FBYTE_NOT_SUPPORTED);
+ }
+
+ // Determine if the current DSS is chained with the
+ // next DSS, with the same or different request ID.
+ if ((gdsFormatter & 0x40) == 0x40) { // on indicates structure chained
to next structure
+ if ((gdsFormatter & 0x10) == 0x10) {
+ dssIsChainedWithSameID_ = true;
+ dssIsChainedWithDiffID_ = false;
+ nextCorrelationID = dssCorrelationID_;
+ }
+ else {
+ dssIsChainedWithSameID_ = false;
+ dssIsChainedWithDiffID_ = true;
+ nextCorrelationID = dssCorrelationID_ + 1;
+ }
+ }
+ else {
+ // chaining bit not b'1', make sure DSSFMT bit3 not b'1'
+ if ((gdsFormatter & 0x10) == 0x10) { // Next DSS can not have same
correlator
+ doSyntaxrmSemantics(CodePoint.SYNERRCD_CHAIN_OFF_SAME_NEXT_CORRELATOR);
+ }
+
+ // chaining bit not b'1', make sure no error continuation
+ if ((gdsFormatter & 0x20) == 0x20) { // must be 'do not continue on
error'
+ doSyntaxrmSemantics(CodePoint.SYNERRCD_CHAIN_OFF_ERROR_CONTINUE);
+ }
+
+ dssIsChainedWithSameID_ = false;
+ dssIsChainedWithDiffID_ = false;
+ nextCorrelationID = 1;
+ }
+
+ correlationID =
+ ((buffer_[pos_++]&0xFF) << 8) +
+ ((buffer_[pos_++]&0xFF) << 0);
+
+ // corrid must be the one expected or a -1 which gets returned in some
error cases.
+ if ((correlationID != dssCorrelationID_) && (correlationID != 0xFFFF)){
+ doSyntaxrmSemantics (CodePoint.SYNERRCD_INVALID_CORRELATOR);
+ }
+ else {
+ dssCorrelationID_ = nextCorrelationID;
+ }
+ dssLength_ -= 6;
+ if ((gdsFormatter & 0x04) == 0x04 )
+ decryptData (gdsFormatter, oldDssLength); //we have to decrypt data
here because
+ //we need the decrypted
codepoint. If
+ //Data is very long > 32767,
we have to
+ //get all the data first
because decrypt
+ //piece by piece doesn't
work.
+ }
+
+
+
+ private final void decryptData(int gdsFormatter, int oldDssLength) throws
org.apache.derby.client.am.DisconnectException
+ {
+ boolean readHeader;
+
+ if(dssLength_ == 32761) {
+ ByteArrayOutputStream baos;
+ int copySize = 0;
+
+ baos = new ByteArrayOutputStream ();
+
+ // set the amount to read for the first segment
+ copySize = dssLength_; // note: has already been adjusted for headers
+
+ do {
+ // determine if a continuation header needs to be read after the
data
+ if (dssIsContinued_)
+ readHeader = true;
+ else
+ readHeader = false;
+
+ // read the segment
+ ensureALayerDataInBuffer (copySize);
+ adjustLengths (copySize);
+ baos.write (buffer_, pos_, copySize);
+ pos_ += copySize;
+
+ // read the continuation header, if necessary
+ if (readHeader)
+ readDSSContinuationHeader ();
+
+ copySize = dssLength_;
+ }
+ while (readHeader == true);
+ byte[] cipherBytes = baos.toByteArray();
+ byte[] clearedByte = null;
+ try{
+ clearedByte =
netAgent_.netConnection_.getEncryptionManager().decryptData(
+ cipherBytes,
+ NetConfiguration.SECMEC_EUSRIDPWD,
+ netAgent_.netConnection_.getTargetPublicKey(),
+ netAgent_.netConnection_.getTargetPublicKey());
+ }
+ catch (SqlException e)
+ {
+ //throw new SqlException (agent_.logWriter_, "error in decrypting
data");
+ }
+
+ //The decrypted data is for one codepoint only. We need to save the
data follows this codepoint
+ longBufferForDecryption_ = new byte[buffer_.length - pos_];
+ longPosForDecryption_ = 0;
+ count_ = count_ - pos_;
+ longCountForDecryption_ = count_;
+
System.arraycopy(buffer_,pos_,longBufferForDecryption_,0,buffer_.length - pos_);
+
+ //copy the clear data to buffer_
+ if (clearedByte.length >=32767)
+ System.arraycopy(clearedByte,0,buffer_,0,32767);
+ else
+ System.arraycopy(clearedByte,0,buffer_,0,clearedByte.length);
+
+ pos_ = 0;
+ dssLength_ = buffer_.length;
+
+ int lobLength = 0;
+ if(clearedByte.length > 32767) { //for extended length, length is
the 4 bytes that follow codepoint
+ lobLength = ( (clearedByte[4] & 0xFF) << 24) +
+ ( (clearedByte[5] & 0xFF) << 16) +
+ ( (clearedByte[6] & 0xFF) << 8) +
+ ( (clearedByte[7] & 0xFF) << 0);
+ longValueForDecryption_ = new byte[lobLength];
+ System.arraycopy (clearedByte, 8, longValueForDecryption_, 0,
clearedByte.length-8);
+ }
+ else {
+ lobLength = ( (clearedByte[0] & 0xFF) << 8) +
+ ( (clearedByte[1] & 0xFF) << 0);
+ longValueForDecryption_ = new byte[lobLength-4];
+ System.arraycopy (clearedByte, 4, longValueForDecryption_, 0,
clearedByte.length-4);
+ }
+ }
+
+ else{
+ int bytesRead = ensureALayerDataInBuffer (dssLength_); //we need to
get back all the data here, and then decrypt
+ if (bytesRead > 0) //we ensuredALayerDAtaInBuffer here and set the
flag to true, so we don't need do this again later
+ ensuredLengthForDecryption_ = true;
+ byte[] encryptedByte = new byte[dssLength_];
+ System.arraycopy(buffer_,pos_,encryptedByte,0,dssLength_);
+ byte[] array1 = new byte[pos_];
+ System.arraycopy(buffer_,0,array1,0,pos_); //save the data before
encrypted data in array1
+ byte[] array3 = new byte[buffer_.length - dssLength_ - pos_];
+ System.arraycopy(buffer_,pos_+dssLength_,array3,0,buffer_.length -
dssLength_ - pos_); //save the data follows encrypted data in array3
+ byte[] clearedByte = null;
+ try{
+ clearedByte =
netAgent_.netConnection_.getEncryptionManager().decryptData(
+ encryptedByte,
+ NetConfiguration.SECMEC_EUSRIDPWD,
+ netAgent_.netConnection_.getTargetPublicKey(),
+ netAgent_.netConnection_.getTargetPublicKey());
+ }
+ catch (SqlException e)
+ {
+ //throw new SqlException (agent_.logWriter_, "error in decrypting
data");
+ }
+ dssLength_ -= (encryptedByte.length - clearedByte.length);
+ byte[] buffer = new byte[array1.length + clearedByte.length +
array3.length];
+ System.arraycopy(array1,0,buffer,0,array1.length);
+
System.arraycopy(clearedByte,0,buffer,array1.length,clearedByte.length);
+
System.arraycopy(array3,0,buffer,array1.length+clearedByte.length,array3.length);
+ buffer_ = buffer;
+ int oldCount = count_;
+ count_ = count_ - (encryptedByte.length - clearedByte.length);
+ if (((clearedByte[2]& 0xff) << 8) + ((clearedByte[3] & 0xff) << 0) ==
0x146c) {
+ int firstLobLength = ( (clearedByte[0] & 0xFF) << 8) +
+ ( (clearedByte[1] & 0xFF) << 0);
+
+ boolean flag = false;
+ if (gdsFormatter == 0x54)
+ flag = true;
+ if(flag){
+ if (oldCount - oldDssLength < 6) {
+ int totalBytesRead = fill(6); //sometimes the 2nd EXTDTA
doesn't come back, need to fetch again to get it
+ if (totalBytesRead > 0) {
+ longBufferForDecryption_ = new byte[totalBytesRead];
+ longPosForDecryption_ = 0;
+ System.arraycopy(buffer_, pos_ + firstLobLength,
longBufferForDecryption_, 0,
+ totalBytesRead);
+ }
+
+ }
+ else {
+ longBufferForDecryption_ = new byte[count_ - pos_ -
firstLobLength];
+ longPosForDecryption_ = 0;
+ System.arraycopy(buffer_, pos_ + firstLobLength,
longBufferForDecryption_, 0,
+ longBufferForDecryption_.length);
+
+ }
+ } //end if(flag)
+ int lobLength = ( (clearedByte[0] & 0xFF) << 8) +
+ ( (clearedByte[1] & 0xFF) << 0) - 4;
+
+ longValueForDecryption_ = new byte[lobLength];
+
+ System.arraycopy (clearedByte, 4, longValueForDecryption_, 0,
clearedByte.length - 4); //copy the decrypted lob value (excluded length an
dcodepoint) to longValue_
+ }
+ else if (((clearedByte[2]& 0xff) << 8) + ((clearedByte[3] & 0xff) <<
0) == 0x241B){
+ int length = ( (clearedByte[0] & 0xFF) << 8) +
+ ( (clearedByte[1] & 0xFF) << 0);
+ boolean noData = false;
+ if (clearedByte[4] == -1 && clearedByte[5] == -1)
+ noData = true; //there is no data, no need to do the copy
+ if (!noData) {
+ if (length == 32776) {
+ length = ( (clearedByte[4] & 0xFF) << 24) +
+ ( (clearedByte[5] & 0xFF) << 16) +
+ ( (clearedByte[6] & 0xFF) << 8) +
+ ( (clearedByte[7] & 0xFF) << 0);
+ longValueForDecryption_ = new byte[length];
+ System.arraycopy (clearedByte, 8, longValueForDecryption_, 0,
+ clearedByte.length - 8);
+ longCountForDecryption_ = count_ - (pos_ + length + 8);
+ longBufferForDecryption_ = new byte[buffer_.length - pos_ -
length - 8];
+ System.arraycopy(buffer_, pos_ + length + 8,
longBufferForDecryption_, 0,
+ longBufferForDecryption_.length);
+
+ }
+ else {
+ longPosForDecryption_ = 0;
+ longCountForDecryption_ = count_ - (pos_ + length);
+ longBufferForDecryption_ = new byte[buffer_.length - pos_ -
length];
+ System.arraycopy (buffer_, pos_ + length,
longBufferForDecryption_, 0,
+ longBufferForDecryption_.length);
+
+ longValueForDecryption_ = new byte[length - 4];
+
+ System.arraycopy (clearedByte, 4, longValueForDecryption_, 0,
+ clearedByte.length - 4);
+ }
+ }
+ }
+ }
+ }
+
+
+ final int readUnsignedShort () throws
org.apache.derby.client.am.DisconnectException
+ {
+ // should we be checking dss lengths and ddmScalarLengths here
+ // if yes, i am not sure this is the correct place if we should be
checking
+ ensureBLayerDataInBuffer (2);
+ adjustLengths (2);
+ return ((buffer_[pos_++] & 0xff) << 8) +
+ ((buffer_[pos_++] & 0xff) << 0);
+ }
+
+ final short readShort () throws
org.apache.derby.client.am.DisconnectException
+ {
+ // should we be checking dss lengths and ddmScalarLengths here
+ ensureBLayerDataInBuffer (2);
+ adjustLengths (2);
+ short s = SignedBinary.getShort (buffer_, pos_);
+
+ pos_ += 2;
+
+ return s;
+ }
+
+ final int readInt () throws org.apache.derby.client.am.DisconnectException
+ {
+ // should we be checking dss lengths and ddmScalarLengths here
+ ensureBLayerDataInBuffer (4);
+ adjustLengths (4);
+ int i = SignedBinary.getInt (buffer_, pos_);
+ pos_ += 4;
+
+ return i;
+ }
+
+ final void readIntArray (int[] array) throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (array.length * 4);
+ adjustLengths (array.length * 4);
+
+ for (int i = 0; i < array.length; i++) {
+ array[i] = SignedBinary.getInt (buffer_, pos_);
+ pos_ += 4;
+ }
+ }
+
+
+ final long readLong () throws org.apache.derby.client.am.DisconnectException
+ {
+ // should we be checking dss lengths and ddmScalarLengths here
+ ensureBLayerDataInBuffer (8);
+ adjustLengths (8);
+ long l = SignedBinary.getLong (buffer_, pos_);
+
+ pos_ += 8;
+
+ return l;
+ }
+
+
+ final int [] readUnsignedShortList() throws
org.apache.derby.client.am.DisconnectException
+ {
+ int len = ddmScalarLen_;
+ ensureBLayerDataInBuffer (len);
+ adjustLengths (len);
+
+ int count = len/2;
+ int[] list = new int[count];
+
+ for (int i=0; i < count; i++) {
+ list[i] = ((buffer_[pos_++] & 0xff) << 8) +
+ ((buffer_[pos_++] & 0xff) << 0);
+ }
+
+ return list;
+ }
+
+ final int readUnsignedByte () throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (1);
+ adjustLengths (1);
+ return (buffer_[pos_++] & 0xff);
+ }
+
+ final byte readByte () throws org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (1);
+ adjustLengths (1);
+ return (byte) (buffer_[pos_++] & 0xff);
+ }
+
+ final boolean readBoolean () throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (1);
+ adjustLengths (1);
+ return buffer_[pos_++] != 0;
+ }
+
+ final String readString (int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (length);
+ adjustLengths (length);
+
+ String result = ccsidManager_.convertToUCS2 (buffer_, pos_, length);
+ pos_ += length;
+ return result;
+ }
+
+ final String readString (int length, String encoding) throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (length);
+ adjustLengths (length);
+ String s = null;
+
+ try {
+ s = new String (buffer_, pos_, length, encoding);
+ }
+ catch (java.io.UnsupportedEncodingException e) {
+ agent_.accumulateChainBreakingReadExceptionAndThrow (
+ new org.apache.derby.client.am.DisconnectException (
+ e,
+ agent_,
+ "encoding not supported!!"));
+ }
+
+ pos_ += length;
+ return s;
+ }
+
+ final String readString () throws
org.apache.derby.client.am.DisconnectException
+ {
+ int len = ddmScalarLen_;
+ ensureBLayerDataInBuffer (len);
+ adjustLengths (len);
+ String result = ccsidManager_.convertToUCS2 (buffer_, pos_, len);
+ pos_ += len;
+ return result;
+ }
+
+ final byte[] readBytes (int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (length);
+ adjustLengths (length);
+
+ byte[] b = new byte[length];
+ System.arraycopy (buffer_, pos_, b, 0, length);
+ pos_ += length;
+ return b;
+ }
+
+ final byte[] readBytes () throws
org.apache.derby.client.am.DisconnectException
+ {
+ int len = ddmScalarLen_;
+ ensureBLayerDataInBuffer (len);
+ adjustLengths (len);
+
+ byte[] b = new byte[len];
+ System.arraycopy (buffer_, pos_, b, 0, len);
+ pos_ += len;
+ return b;
+ }
+
+ final byte[] readLDBytes () throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (2);
+ int len = ((buffer_[pos_++] & 0xff) << 8) + ((buffer_[pos_++] & 0xff) <<
0);
+
+ if (len == 0) {
+ adjustLengths (2);
+ return null;
+ }
+
+ ensureBLayerDataInBuffer (len);
+ adjustLengths (len + 2);
+
+ byte [] b = new byte[len];
+ System.arraycopy (buffer_, pos_, b, 0, len);
+ pos_ += len;
+ return b;
+ }
+
+ final void skipBytes (int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (length);
+ adjustLengths (length);
+ pos_ += length;
+ }
+
+ final void skipBytes () throws org.apache.derby.client.am.DisconnectException
+ {
+ int len = ddmScalarLen_;
+ ensureBLayerDataInBuffer (len);
+ adjustLengths (len);
+ pos_ += len;
+ }
+
+ // This will be the new and improved getData that handles all QRYDTA/EXTDTA
+ // Returns the stream so that the caller can cache it
+ final ByteArrayOutputStream getData (ByteArrayOutputStream existingBuffer)
throws org.apache.derby.client.am.DisconnectException
+ {
+ boolean readHeader;
+ int copySize;
+ ByteArrayOutputStream baos;
+
+ // note: an empty baos can yield an allocated and empty byte[]
+ if (existingBuffer != null)
+ baos = existingBuffer;
+ else {
+ if (ddmScalarLen_ != -1) {
+ // allocate a stream based on a known amount of data
+ baos = new ByteArrayOutputStream (ddmScalarLen_);
+ }
+ else {
+ // allocate a stream to hold an unknown amount of data
+ baos = new ByteArrayOutputStream ();
+ //isLengthAndNullabilityUnknown = true;
+ }
+ }
+
+ // set the amount to read for the first segment
+ copySize = dssLength_; // note: has already been adjusted for headers
+
+ do {
+ // determine if a continuation header needs to be read after the data
+ if (dssIsContinued_)
+ readHeader = true;
+ else
+ readHeader = false;
+
+ // read the segment
+ ensureALayerDataInBuffer (copySize);
+ adjustLengths (copySize);
+ baos.write (buffer_, pos_, copySize);
+ pos_ += copySize;
+
+ // read the continuation header, if necessary
+ if (readHeader)
+ readDSSContinuationHeader ();
+
+ copySize = dssLength_;
+ }
+ while (readHeader == true);
+
+ return baos;
+ }
+
+ // reads a DSS continuation header
+ // prereq: pos_ is positioned on the first byte of the two-byte header
+ // post: dssIsContinued_ is set to true if the continuation bit is on,
false otherwise
+ // dssLength_ is set to DssConstants.MAX_DSS_LEN - 2 (don't count
the header for the next read)
+ // helper method for getEXTDTAData
+ protected final void readDSSContinuationHeader () throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureALayerDataInBuffer(2);
+
+ dssLength_ =
+ ((buffer_[pos_++]&0xFF) << 8) +
+ ((buffer_[pos_++]&0xFF) << 0);
+
+ if ((dssLength_ & 0x8000) == 0x8000) {
+ dssLength_ = DssConstants.MAX_DSS_LEN;
+ dssIsContinued_ = true;
+ }
+ else {
+ dssIsContinued_ = false;
+ }
+ // it is a syntax error if the dss continuation header length
+ // is less than or equal to two
+ if (dssLength_ <= 2) {
+ doSyntaxrmSemantics (CodePoint.SYNERRCD_DSS_CONT_LESS_OR_EQUAL_2);
+ }
+
+ dssLength_ -= 2; // avoid consuming the DSS cont header
+ }
+
+
+ // As part of parsing the reply, the client can detect that the
+ // data sent from the target agent does not structurally
+ // conform to the requirements of the DDM architecture. These are
+ // the same checks performed by the target server on the messages
+ // it receives from the protocolj code. Server side detected errors
+ // result in a SYNTAXRM being returned from the AS. According to the
+ // DDM manual, parsing of the DSS is terminated when the error is
+ // detected. The Syntax Error Code, SYNERRCD, describes the various errors.
+ //
+ // Note: Not all of these may be valid at the client. See descriptions for
+ // which ones make sense for client side errors/checks.
+ // Syntax Error Code Description of Error
+ // ----------------- --------------------
+ // 0x01 Dss header Length is less than 6.
+ // 0x02 Dss header Length does not match the
+ // number of bytes of data found.
+ // 0x03 Dss header C-byte not D0.
+ // 0x04 Dss header f-bytes either not
+ // recognized or not supported.
+ // 0x05 DSS continuation specified but not
found.
+ // For example, DSS continuation is
specified
+ // on the last DSS, and the SNA LU 6.2
communication
+ // facility returned the SEND indicator.
+ // 0x06 DSS chaining specified but no DSS
found.
+ // For example, DSS chaining is specified
+ // on the last DSS, and the SNA LU 6.2
communication
+ // facility returned the SEND indicator.
+ // 0x07 Object length less than four. For
example,
+ // a command parameter's length is
specified
+ // as two, or a command's length is
specified as three.
+ // 0x08 Object length does not match the
number of bytes of data
+ // found. For example, a RQSDSS with a
length of 150
+ // contains a command whose length is 125
or a SRVDGN parameter
+ // specifies a length of 200 but there
are only 50
+ // bytes left in the DSS.
+ // 0x09 Object length greater than maximum
allowed.
+ // For example, a RECCNT parameter
specifies a
+ // length of ten, but the parameter is
defined
+ // to have a maximum length of eight.
+ // 0x0A Object length less than the minimum
required.
+ // For example, a SVRCOD parameter
specifies a
+ // length of five, but the parameter is
defined
+ // to have a fixed length of six.
+ // 0x0B Object length not allowed. For
example,
+ // a FILEXDPT parameter is specified with
a length of
+ // 11, but this would indicate that only
half of the hours
+ // field is present instead of the
complete hours field.
+ // 0x0C Incorrect large object extended length
field (see
+ // description of DSS). For example, an
extended
+ // length field is present, but it is
only three bytes
+ // long when it is defined to be a
multiple of two bytes.
+ // 0x0D Object code point index not supported.
+ // For example, a code point of 8032 is
encountered
+ // but x'8' is a reserved code point
index.
+ // 0x0E Required object not found. For
example, a CLEAR
+ // command does not have a filnam
parameter present,
+ // or a MODREC command is not followed by
a RECORD
+ // command data object.
+ // 0x0F Too many command data objects sent.
For example,
+ // a MODREC command is followed by two
RECORD command
+ // command data objects, or a DECREC
command is followed
+ // by RECORD object.
+ // 0x10 Mutually exclusive objects present.
+ // For example, a CRTDIRF command
specifies both
+ // a DCLNAM and FILNAM parameters.
+ // 0x11 Too few command data objects sent.
+ // For example, an INSRECEF command that
+ // specified RECCNT95) is followed by only
+ // 4 RECORD command data objects.
+ // 0x12 Duplicate object present.
+ // For example, a LSTFAT command has tow
FILNAM
+ // parameters specified.
+ // 0x13 Invalid request correlator specified.
+ // Use PRCCNVRM with PRCCNVDC of 04 or 05
instead
+ // of this error code. This error code
is being retained
+ // for compatibility with Level 1 of the
architecture.
+ // 0x14 Required value not found.
+ // 0x15 Reserved value not allowed. For
example,
+ // a INSRECEF command specified a
RECCNT(0) parameter.
+ // 0x16 DSS continuation less than or equal to
two.
+ // For example, the length bytes of the
DSS continuation
+ // have the value of one.
+ // 0x17 Objects not in required order. For
example, a RECAL
+ // object contains a RECORD object
followed by a RECNBR
+ // object with is not in the defined
order.
+ // 0x18 DSS chaining byt not b'1', but DSSFMT
bit3 set to b'1'.
+ // 0x19 Previous DSS indicated current DSS has
the same
+ // request correlator, but the request
correlators are
+ // not the same.
+ // 0x1A DSS cahining bit not b'1', but error
continuation requested.
+ // 0x1B Mutually exclusive parameter values
not specified.
+ // For example, an OPEN command specified
PRPSHD(TRUE)
+ // and FILSHR(READER).
+ // 0x1D Code point not valid command. For
example, the first
+ // code point in RQSDSS either is not in
the dictionary
+ // or is not a code point for a command.
+ //
+ // When the client detects these errors, it will be handled as if a SYNTAXRM
is returned
+ // from the server. In this SYNTAXRM case, PROTOCOL architects an SQLSTATE
of 58008 or 58009.
+ //
+ // Messages
+ // SQLSTATE : 58009
+ // Execution failed due to a distribution protocol error that caused
deallocation of the conversation.
+ // SQLCODE : -30020
+ // Execution failed because of a Distributed Protocol
+ // Error that will affect the successful execution of subsequent
+ // commands and SQL statements: Reason Code <reason-code>.
+ // Some possible reason codes include:
+ // 121C Indicates that the user is not authorized to perform the
requested command.
+ // 1232 The command could not be completed because of a permanent error.
+ // In most cases, the server will be in the process of an abend.
+ // 220A The target server has received an invalid data description.
+ // If a user SQLDA is specified, ensure that the fields are
+ // initialized correctly. Also, ensure that the length does not
+ // exceed the maximum allowed length for the data type being used.
+ //
+ // The command or statement cannot be processed. The current
+ // transaction is rolled back and the application is disconnected
+ // from the remote database.
+ final void doSyntaxrmSemantics (int syntaxErrorCode) throws
org.apache.derby.client.am.DisconnectException
+ {
+ agent_.accumulateChainBreakingReadExceptionAndThrow (
+ new org.apache.derby.client.am.DisconnectException (
+ agent_,
+ "Execution failed due to a distribution protocol error " +
+ "that caused deallocation of the conversation. " +
+ "A PROTOCOL Data Stream Syntax Error was detected. Reason: " +
+ "0x" + Integer.toHexString (syntaxErrorCode),
+ SqlState._58009));
+ }
+
+
+// the names of these methods start with a letter z.
+// the z will be removed when they are finalized...
+
+ protected final void pushLengthOnCollectionStack()
+ {
+ ddmCollectionLenStack_[++topDdmCollectionStack_] = ddmScalarLen_;
+ ddmScalarLen_ = 0;
+ }
+
+ protected final void adjustLengths(int length)
+ {
+ ddmScalarLen_ -= length;
+ adjustCollectionAndDssLengths (length);
+ /*
+ for (int i = 0; i <= topDdmCollectionStack_; i++) {
+ ddmCollectionLenStack_[i] -= length;
+ }
+ dssLength_ -= length;
+ */
+ }
+
+ protected int adjustDdmLength (int ddmLength, int length)
+ {
+ ddmLength -= length;
+ if (ddmLength == 0)
+ adjustLengths (getDdmLength());
+ return ddmLength;
+ }
+
+ // Pop the collection Length stack.
+ // pre: The collection length stack must not be empty and the top value
+ // on the stack must be 0.
+ // post: The top 0 value on the stack will be popped.
+ protected final void popCollectionStack()
+ {
+ topDdmCollectionStack_--;
+ }
+
+ protected final int peekCodePoint() throws
org.apache.derby.client.am.DisconnectException
+ {
+ if (topDdmCollectionStack_ != EMPTY_STACK) {
+ if (ddmCollectionLenStack_[topDdmCollectionStack_] == 0)
+ return END_OF_COLLECTION;
+ else if (ddmCollectionLenStack_[topDdmCollectionStack_] < 4) {
+ // error
+ }
+ }
+
+ // if there is no more data in the current dss, and the dss is not
+ // continued, indicate the end of the same Id chain or read the next dss
header.
+ if ((dssLength_ == 0) && (!dssIsContinued_)) {
+ if (!dssIsChainedWithSameID_) {
+ return END_OF_SAME_ID_CHAIN;
+ }
+ readDssHeader();
+ }
+
+ if (longBufferForDecryption_ == null) //we don't need to do this if it's
data stream encryption
+ ensureBLayerDataInBuffer (4);
+ peekedLength_ = ((buffer_[pos_] & 0xff) << 8) + ((buffer_[pos_+1] & 0xff)
<< 0);
+ peekedCodePoint_ = ((buffer_[pos_+2] & 0xff) << 8) + ((buffer_[pos_+3] &
0xff) << 0);
+
+ // check for extended length
+ if ((peekedLength_ & 0x8000) == 0x8000)
+ peekExtendedLength();
+ else
+ peekedNumOfExtendedLenBytes_ = 0;
+ return peekedCodePoint_;
+ }
+
+ // Read out the 2-byte length without moving the pos_ pointer.
+ protected final int peekLength() throws
org.apache.derby.client.am.DisconnectException
+ {
+ ensureBLayerDataInBuffer (2);
+ return (((buffer_[pos_] & 0xff) << 8) +
+ ((buffer_[pos_ + 1] & 0xff) << 0));
+ }
+
+ // Read "length" number of bytes from the buffer into the byte array b
starting from offset
+ // "offset". The current offset in the buffer does not change.
+ protected final int peekFastBytes (byte[] b, int offset, int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ for (int i = 0; i < length; i++) {
+ b[offset+i] = buffer_[pos_+i];
+ }
+ return offset+length;
+ }
+
+ protected final void parseLengthAndMatchCodePoint (int expectedCodePoint)
throws org.apache.derby.client.am.DisconnectException
+ {
+ int actualCodePoint = 0;
+ if (peekedCodePoint_ == END_OF_COLLECTION)
+ actualCodePoint = readLengthAndCodePoint();
+ else {
+ actualCodePoint = peekedCodePoint_;
+ pos_ += (4 + peekedNumOfExtendedLenBytes_);
+ ddmScalarLen_ = peekedLength_;
+ if (peekedNumOfExtendedLenBytes_ == 0 && ddmScalarLen_ != -1) {
+ adjustLengths (4);
+ }
+ else {
+ adjustCollectionAndDssLengths (4+peekedNumOfExtendedLenBytes_);
+ }
+ peekedLength_ = 0;
+ peekedCodePoint_ = END_OF_COLLECTION;
+ peekedNumOfExtendedLenBytes_ = 0;
+ }
+
+ if (actualCodePoint != expectedCodePoint) {
+ zThrowSyntaxError ("actual code point, " + actualCodePoint +
+ " does not match expected code point, " +
expectedCodePoint);
+ }
+ }
+ protected final int readLengthAndCodePoint () throws
org.apache.derby.client.am.DisconnectException
+ {
+ if (topDdmCollectionStack_ != EMPTY_STACK) {
+ if (ddmCollectionLenStack_[topDdmCollectionStack_] == 0)
+ return END_OF_COLLECTION;
+ else if (ddmCollectionLenStack_[topDdmCollectionStack_] < 4) {
+ zThrowSyntaxError ("ddm collection contains less than 4 bytes of
data");
+ }
+ }
+
+ // if there is no more data in the current dss, and the dss is not
+ // continued, indicate the end of the same Id chain or read the next dss
header.
+ if ((dssLength_ == 0) && (!dssIsContinued_)) {
+ if (!dssIsChainedWithSameID_) {
+ return END_OF_SAME_ID_CHAIN;
+ }
+ readDssHeader();
+ }
+
+ ensureBLayerDataInBuffer (4);
+ ddmScalarLen_ =
+ ((buffer_[pos_++] & 0xff) << 8) +
+ ((buffer_[pos_++] & 0xff) << 0);
+ int codePoint = ((buffer_[pos_++] & 0xff) << 8) +
+ ((buffer_[pos_++] & 0xff) << 0);
+ adjustLengths (4);
+
+ // check for extended length
+ if ((ddmScalarLen_ & 0x8000) == 0x8000) {
+ readExtendedLength();
+ }
+ return codePoint;
+ }
+
+ private final void readExtendedLength() throws
org.apache.derby.client.am.DisconnectException
+ {
+ int numberOfExtendedLenBytes = (ddmScalarLen_ - 0x8000); // fix scroll
problem was - 4
+ int adjustSize = 0;
+ switch (numberOfExtendedLenBytes) {
+ case 4:
+ ensureBLayerDataInBuffer (4);
+ ddmScalarLen_ =
+ ((buffer_[pos_++] & 0xff) << 32) +
+ ((buffer_[pos_++] & 0xff) << 16) +
+ ((buffer_[pos_++] & 0xff) << 8) +
+ ((buffer_[pos_++] & 0xff) << 0);
+ adjustSize = 4;
+ break;
+ case 0:
+ ddmScalarLen_ = -1;
+ adjustSize = 0;
+ break;
+ default:
+ doSyntaxrmSemantics(CodePoint.SYNERRCD_INCORRECT_EXTENDED_LEN);
+ }
+
+ adjustCollectionAndDssLengths (adjustSize);
+ /*
+ // adjust the lengths here. this is a special case since the
+ // extended length bytes do not include their own length.
+ for (int i = 0; i <= topDdmCollectionStack_; i++) {
+ ddmCollectionLenStack_[i] -= adjustSize;
+ }
+ dssLength_ -= adjustSize;
+ */
+ }
+
+ private final void adjustCollectionAndDssLengths (int length)
+ {
+ // adjust the lengths here. this is a special case since the
+ // extended length bytes do not include their own length.
+ for (int i = 0; i <= topDdmCollectionStack_; i++) {
+ ddmCollectionLenStack_[i] -= length;
+ }
+ dssLength_ -= length;
+ }
+
+ protected final void startSameIdChainParse() throws
org.apache.derby.client.am.DisconnectException
+ {
+ readDssHeader ();
+ netAgent_.clearSvrcod();
+ }
+
+ protected final void endOfSameIdChainData() throws
org.apache.derby.client.am.DisconnectException
+ {
+ netAgent_.targetTypdef_ = netAgent_.originalTargetTypdef_;
+ netAgent_.targetSqlam_ = netAgent_.orignalTargetSqlam_;
+
+ if (this.topDdmCollectionStack_ != Reply.EMPTY_STACK) {
+ zThrowSyntaxError ("collection stack not empty at end of same id chain
parse");
+ }
+ if (this.dssLength_ != 0) {
+ zThrowSyntaxError ("dss length not 0 at end of same id chain parse");
+ }
+ if (dssIsChainedWithSameID_ == true) {
+ zThrowSyntaxError ("dss chained with same id at end of same id chain
parse");
+ }
+ }
+
+ private final void zThrowSyntaxError (String error) throws
org.apache.derby.client.am.DisconnectException
+ {
+ agent_.accumulateChainBreakingReadExceptionAndThrow (
+ new org.apache.derby.client.am.DisconnectException (agent_, error));
+ }
+
+ protected final int peekTotalColumnCount (int tripletLength) throws
org.apache.derby.client.am.DisconnectException
+ {
+ int columnCount = 0;
+ int offset = 0;
+ int tripletType = FdocaConstants.CPT_TRIPLET_TYPE;
+ while (tripletType == FdocaConstants.CPT_TRIPLET_TYPE) {
+ columnCount += ((tripletLength-3)/3);
+ // Peek ahead for the next triplet's tripletLength and tripletType.
+ // The number of bytes to skip before the next tripletType is
tripletLength - 3.
+ ensureBLayerDataInBuffer (tripletLength-3);
+ offset += (tripletLength-3);
+ tripletLength = (buffer_[pos_+offset++] & 0xff);
+ tripletType = (buffer_[pos_+offset++] & 0xff);
+ // Skip the 1-byte tripletId.
+ offset++;
+ }
+ return columnCount;
+ }
+
+ private final void peekExtendedLength () throws
org.apache.derby.client.am.DisconnectException
+ {
+ peekedNumOfExtendedLenBytes_ = (peekedLength_ - 0x8004);
+ switch (peekedNumOfExtendedLenBytes_) {
+ case 4:
+ // L L C P Extended Length
+ // -->2-bytes<-- --->4-bytes<---
+ // We are only peeking the length here, the actual pos_ is still before
LLCP. We ensured
+ // 4-bytes in peedCodePoint() for the LLCP, and we need to ensure
4-bytes(of LLCP) + the
+ // extended length bytes here.
+ if (longBufferForDecryption_ == null ) //we ddon't need to do this if
it's data stream encryption
+ ensureBLayerDataInBuffer (4 + 4);
+ // The ddmScalarLen_ we peek here does not include the LLCP and the
extended length bytes
+ // themselves. So we will add those back to the ddmScalarLen_ so it can
be adjusted
+ // correctly in parseLengthAndMatchCodePoint(). (since the
adjustLengths() method will
+ // subtract the length from ddmScalarLen_)
+ peekedLength_ =
+ ((buffer_[pos_+4] & 0xff) << 32) +
+ ((buffer_[pos_+5] & 0xff) << 16) +
+ ((buffer_[pos_+6] & 0xff) << 8) +
+ ((buffer_[pos_+7] & 0xff) << 0);
+ break;
+ case 0:
+ peekedLength_ = -1; // this ddm is streamed, so set -1 -> length unknown
+ break;
+ default:
+ doSyntaxrmSemantics(CodePoint.SYNERRCD_INCORRECT_EXTENDED_LEN);
+ }
+ }
+
+ final int readFastUnsignedByte () throws
org.apache.derby.client.am.DisconnectException
+ {
+ return (buffer_[pos_++] & 0xff);
+ }
+
+ final short readFastShort () throws
org.apache.derby.client.am.DisconnectException
+ {
+ short s = SignedBinary.getShort (buffer_, pos_);
+ pos_ += 2;
+ return s;
+ }
+
+ final int readFastUnsignedShort () throws
org.apache.derby.client.am.DisconnectException
+ {
+ return ((buffer_[pos_++] & 0xff) << 8) +
+ ((buffer_[pos_++] & 0xff) << 0);
+ }
+
+ final int readFastInt () throws
org.apache.derby.client.am.DisconnectException
+ {
+ int i = SignedBinary.getInt (buffer_, pos_);
+ pos_ += 4;
+ return i;
+ }
+
+ final String readFastString (int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ String result = ccsidManager_.convertToUCS2 (buffer_, pos_, length);
+ pos_ += length;
+ return result;
+ }
+
+ final byte[] readFastBytes (int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ byte[] b = new byte[length];
+ System.arraycopy (buffer_, pos_, b, 0, length);
+ pos_ += length;
+ return b;
+ }
+
+ protected final int peekFastLength() throws
org.apache.derby.client.am.DisconnectException
+ {
+ return (((buffer_[pos_] & 0xff) << 8) +
+ ((buffer_[pos_ + 1] & 0xff) << 0));
+ }
+
+ final void skipFastBytes (int length) throws
org.apache.derby.client.am.DisconnectException
+ {
+ pos_ += length;
+ }
+
+ final void readFastIntArray (int[] array) throws
org.apache.derby.client.am.DisconnectException
+ {
+ for (int i = 0; i < array.length; i++) {
+ array[i] = SignedBinary.getInt (buffer_, pos_);
+ pos_ += 4;
+ }
+ }
+
+ final String readFastString (int length, String encoding) throws
org.apache.derby.client.am.DisconnectException
+ {
+ String s = null;
+
+ try {
+ s = new String (buffer_, pos_, length, encoding);
+ }
+ catch (java.io.UnsupportedEncodingException e) {
+ agent_.accumulateChainBreakingReadExceptionAndThrow (
+ new org.apache.derby.client.am.DisconnectException (
+ e,
+ agent_,
+ "encoding not supported!!"));
+ }
+ pos_ += length;
+ return s;
+ }
+
+ final byte[] readFastLDBytes () throws
org.apache.derby.client.am.DisconnectException
+ {
+ int len = ((buffer_[pos_++] & 0xff) << 8) + ((buffer_[pos_++] & 0xff) <<
0);
+ if (len == 0) return null;
+
+ byte [] b = new byte[len];
+ System.arraycopy (buffer_, pos_, b, 0, len);
+ pos_ += len;
+ return b;
+ }
+ final long readFastLong () throws
org.apache.derby.client.am.DisconnectException
+ {
+ long l = SignedBinary.getLong (buffer_, pos_ );
+ pos_ += 8;
+ return l;
+ }
+
+ final byte readFastByte () throws
org.apache.derby.client.am.DisconnectException
+ {
+ return (byte) (buffer_[pos_++] & 0xff);
+}
+
+ final void mark()
+ {
+ currentPos_ = pos_;
+ }
+
+ // remove and return the top offset value from mark stack.
+ final int popMark()
+ {
+ return currentPos_;
+ }
+
+ final int getFastSkipSQLCARDrowLength ()
+ {
+ return pos_ - popMark();
+ }
+
+ // The only difference between this method and the original getData() method
is this method
+ // is not doing an ensureALayerDataInBuffer
+ final ByteArrayOutputStream getFastData (ByteArrayOutputStream
existingBuffer) throws org.apache.derby.client.am.DisconnectException
+ {
+ boolean readHeader;
+ int copySize;
+ ByteArrayOutputStream baos;
+
+ // note: an empty baos can yield an allocated and empty byte[]
+ if (existingBuffer != null)
+ baos = existingBuffer;
+ else {
+ if (ddmScalarLen_ != -1) {
+ // allocate a stream based on a known amount of data
+ baos = new ByteArrayOutputStream (ddmScalarLen_);
+ }
+ else {
+ // allocate a stream to hold an unknown amount of data
+ baos = new ByteArrayOutputStream ();
+ //isLengthAndNullabilityUnknown = true;
+ }
+ }
+
+ // set the amount to read for the first segment
+ copySize = dssLength_; // note: has already been adjusted for headers
+
+ do {
+ // determine if a continuation header needs to be read after the data
+ if (dssIsContinued_)
+ readHeader = true;
+ else
+ readHeader = false;
+
+ // read the segment
+ //ensureALayerDataInBuffer (copySize);
+ adjustLengths (copySize);
+ baos.write (buffer_, pos_, copySize);
+ pos_ += copySize;
+
+ // read the continuation header, if necessary
+ if (readHeader)
+ readDSSContinuationHeader ();
+
+ copySize = dssLength_;
+ }
+ while (readHeader == true);
+
+ return baos;
+ }
+
+ // This method is only used to match the codePoint for those class instance
variables
+ // that are embedded in other reply messages.
+ final protected void matchCodePoint (int expectedCodePoint) throws
org.apache.derby.client.am.DisconnectException
+ {
+ int actualCodePoint = 0;
+ actualCodePoint = peekedCodePoint_;
+ pos_ += 4;
+ if (actualCodePoint != expectedCodePoint) {
+ zThrowSyntaxError ("actual code point, " + actualCodePoint +
+ " does not match expected code point, " +
expectedCodePoint);
+ }
+ }
+
+
+ protected final int peekNumOfColumns () throws
org.apache.derby.client.am.DisconnectException
+ {
+ // skip the 4-byte LLCP and any extended length bytes + 1-byte null
sqlcagrp null indicator
+ int offset = (4 + peekedNumOfExtendedLenBytes_ + 1);
+
+ offset = skipSQLDHROW (offset);
+
+ return SignedBinary.getShort (buffer_, pos_+offset);
+ }
+
+ protected final boolean peekForNullSqlcagrp ()
+ {
+ // skip the 4-byte LLCP and any extended length bytes
+ int offset = (4 + peekedNumOfExtendedLenBytes_);
+ int nullInd = buffer_[pos_+offset] & 0xff;
+ return (nullInd == CodePoint.NULLDATA);
+ }
+
+ private final int skipSQLDHROW (int offset) throws
org.apache.derby.client.am.DisconnectException
+ {
+ int sqldhrowgrpNullInd = buffer_[pos_+offset++] & 0xff;
+ if (sqldhrowgrpNullInd == CodePoint.NULLDATA)
+ return offset;
+
+ offset += 12;
+
+ // skip sqldrdbnam
+ int stringLength = ((buffer_[pos_+offset++] & 0xff) << 8) +
+ ((buffer_[pos_+offset++] & 0xff) << 0);
+ offset += stringLength;
+
+ // skip sqldschema
+ stringLength = ((buffer_[pos_+offset++] & 0xff) << 8) +
+ ((buffer_[pos_+offset++] & 0xff) << 0);
+ offset += stringLength;
+
+ stringLength = ((buffer_[pos_+offset++] & 0xff) << 8) +
+ ((buffer_[pos_+offset++] & 0xff) << 0);
+ offset += stringLength;
+
+ return offset;
+ }
+}
+
+
+
+
Propchange:
incubator/derby/code/trunk/java/client/org/apache/derby/client/net/Reply.java
------------------------------------------------------------------------------
svn:eol-style = native
