NetConnectionReply.java
| Index Score | ||
|---|---|---|
 |
 |
org.apache.derby.client.net |
 |
 |
Apache Derby |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| LINE_COMMENT | Number of line comments |  |
| RETURNS | Number of return points from functions | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| SIZE | Size of the file in bytes | |
| COMMENTS | Comment lines | |
| CYCLOMATIC | Cyclomatic complexity | |
| LINES | Number of lines in the source file | |
| LOGICAL_LINES | Number of statements | |
| ELOC | Effective lines of code | |
| LOC | Lines of code | |
| BLOCKS | Number of blocks | |
| OPERATORS | Number of operators | |
| DECL_COMMENTS | Comments in declarations | |
| PROGRAM_LENGTH | Halstead program length | |
| EXEC_COMMENTS | Comments in executable code | |
| OPERANDS | Number of operands | |
| FUNCTIONS | Number of function declarations | |
| COMPARISONS | Number of comparison operators | |
| LOOPS | Number of loops | |
| EXITS | Procedure exits | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PARAMS | Number of formal parameter declarations | |
| WHITESPACE | Number of whitespace lines | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0171 | JAVA0171 Unused local variable | |
| JAVA0031 | JAVA0031 Case statement not properly closed | |
| JAVA0160 | JAVA0160 Method does not throw specified exception | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| JAVA0076 | JAVA0076 Use of magic number | |
| JAVA0175 | JAVA0175 Successive assignment to variable | |
| JAVA0174 | JAVA0174 Assigned local variable never used | |
| UNIQUE_OPERATORS | Number of unique operators | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0130 | JAVA0130 Non-static method does not use instance fields | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0138 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| DOC_COMMENT | Number of javadoc comment lines | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
/*
Derby - Class org.apache.derby.client.net.NetConnectionReply
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You 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 javax.transaction.xa.Xid;
import org.apache.derby.client.am.Connection;
import org.apache.derby.client.am.ConnectionCallbackInterface;
import org.apache.derby.client.am.StatementCallbackInterface;
import org.apache.derby.client.am.ResultSetCallbackInterface;
import org.apache.derby.client.am.DisconnectException;
import org.apache.derby.client.am.SqlException;
import org.apache.derby.client.am.ClientMessageId;
import org.apache.derby.client.am.Sqlca;
import java.io.UnsupportedEncodingException;
import org.apache.derby.client.am.UnitOfWorkListener;
import org.apache.derby.shared.common.error.ExceptionSeverity;
import org.apache.derby.shared.common.error.ExceptionUtil;
import org.apache.derby.shared.common.reference.SQLState;
import org.apache.derby.shared.common.reference.MessageId;
import org.apache.derby.shared.common.i18n.MessageUtil;
public class NetConnectionReply extends Reply
implements ConnectionReplyInterface {
private static MessageUtil msgutil_ = SqlException.getMessageUtil();
NetConnectionReply(NetAgent netAgent, int bufferSize) {
super(netAgent, bufferSize);
}
// NET only entry point
void readExchangeServerAttributes(Connection connection) throws SqlException {
startSameIdChainParse();
parseEXCSATreply((NetConnection) connection);
endOfSameIdChainData();
agent_.checkForChainBreakingException_();
}
void verifyConnectReply(int codept) throws SqlException {
if (peekCodePoint() != codept) {
parseConnectError();
return;
}
readLengthAndCodePoint();
skipBytes();
if (codept == CodePoint.ACCRDBRM) {
int peekCP = peekCodePoint();
if (peekCP == Reply.END_OF_SAME_ID_CHAIN) {
return;
}
parseTypdefsOrMgrlvlovrs();
NetSqlca netSqlca = parseSQLCARD(null);
netAgent_.netConnection_.completeSqlca(netSqlca);
}
}
void parseConnectError() throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.MGRLVLRM:
parseMGRLVLRM();
break;
default:
parseCommonError(peekCP);
}
}
void readDummyExchangeServerAttributes(Connection connection) throws SqlException {
startSameIdChainParse();
parseDummyEXCSATreply((NetConnection) connection);
endOfSameIdChainData();
agent_.checkForChainBreakingException_();
}
// NET only entry point
void readAccessSecurity(Connection connection,
int securityMechanism) throws SqlException {
startSameIdChainParse();
parseACCSECreply((NetConnection) connection, securityMechanism);
endOfSameIdChainData();
agent_.checkForChainBreakingException_();
}
// NET only entry point
void readSecurityCheck(Connection connection) throws SqlException {
startSameIdChainParse();
parseSECCHKreply((NetConnection) connection);
endOfSameIdChainData();
agent_.checkForChainBreakingException_();
}
// NET only entry point
void readAccessDatabase(Connection connection) throws SqlException {
startSameIdChainParse();
parseACCRDBreply((NetConnection) connection);
endOfSameIdChainData();
agent_.checkForChainBreakingException_();
}
public void readCommitSubstitute(ConnectionCallbackInterface connection) throws DisconnectException {
startSameIdChainParse();
parseDummyEXCSATreply((NetConnection) connection);
endOfSameIdChainData();
}
public void readLocalCommit(ConnectionCallbackInterface connection) throws DisconnectException {
startSameIdChainParse();
parseRDBCMMreply(connection);
endOfSameIdChainData();
}
public void readLocalRollback(ConnectionCallbackInterface connection) throws DisconnectException {
startSameIdChainParse();
parseRDBRLLBCKreply(connection);
endOfSameIdChainData();
}
public void readLocalXAStart(ConnectionCallbackInterface connection) throws DisconnectException {
}
public void readLocalXACommit(ConnectionCallbackInterface connection) throws DisconnectException {
}
public void readLocalXARollback(ConnectionCallbackInterface connection) throws DisconnectException {
}
protected void readXaStartUnitOfWork(NetConnection conn) throws DisconnectException {
}
protected int readXaEndUnitOfWork(NetConnection conn) throws DisconnectException {
return 0;
}
protected int readXaPrepare(NetConnection conn) throws DisconnectException {
return 0;
}
protected void readXaCommit(NetConnection conn) throws DisconnectException {
}
protected int readXaRollback(NetConnection conn) throws DisconnectException {
return 0;
}
protected void readXaRecover(NetConnection conn) throws DisconnectException {
}
protected void readXaForget(NetConnection conn) throws DisconnectException {
}
//------------------parse reply for specific command--------------------------
// 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.
// Parse the reply for the RDB Commit Unit of Work Command.
// This method handles the parsing of all command replies and reply data
// for the rdbcmm command.
private void parseRDBCMMreply(ConnectionCallbackInterface connection) throws DisconnectException {
int peekCP = parseTypdefsOrMgrlvlovrs();
if (peekCP != CodePoint.ENDUOWRM && peekCP != CodePoint.SQLCARD) {
parseCommitError(connection);
return;
}
if (peekCP == CodePoint.ENDUOWRM) {
parseENDUOWRM(connection);
peekCP = parseTypdefsOrMgrlvlovrs();
}
NetSqlca netSqlca = parseSQLCARD(null);
connection.completeSqlca(netSqlca);
}
// Parse the reply for the RDB Rollback Unit of Work Command.
// This method handles the parsing of all command replies and reply data
// for the rdbrllbck command.
private void parseRDBRLLBCKreply(ConnectionCallbackInterface connection) throws DisconnectException {
int peekCP = parseTypdefsOrMgrlvlovrs();
if (peekCP != CodePoint.ENDUOWRM) {
parseRollbackError();
return;
}
parseENDUOWRM(connection);
peekCP = parseTypdefsOrMgrlvlovrs();
NetSqlca netSqlca = parseSQLCARD(null);
connection.completeSqlca(netSqlca);
}
// Parse the reply for the Exchange Server Attributes Command.
// This method handles the parsing of all command replies and reply data
// for the excsat command.
private void parseEXCSATreply(NetConnection netConnection) throws DisconnectException {
if (peekCodePoint() != CodePoint.EXCSATRD) {
parseExchangeServerAttributesError();
return;
}
parseEXCSATRD(netConnection);
}
// Parse the reply for the Exchange Server Attributes Command (Dummy)
// This method handles the parsing of all command replies and reply data
// for the excsat command.
private void parseDummyEXCSATreply(NetConnection netConnection) throws DisconnectException {
if (peekCodePoint() != CodePoint.EXCSATRD) {
parseExchangeServerAttributesError();
return;
}
parseDummyEXCSATRD(netConnection);
}
// Parse the reply for the Access Security Command.
// This method handles the parsing of all command replies and reply data
// for the accsec command.
private void parseACCSECreply(NetConnection netConnection, int securityMechanism) throws DisconnectException {
int peekCP = peekCodePoint();
if (peekCP != CodePoint.ACCSECRD) {
parseAccessSecurityError(netConnection);
return;
}
parseACCSECRD(netConnection, securityMechanism);
peekCP = peekCodePoint();
if (peekCP == Reply.END_OF_SAME_ID_CHAIN) {
return;
}
}
// Parse the reply for the Security Check Command.
// This method handles the parsing of all command replies and reply data
// for the secchk command.
private void parseSECCHKreply(NetConnection netConnection) throws DisconnectException {
if (peekCodePoint() != CodePoint.SECCHKRM) {
parseSecurityCheckError(netConnection);
return;
}
parseSECCHKRM(netConnection);
if (peekCodePoint() == CodePoint.SECTKN) {
// rpydta used only if the security mechanism returns
// a security token that must be sent back to the source system.
// this is only used for DCSSEC. In the case of DCESEC,
// the sectkn must be returned as reply data if DCE is using
// mutual authentication.
// Need to double check what to map this to. This is probably
// incorrect but consider it a conversation protocol error
// 0x03 - OBJDSS sent when not allowed.
//parseSECTKN (true);
boolean done = false;
byte[] bytes = parseSECTKN(false);
}
}
// Parse the reply for the Access RDB Command.
// This method handles the parsing of all command replies and reply data
// for the accrdb command.
private void parseACCRDBreply(NetConnection netConnection) throws DisconnectException {
int peekCP = peekCodePoint();
if (peekCP != CodePoint.ACCRDBRM) {
parseAccessRdbError(netConnection);
return;
}
parseACCRDBRM(netConnection);
peekCP = peekCodePoint();
if (peekCP == Reply.END_OF_SAME_ID_CHAIN) {
return;
}
parseTypdefsOrMgrlvlovrs();
NetSqlca netSqlca = parseSQLCARD(null);
netConnection.completeSqlca(netSqlca);
}
protected int parseTypdefsOrMgrlvlovrs() throws DisconnectException {
boolean targetTypedefCloned = false;
while (true) {
int peekCP = peekCodePoint();
if (peekCP == CodePoint.TYPDEFNAM) {
if (!targetTypedefCloned) {
netAgent_.targetTypdef_ = (Typdef) netAgent_.targetTypdef_.clone();
targetTypedefCloned = true;
}
parseTYPDEFNAM();
} else if (peekCP == CodePoint.TYPDEFOVR) {
if (!targetTypedefCloned) {
netAgent_.targetTypdef_ = (Typdef) netAgent_.targetTypdef_.clone();
targetTypedefCloned = true;
}
parseTYPDEFOVR();
} else {
return peekCP;
}
}
}
//-----------------------------parse DDM Reply Messages-----------------------
protected void parseCommitError(ConnectionCallbackInterface connection) throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.ABNUOWRM:
NetSqlca sqlca = parseAbnormalEndUow(connection,null);
connection.completeSqlca(sqlca);
break;
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.RDBNACRM:
parseRDBNACRM();
break;
default:
parseCommonError(peekCP);
break;
}
}
void parseRollbackError() throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.RDBNACRM:
parseRDBNACRM();
break;
default:
parseCommonError(peekCP);
break;
}
}
void parseExchangeServerAttributesError() throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.MGRLVLRM:
parseMGRLVLRM();
break;
default:
parseCommonError(peekCP);
}
}
void parseAccessSecurityError(NetConnection netConnection) throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.RDBNFNRM:
parseRDBNFNRM(netConnection);
break;
case CodePoint.RDBAFLRM:
parseRdbAccessFailed(netConnection);
break;
default:
parseCommonError(peekCP);
}
}
void parseSecurityCheckError(NetConnection netConnection) throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.OBJNSPRM:
parseOBJNSPRM();
break;
case CodePoint.RDBNFNRM:
parseRDBNFNRM(netConnection);
break;
case CodePoint.RDBAFLRM:
parseRdbAccessFailed(netConnection);
break;
default:
parseCommonError(peekCP);
}
}
void parseAccessRdbError(NetConnection netConnection) throws DisconnectException {
int peekCP = peekCodePoint();
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.RDBACCRM:
parseRDBACCRM();
break;
case CodePoint.RDBAFLRM:
parseRdbAccessFailed(netConnection);
break;
case CodePoint.RDBATHRM:
parseRDBATHRM(netConnection);
break;
case CodePoint.RDBNFNRM:
parseRDBNFNRM(netConnection);
break;
default:
parseCommonError(peekCP);
}
}
// Called by all the NET*Reply classes.
void parseCommonError(int peekCP) throws DisconnectException {
switch (peekCP) {
case CodePoint.CMDNSPRM:
parseCMDNSPRM();
break;
case CodePoint.PRCCNVRM:
parsePRCCNVRM();
break;
case CodePoint.SYNTAXRM:
parseSYNTAXRM();
break;
case CodePoint.VALNSPRM:
parseVALNSPRM();
break;
default:
doObjnsprmSemantics(peekCP);
}
}
/**
* Perform necessary actions for parsing of a ABNUOWRM message.
*
* @param connection an implementation of the ConnectionCallbackInterface
*
* @return an NetSqlca object obtained from parsing the ABNUOWRM
* @throws DisconnectException
*
*/
NetSqlca parseAbnormalEndUow(ConnectionCallbackInterface connection,UnitOfWorkListener uwl) throws DisconnectException {
parseABNUOWRM();
if (peekCodePoint() != CodePoint.SQLCARD) {
parseTypdefsOrMgrlvlovrs();
}
NetSqlca netSqlca = parseSQLCARD(null);
if(ExceptionUtil.getSeverityFromIdentifier(netSqlca.getSqlState()) >
ExceptionSeverity.STATEMENT_SEVERITY || uwl == null)
connection.completeAbnormalUnitOfWork();
else
connection.completeAbnormalUnitOfWork(uwl);
return netSqlca;
}
/**
* Perform necessary actions for parsing of a ABNUOWRM message.
*
* @param s an implementation of the StatementCallbackInterface
*
* @return an NetSqlca object obtained from parsing the ABNUOWRM
* @throws DisconnectException
*
*/
NetSqlca parseAbnormalEndUow(StatementCallbackInterface s) throws DisconnectException {
return parseAbnormalEndUow(s.getConnectionCallbackInterface(),s);
}
/**
* Perform necessary actions for parsing of a ABNUOWRM message.
*
* @param r an implementation of the ResultsetCallbackInterface
*
* @return an NetSqlca object obtained from parsing the ABNUOWRM
* @throws DisconnectException
*
*/
NetSqlca parseAbnormalEndUow(ResultSetCallbackInterface r) throws DisconnectException {
return parseAbnormalEndUow(r.getConnectionCallbackInterface(),r);
}
void parseRdbAccessFailed(NetConnection netConnection) throws DisconnectException {
parseRDBAFLRM();
// an SQLCARD is returned if an RDBALFRM is returned.
// this SQLCARD always follows the RDBALFRM.
// TYPDEFNAM and TYPDEFOVR are MTLINC
if (peekCodePoint() == CodePoint.TYPDEFNAM) {
parseTYPDEFNAM();
parseTYPDEFOVR();
} else {
parseTYPDEFOVR();
parseTYPDEFNAM();
}
NetSqlca netSqlca = parseSQLCARD(null);
//Check if the SQLCARD has null SQLException
if(netSqlca.getSqlErrmc() == null)
netConnection.setConnectionNull(true);
else
netConnection.completeSqlca(netSqlca);
}
// The Security Check (SECCHKRM) Reply Message indicates the acceptability
// of the security information.
// this method returns the security check code. it is up to the caller to check
// the value of this return code and take the appropriate action.
//
// Returned from Server:
// SVRCOD - required (0 - INFO, 8 - ERROR, 16 -SEVERE)
// SECCHKCD - required
// SECTKN - optional, ignorable
// SVCERRNO - optional
private void parseSECCHKRM(NetConnection netConnection) throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean secchkcdReceived = false;
int secchkcd = CodePoint.SECCHKCD_00;
boolean sectknReceived = false;
byte[] sectkn = null;
parseLengthAndMatchCodePoint(CodePoint.SECCHKRM);
pushLengthOnCollectionStack();
int peekCP = peekCodePoint();
while (peekCP != Reply.END_OF_COLLECTION) {
boolean foundInPass = false;
if (peekCP == CodePoint.SVRCOD) {
// severity code. it's value is dictated by the SECCHKCD.
// right now it will not be checked that it is the correct value
// for the SECCHKCD. maybe this will be done in the future.
foundInPass = true;
svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
svrcod = parseSVRCOD(CodePoint.SVRCOD_INFO, CodePoint.SVRCOD_SEVERE);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SECCHKCD) {
// security check code. this specifies the state of the security information.
// there is a relationship between this value and the SVRCOD value.
// right now this driver will not check these values against each other.
foundInPass = true;
secchkcdReceived = checkAndGetReceivedFlag(secchkcdReceived);
secchkcd = parseSECCHKCD();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SECTKN) {
// security token.
// used when mutual authentication of the source and target servers
// is requested. The architecture lists this as an instance variable
// and also says that the SECTKN flows as reply data to the secchk cmd and
// it must flow after the secchkrm message. Right now this driver doesn't
// support ay mutual authentication so it will be ignored (it is listed
// as an ignorable instance variable in the ddm manual).
foundInPass = true;
sectknReceived = checkAndGetReceivedFlag(sectknReceived);
sectkn = parseSECTKN(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
// check for the required instance variables.
checkRequiredObjects(svrcodReceived, secchkcdReceived);
netConnection.securityCheckComplete(svrcod, secchkcd);
}
// Access to RDB Completed (ACRDBRM) Reply Message specifies that an
// instance of the SQL application manager has been created and is bound
// to the specified relation database (RDB).
//
// Returned from Server:
// SVRCOD - required (0 - INFO, 4 - WARNING)
// PRDID - required
// TYPDEFNAM - required (MINLVL 4) (QTDSQLJVM)
// TYPDEFOVR - required
// RDBINTTKN - optional
// CRRTKN - optional
// USRID - optional
// SRVLST - optional (MINLVL 5)
private void parseACCRDBRM(NetConnection netConnection) throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean prdidReceived = false;
String prdid = null;
boolean typdefnamReceived = false;
boolean typdefovrReceived = false;
boolean rdbinttknReceived = false;
boolean crrtknReceived = false;
byte[] crrtkn = null;
boolean usridReceived = false;
String usrid = null;
parseLengthAndMatchCodePoint(CodePoint.ACCRDBRM);
pushLengthOnCollectionStack();
int peekCP = peekCodePoint();
while (peekCP != Reply.END_OF_COLLECTION) {
boolean foundInPass = false;
if (peekCP == CodePoint.SVRCOD) {
// severity code. If the target SQLAM cannot support the typdefovr
// parameter values specified for the double-byte and mixed-byte CCSIDs
// on the corresponding ACCRDB command, then the severity code WARNING
// is specified on the ACCRDBRM.
foundInPass = true;
svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
svrcod = parseSVRCOD(CodePoint.SVRCOD_INFO, CodePoint.SVRCOD_WARNING);
peekCP = peekCodePoint();
}
// this is the product release level of the target RDB server.
if (peekCP == CodePoint.PRDID) {
foundInPass = true;
prdidReceived = checkAndGetReceivedFlag(prdidReceived);
prdid = parsePRDID(false); // false means do not skip the bytes
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.TYPDEFNAM) {
// this is the name of the data type to the data representation mapping
// definitions tha the target SQLAM uses when sending reply data objects.
foundInPass = true;
typdefnamReceived = checkAndGetReceivedFlag(typdefnamReceived);
parseTYPDEFNAM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.TYPDEFOVR) {
// this is the single-byte, double-byte, and mixed-byte CCSIDs of the
// scalar data arrays (SDA) in the identified data type to data representation
// mapping definitions.
foundInPass = true;
typdefovrReceived = checkAndGetReceivedFlag(typdefovrReceived);
parseTYPDEFOVR();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.USRID) {
// specifies the target defined user ID. It is returned if the value of
// TRGDFTRT is TRUE in ACCRDB. Right now this driver always sets this
// value to false so this should never get returned here.
// if it is returned, it could be considered an error but for now
// this driver will just skip the bytes.
foundInPass = true;
usridReceived = checkAndGetReceivedFlag(usridReceived);
usrid = parseUSRID(true);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CRRTKN) {
// carries information to correlate with the work being done on bahalf
// of an application at the source and at the target server.
// defualt value is ''.
// this parameter is only retunred if an only if the CRRTKN parameter
// is not received on ACCRDB. We will rely on server to send us this
// in ACCRDBRM
foundInPass = true;
crrtknReceived = checkAndGetReceivedFlag(crrtknReceived);
crrtkn = parseCRRTKN(false);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
// check for the required instance variables.
checkRequiredObjects(svrcodReceived,
prdidReceived,
typdefnamReceived,
typdefovrReceived);
netConnection.rdbAccessed(svrcod,
prdid,
crrtknReceived,
crrtkn);
}
// The End Unit of Work Condition (ENDUOWRM) Reply Mesage specifies
// that the unit of work has ended as a result of the last command.
//
// Returned from Server:
// SVRCOD - required (4 WARNING)
// UOWDSP - required
// RDBNAM - optional
void parseENDUOWRM(ConnectionCallbackInterface connection) throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean uowdspReceived = false;
int uowdsp = 0;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.ENDUOWRM);
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_WARNING, CodePoint.SVRCOD_WARNING);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.UOWDSP) {
foundInPass = true;
uowdspReceived = checkAndGetReceivedFlag(uowdspReceived);
uowdsp = parseUOWDSP();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, uowdspReceived);
netAgent_.setSvrcod(svrcod);
if (uowdsp == CodePoint.UOWDSP_COMMIT) {
connection.completeLocalCommit();
} else {
connection.completeLocalRollback();
}
}
// Command Check Reply Message indicates that the requested
// command encountered an unarchitected and implementation-specific
// condition for which there is no architected message. If the severity
// code value is ERROR or greater, the command has failed. The
// message can be accompanied by other messages that help to identify
// the specific condition.
// The CMDCHKRM should not be used as a general catch-all in place of
// product-defined messages when using product extensions to DDM.
// PROTOCOL architects the SQLSTATE value depending on SVRCOD
// SVRCOD 0 -> SQLSTATE is not returned
// SVRCOD 8 -> SQLSTATE of 58008 or 58009
// SVRCOD 16,32,64,128 -> SQLSTATE of 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.
//
//
// Returned from Server:
// SVRCOD - required (0 - INFO, 4 - WARNING, 8 - ERROR, 16 - SEVERE,
// 32 - ACCDMG, 64 - PRMDMG, 128 - SESDMG))
// RDBNAM - optional (MINLVL 3)
// RECCNT - optional (MINVAL 0, MINLVL 3)
//
// Called by all the Reply classesCMDCHKRM
protected void parseCMDCHKRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.CMDCHKRM);
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_INFO, CodePoint.SVRCOD_SESDMG);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
// skip over the RECCNT since it can't be found in the DDM book.
if (peekCP == 0x115C) {
foundInPass = true;
parseLengthAndMatchCodePoint(0x115C);
skipBytes();
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived);
netAgent_.setSvrcod(svrcod);
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
msgutil_.getTextMessage(MessageId.CONN_DRDA_CMDCHKRM)));
}
// RDB Not Accessed Reply Message indicates that the access relational
// database command (ACCRDB) was not issued prior to a command
// requesting the RDB Services.
// 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.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// RDBNAM - required
//
// Called by all the NET*Reply classes.
void parseRDBNACRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.RDBNACRM);
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.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, rdbnamReceived);
netAgent_.setSvrcod(svrcod);
agent_.accumulateChainBreakingReadExceptionAndThrow(
new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
msgutil_.getTextMessage(MessageId.CONN_DRDA_RDBNACRM)));
}
// RDB Not Found Reply Message indicates that the target
// server cannot find the specified relational database.
// PROTOCOL architects an SQLSTATE of 08004.
//
// Messages
// SQLSTATE : 8004
// The application server rejected establishment of the connection.
// SQLCODE : -30061
// The database alias or database name <name> was not found at the remote node.
// The statement cannot be processed.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// RDBNAM - required
//
private void parseRDBNFNRM(NetConnection netConnection) throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.RDBNFNRM);
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.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, rdbnamReceived);
netAgent_.setSvrcod(svrcod);
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.NET_DATABASE_NOT_FOUND),
netConnection.databaseName_));
}
// Not Authorized to RDB Reply Message specifies that
// the requester is not authorized to access the specified
// relational database.
// PROTOCOL architects an SQLSTATE of 08004
//
// Messages
// SQLSTATE : 8004
// Authorization ID <authorization-ID> attempted to perform the specified
// <operation> without having been granted the proper authorization to do so.
// SQLCODE : -30060
// <authorization-ID> does not have the privilege to perform operation <operation>.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// RDBNAM - required
//
private void parseRDBATHRM(NetConnection netConnection) throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.RDBATHRM);
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.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, rdbnamReceived);
netAgent_.setSvrcod(svrcod);
netAgent_.accumulateReadException(new SqlException(agent_.logWriter_,
new ClientMessageId(SQLState.NET_CONNECT_AUTH_FAILED),
msgutil_.getTextMessage(MessageId.CONN_USER_NOT_AUTHORIZED_TO_DB)));
}
// Data Stream Syntax Error Reply Message indicates that the data
// sent to the target agent does not structurally conform to the requirements
// of the DDM architecture. The target agent terminated paring of the DSS
// when the condition SYNERRCD specified was detected.
// 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.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// SYNERRCD - required
// RECCNT - optional (MINVAL 0, MINLVL 3) (will not be returned - should be ignored)
// CODPNT - optional (MINLVL 3)
// RDBNAM - optional (MINLVL 3)
//
protected void parseSYNTAXRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean synerrcdReceived = false;
int synerrcd = 0;
boolean rdbnamReceived = false;
String rdbnam = null;
boolean codpntReceived = false;
int codpnt = 0;
parseLengthAndMatchCodePoint(CodePoint.SYNTAXRM);
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.SYNERRCD) {
foundInPass = true;
synerrcdReceived = checkAndGetReceivedFlag(synerrcdReceived);
synerrcd = parseSYNERRCD();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CODPNT) {
foundInPass = true;
codpntReceived = checkAndGetReceivedFlag(codpntReceived);
codpnt = parseCODPNT();
peekCP = peekCodePoint();
}
// RECCNT will be skipped.
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, synerrcdReceived);
netAgent_.setSvrcod(svrcod);
doSyntaxrmSemantics(codpnt);
}
// RDB Currently Accessed Reply Message inidcates that the
// ACCRDB command cannot be issued because the requester
// has access to a relational database.
// 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.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// RDBNAM - required
//
private void parseRDBACCRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.RDBACCRM);
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.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, rdbnamReceived);
netAgent_.setSvrcod(svrcod);
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
msgutil_.getTextMessage(MessageId.CONN_DRDA_RDBACCRM)));
}
// RDB Access Failed Reply Message specifies that the relational
// database failed the attempted connection.
// An SQLCARD object must also be returned, following the
// RDBAFLRM, to explain why the RDB failed the connection.
// In addition, the target SQLAM instance is destroyed.
// The SQLSTATE is returned in the SQLCARD.
//
// 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.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// RDBNAM - required
//
private void parseRDBAFLRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.RDBAFLRM);
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.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, rdbnamReceived);
netAgent_.setSvrcod(svrcod);
}
// Parameter Value Not Supported Reply Message indicates
// that the parameter value specified is either not recognized
// or not supported for the specified parameter.
// The VALNSPRM can only be specified in accordance with
// the rules specified for DDM subsetting.
// The code point of the command parameter in error is
// returned as a parameter in this message.
// PROTOCOL Architects an SQLSTATE of 58017.
//
// if codepoint is 0x119C,0x119D, or 0x119E then SQLSTATE 58017, SQLCODE -332
// else SQLSTATE 58017, SQLCODE -30073
//
// Messages
// SQLSTATE : 58017
// The DDM parameter value is not supported.
// SQLCODE : -332
// There is no available conversion for the source code page
// <code page> to the target code page <code page>.
// Reason code <reason-code>.
// The reason codes are as follows:
// 1 source and target code page combination is not supported
// by the database manager.
// 2 source and target code page combination is either not
// supported by the database manager or by the operating
// system character conversion utility on the client node.
// 3 source and target code page combination is either not
// supported by the database manager or by the operating
// system character conversion utility on the server node.
//
// SQLSTATE : 58017
// The DDM parameter value is not supported.
// SQLCODE : -30073
// <parameter-identifier> Parameter value <value> is not supported.
// Some possible parameter identifiers include:
// 002F The target server does not support the data type
// requested by the application requester.
// The target server does not support the CCSID
// requested by the application requester. Ensure the CCSID
// used by the requester is supported by the server.
// 119C - Verify the single-byte CCSID.
// 119D - Verify the double-byte CCSID.
// 119E - Verify the mixed-byte CCSID.
//
// The current environment command or SQL statement
// cannot be processed successfully, nor can any subsequent
// commands or SQL statements. The current transaction is
// rolled back and the application is disconnected
// from the remote database. The command cannot be processed.
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// CODPNT - required
// RECCNT - optional (MINLVL 3, MINVAL 0) (will not be returned - should be ignored)
// RDBNAM - optional (MINLVL 3)
//
protected void parseVALNSPRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
boolean codpntReceived = false;
int codpnt = 0;
parseLengthAndMatchCodePoint(CodePoint.VALNSPRM);
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.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CODPNT) {
foundInPass = true;
codpntReceived = checkAndGetReceivedFlag(codpntReceived);
codpnt = parseCODPNT();
peekCP = peekCodePoint();
}
// RECCNT will be skipped
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, codpntReceived);
netAgent_.setSvrcod(svrcod);
doValnsprmSemantics(codpnt, "\"\"");
}
// Conversational Protocol Error Reply Message
// indicates that a conversational protocol error occurred.
// PROTOCOL architects the SQLSTATE value depending on SVRCOD
// SVRCOD 8 -> SQLSTATE of 58008 or 58009
// SVRCOD 16,128 -> SQLSTATE of 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.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR, 16 - SEVERE, 128 - SESDMG)
// PRCCNVCD - required
// RECCNT - optional (MINVAL 0, MINLVL 3)
// RDBNAM - optional (NINLVL 3)
//
protected void parsePRCCNVRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
boolean prccnvcdReceived = false;
int prccnvcd = 0;
parseLengthAndMatchCodePoint(CodePoint.PRCCNVRM);
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_SESDMG);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.PRCCNVCD) {
foundInPass = true;
prccnvcdReceived = checkAndGetReceivedFlag(prccnvcdReceived);
prccnvcd = parsePRCCNVCD();
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, prccnvcdReceived);
netAgent_.setSvrcod(svrcod);
doPrccnvrmSemantics(CodePoint.PRCCNVRM);
}
// Object Not Supported Reply Message indicates that the target
// server does not recognize or support the object
// specified as data in an OBJDSS for the command associated
// with the object.
// The OBJNSPRM is also returned if an object is found in a
// valid collection in an OBJDSS (such as RECAL collection)
// that that is not valid for that collection.
// PROTOCOL Architects an SQLSTATE of 58015.
//
// Messages
// SQLSTATE : 58015
// The DDM object is not supported.
// SQLCODE : -30071
// <object-identifier> Object is not supported.
// The current transaction is rolled back and the application
// is disconnected from the remote database. The command
// cannot be processed.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR, 16 - SEVERE)
// CODPNT - required
// RECCNT - optional (MINVAL 0) (will not be returned - should be ignored)
// RDBNAM - optional (MINLVL 3)
//
// Also called by NetPackageReply and NetStatementReply
void parseOBJNSPRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
boolean codpntReceived = false;
int codpnt = 0;
parseLengthAndMatchCodePoint(CodePoint.OBJNSPRM);
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_SEVERE);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CODPNT) {
foundInPass = true;
codpntReceived = checkAndGetReceivedFlag(codpntReceived);
codpnt = parseCODPNT();
peekCP = peekCodePoint();
}
// skip the RECCNT
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, codpntReceived);
netAgent_.setSvrcod(svrcod);
doObjnsprmSemantics(codpnt);
}
// Manager-Level Conflict (MGRLVLRM) Reply Message indicates that
// the manager levels specified in the MGRLVLLS conflict amoung
// themselves or with previously specified manager levels.
// - The manager-level dependencies of one specified manager violates another
// specified maanger level.
// - The manager- level specified attempts to respecify a manager level that
// previously EXCSAT command specified.
// PROTOCOL architects an SQLSTATE of 58010.
//
// Messages
// SQLSTATE : 58010
// Execution failed due to a distributed protocol error that will affect
// the successful execution of subsequent DDM commands or SQL statements.
// SQLCODE : -30021
// Execution failed due to a distribution protocol error
// that will affect the successful execution of subsequent
// commands and SQL statements: Manager <manager> at Level <level>
// not supported.
//
// A system error occurred that prevented successful connection
// of the application to the remote database.
//
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// MGRLVLLS - required
//
private void parseMGRLVLRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean mgrlvllsReceived = false;
int[] managerCodePoint = null;
int[] managerLevel = null;
parseLengthAndMatchCodePoint(CodePoint.MGRLVLRM);
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.MGRLVLLS) {
foundInPass = true;
mgrlvllsReceived = checkAndGetReceivedFlag(mgrlvllsReceived);
parseLengthAndMatchCodePoint(CodePoint.MGRLVLLS);
int managerListLength = getDdmLength();
if ((managerListLength == 0) || ((managerListLength % 7) != 0)) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_OBJ_LEN_NOT_ALLOWED);
}
int managerCount = managerListLength / 7;
managerCodePoint = new int[managerCount];
managerLevel = new int[managerCount];
for (int i = 0; i < managerCount; i++) {
managerCodePoint[i] = parseCODPNTDR();
managerLevel[i] = parseMGRLVLN();
}
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, mgrlvllsReceived);
netAgent_.setSvrcod(svrcod);
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
// Command Not Supported Reply Message indicates that the specified
// command is not recognized or not supported for the
// specified target. The reply message can be returned
// only in accordance with the architected rules for DDM subsetting.
// PROTOCOL architects an SQLSTATE of 58014.
//
// Messages
// SQLSTATE : 58014
// The DDM command is not supported.
// SQLCODE : -30070
// <command-identifier> Command is not supported.
// The current transaction is rolled back and the application is
// disconnected from the remote database. The statement cannot be processed.
//
//
// Returned from Server:
// SVRCOD - required (4 - WARNING, 8 - ERROR) (MINLVL 2)
// CODPNT - required
// RDBNAM - optional (MINLVL 3)
//
protected void parseCMDNSPRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
boolean srvdgnReceived = false;
byte[] srvdgn = null;
boolean codpntReceived = false;
int codpnt = 0;
parseLengthAndMatchCodePoint(CodePoint.CMDNSPRM);
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_WARNING, CodePoint.SVRCOD_ERROR);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.RDBNAM) {
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CODPNT) {
foundInPass = true;
codpntReceived = checkAndGetReceivedFlag(codpntReceived);
codpnt = parseCODPNT();
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, codpntReceived);
netAgent_.setSvrcod(svrcod);
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_DDM_COMMAND_NOT_SUPPORTED),
Integer.toHexString(codpnt)));
}
// Abnormal End Unit of Work Condition Reply Message indicates
// that the current unit of work ended abnormally because
// of some action at the target server. This can be caused by a
// deadlock resolution, operator intervention, or some similar
// situation that caused the relational database to rollback
// the current unit of work. This reply message is returned only
// if an SQLAM issues the command. Whenever an ABNUOWRM is returned
// in response to a command, an SQLCARD object must also be returned
// following the ABNUOWRM. The SQLSTATE is returned in the SQLCARD.
//
// Returned from Server:
// SVRCOD - required (8 - ERROR)
// RDBNAM - required
//
// Called by all the NET*Reply classes.
void parseABNUOWRM() throws DisconnectException {
boolean svrcodReceived = false;
int svrcod = CodePoint.SVRCOD_INFO;
boolean rdbnamReceived = false;
String rdbnam = null;
parseLengthAndMatchCodePoint(CodePoint.ABNUOWRM);
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.RDBNAM) {
// skip the rbbnam since it doesn't tell us anything new.
// there is no way to return it to the application anyway.
// not having to convert this to a string is a time saver also.
foundInPass = true;
rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
rdbnam = parseRDBNAM(true);
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(svrcodReceived, rdbnamReceived);
// the abnuowrm has been received, do whatever state changes are necessary
netAgent_.setSvrcod(svrcod);
}
//--------------------- parse DDM Reply Data--------------------------------------
// The Server Attributes Reply Data (EXCSATRD) returns the following
// information in response to an EXCSAT command:
// - the target server's class name
// - the target server's support level for each class of manager
// the source requests
// - the target server's product release level
// - the target server's external name
// - the target server's name
//
// Returned from Server:
// EXTNAM - optional
// MGRLVLLS - optional
// SRVCLSNM - optional
// SRVNAM - optional
// SRVRLSLV - optional
private void parseEXCSATRD(NetConnection netConnection) throws DisconnectException {
boolean extnamReceived = false;
String extnam = null;
boolean mgrlvllsReceived = false;
boolean srvclsnmReceived = false;
String srvclsnm = null;
boolean srvnamReceived = false;
String srvnam = null;
boolean srvrlslvReceived = false;
String srvrlslv = null;
parseLengthAndMatchCodePoint(CodePoint.EXCSATRD);
pushLengthOnCollectionStack();
int peekCP = peekCodePoint();
while (peekCP != Reply.END_OF_COLLECTION) {
boolean foundInPass = false;
if (peekCP == CodePoint.EXTNAM) {
// External Name is the name of the job, task, or process
// on a system for which a DDM server is active. For a target
// DDM server, the external name is the name of the job the system creates
// or activates to run the DDM server.
// No semantic meaning is assigned to external names in DDM.
// External names are transmitted to aid in problem determination.
// This driver will save the external name of the target (the
// driver may use it for logging purposes later).
foundInPass = true;
extnamReceived = checkAndGetReceivedFlag(extnamReceived);
extnam = parseEXTNAM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.MGRLVLLS) {
// Manager-Level List
// specifies a list of code points and support levels for the
// classes of managers a server supports
foundInPass = true;
mgrlvllsReceived = checkAndGetReceivedFlag(mgrlvllsReceived);
parseMGRLVLLS(netConnection); // need to review this one, check input and output
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SRVCLSNM) {
// Server Class Name
// specifies the name of a class of ddm servers.
foundInPass = true;
srvclsnmReceived = checkAndGetReceivedFlag(srvclsnmReceived);
srvclsnm = parseSRVCLSNM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SRVNAM) {
// Server Name
// no semantic meaning is assigned to server names in DDM,
// it is recommended (by the DDM manual) that the server's
// physical or logical location identifier be used as a server name.
// server names are transmitted for problem determination purposes.
// this driver will save this name and in the future may use it
// for logging errors.
foundInPass = true;
srvnamReceived = checkAndGetReceivedFlag(srvnamReceived);
srvnam = parseSRVNAM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SRVRLSLV) {
// Server Product Release Level
// specifies the procuct release level of a ddm server.
// the contents are unarchitected.
// this driver will save this information and in the future may
// use it for logging purposes.
foundInPass = true;
srvrlslvReceived = checkAndGetReceivedFlag(srvrlslvReceived);
srvrlslv = parseSRVRLSLV();
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
// according the the DDM book, all these instance variables are optional
netConnection.setServerAttributeData(extnam, srvclsnm, srvnam, srvrlslv);
}
// Must make a version that does not change state in the associated connection
private void parseDummyEXCSATRD(NetConnection netConnection) throws DisconnectException {
boolean extnamReceived = false;
String extnam = null;
boolean mgrlvllsReceived = false;
boolean srvclsnmReceived = false;
String srvclsnm = null;
boolean srvnamReceived = false;
String srvnam = null;
boolean srvrlslvReceived = false;
String srvrlslv = null;
parseLengthAndMatchCodePoint(CodePoint.EXCSATRD);
pushLengthOnCollectionStack();
int peekCP = peekCodePoint();
while (peekCP != Reply.END_OF_COLLECTION) {
boolean foundInPass = false;
if (peekCP == CodePoint.EXTNAM) {
// External Name is the name of the job, task, or process
// on a system for which a DDM server is active. For a target
// DDM server, the external name is the name of the job the system creates
// or activates to run the DDM server.
// No semantic meaning is assigned to external names in DDM.
// External names are transmitted to aid in problem determination.
// This driver will save the external name of the target (the
// driver may use it for logging purposes later).
foundInPass = true;
extnamReceived = checkAndGetReceivedFlag(extnamReceived);
extnam = parseEXTNAM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.MGRLVLLS) {
// Manager-Level List
// specifies a list of code points and support levels for the
// classes of managers a server supports
foundInPass = true;
mgrlvllsReceived = checkAndGetReceivedFlag(mgrlvllsReceived);
parseMGRLVLLS(netConnection); // need to review this one, check input and output
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SRVCLSNM) {
// Server Class Name
// specifies the name of a class of ddm servers.
foundInPass = true;
srvclsnmReceived = checkAndGetReceivedFlag(srvclsnmReceived);
srvclsnm = parseSRVCLSNM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SRVNAM) {
// Server Name
// no semantic meaning is assigned to server names in DDM,
// it is recommended (by the DDM manual) that the server's
// physical or logical location identifier be used as a server name.
// server names are transmitted for problem determination purposes.
// this driver will save this name and in the future may use it
// for logging errors.
foundInPass = true;
srvnamReceived = checkAndGetReceivedFlag(srvnamReceived);
srvnam = parseSRVNAM();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SRVRLSLV) {
// Server Product Release Level
// specifies the procuct release level of a ddm server.
// the contents are unarchitected.
// this driver will save this information and in the future may
// use it for logging purposes.
foundInPass = true;
srvrlslvReceived = checkAndGetReceivedFlag(srvrlslvReceived);
srvrlslv = parseSRVRLSLV();
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
// according the the DDM book, all these instance variables are optional
// don't change state of netConnection because this is a DUMMY flow
//netConnection.setServerAttributeData (extnam, srvclsnm, srvnam, srvrlslv);
}
// The Access Security Reply Data (ACSECRD) Collection Object contains
// the security information from a target server's security manager.
// this method returns the security check code received from the server
// (if the server does not return a security check code, this method
// will return 0). it is up to the caller to check
// the value of this return code and take the appropriate action.
//
// Returned from Server:
// SECMEC - required
// SECTKN - optional (MINLVL 6)
// SECCHKCD - optional
private void parseACCSECRD(NetConnection netConnection, int securityMechanism) throws DisconnectException {
boolean secmecReceived = false;
int[] secmecList = null;
boolean sectknReceived = false;
byte[] sectkn = null;
boolean secchkcdReceived = false;
int secchkcd = 0;
parseLengthAndMatchCodePoint(CodePoint.ACCSECRD);
pushLengthOnCollectionStack();
int peekCP = peekCodePoint();
while (peekCP != Reply.END_OF_COLLECTION) {
boolean foundInPass = false;
if (peekCP == CodePoint.SECMEC) {
// security mechanism.
// this value must either reflect the value sent in the ACCSEC command
// if the target server supports it; or the values the target server
// does support when it does not support or accept the value
// requested by the source server.
// the secmecs returned are treated as a list and stored in
// targetSecmec_List.
// if the target server supports the source's secmec, it
// will be saved in the variable targetSecmec_ (NOTE: so
// after calling this method, if targetSecmec_'s value is zero,
// then the target did NOT support the source secmec. any alternate
// secmecs would be contained in targetSecmec_List).
foundInPass = true;
secmecReceived = checkAndGetReceivedFlag(secmecReceived);
secmecList = parseSECMEC();
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SECTKN) {
// security token
foundInPass = true;
sectknReceived = checkAndGetReceivedFlag(sectknReceived);
sectkn = parseSECTKN(false);
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.SECCHKCD) {
// security check code.
// included if and only if an error is detected when processing
// the ACCSEC command. this has an implied severity code
// of ERROR.
foundInPass = true;
secchkcdReceived = checkAndGetReceivedFlag(secchkcdReceived);
secchkcd = parseSECCHKCD();
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
checkRequiredObjects(secmecReceived);
netConnection.setAccessSecurityData(secchkcd,
securityMechanism,
secmecList,
sectknReceived,
sectkn);
}
// Called by all the NET*Reply classes.
void parseTYPDEFNAM() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.TYPDEFNAM);
netAgent_.targetTypdef_.setTypdefnam(readString());
}
// Called by all the NET*Reply classes.
void parseTYPDEFOVR() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.TYPDEFOVR);
pushLengthOnCollectionStack();
int peekCP = peekCodePoint();
while (peekCP != Reply.END_OF_COLLECTION) {
boolean foundInPass = false;
if (peekCP == CodePoint.CCSIDSBC) {
foundInPass = true;
netAgent_.targetTypdef_.setCcsidSbc(parseCCSIDSBC());
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CCSIDDBC) {
foundInPass = true;
netAgent_.targetTypdef_.setCcsidDbc(parseCCSIDDBC());
peekCP = peekCodePoint();
}
if (peekCP == CodePoint.CCSIDMBC) {
foundInPass = true;
netAgent_.targetTypdef_.setCcsidMbc(parseCCSIDMBC());
peekCP = peekCodePoint();
}
if (!foundInPass) {
doPrmnsprmSemantics(peekCP);
}
}
popCollectionStack();
}
// The SYNCCRD Reply Mesage
//
// Returned from Server:
// XARETVAL - required
int parseSYNCCRD(ConnectionCallbackInterface connection) throws DisconnectException {
return 0;
}
// Process XA return value
protected int parseXARETVAL() throws DisconnectException {
return 0;
}
// Process XA return value
protected byte parseSYNCTYPE() throws DisconnectException {
return 0;
}
// This method handles the parsing of all command replies and reply data
// for the SYNCCTL command.
protected int parseSYNCCTLreply(ConnectionCallbackInterface connection)
throws DisconnectException {
if (peekCodePoint() == CodePoint.PBSD) {
parsePBSD();
}
return 0;
}
// Called by the XA commit and rollback parse reply methods.
void parseSYNCCTLError(int peekCP) throws DisconnectException {
switch (peekCP) {
case CodePoint.CMDCHKRM:
parseCMDCHKRM();
break;
case CodePoint.PRCCNVRM:
parsePRCCNVRM();
break;
case CodePoint.SYNTAXRM:
parseSYNTAXRM();
break;
case CodePoint.VALNSPRM:
parseVALNSPRM();
break;
default:
doObjnsprmSemantics(peekCP);
}
}
// Manager-Level List.
// Specifies a list of code points and support levels for the
// classes of managers a server supports.
// The target server must not provide information for any target
// managers unless the source explicitly requests it.
// For each manager class, if the target server's support level
// is greater than or equal to the source server's level, then the source
// server's level is returned for that class if the target server can operate
// at the source's level; otherwise a level 0 is returned. If the target
// server's support level is less than the source server's level, the
// target server's level is returned for that class. If the target server
// does not recognize the code point of a manager class or does not support
// that class, it returns a level of 0. The target server then waits
// for the next command or for the source server to terminate communications.
// When the source server receives EXCSATRD, it must compare each of the entries
// in the mgrlvlls parameter it received to the corresponding entries in the mgrlvlls
// parameter it sent. If any level mismatches, the source server must decide
// whether it can use or adjust to the lower level of target support for that manager
// class. There are no architectural criteria for making this decision.
// The source server can terminate communications or continue at the target
// servers level of support. It can also attempt to use whatever
// commands its user requests while receiving eror reply messages for real
// functional mismatches.
// The manager levels the source server specifies or the target server
// returns must be compatible with the manager-level dependencies of the specified
// manangers. Incompatible manager levels cannot be specified.
// After this method successfully returns, the targetXXXX values (where XXXX
// represents a manager name. example targetAgent) contain the negotiated
// manager levels for this particular connection.
private void parseMGRLVLLS(NetConnection netConnection) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.MGRLVLLS);
// each manager class and level is 4 bytes long.
// get the length of the mgrlvls bytes, make sure it contains
// the correct number of bytes for a mgrlvlls object, and calculate
// the number of manager's returned from the server.
int managerListLength = getDdmLength();
if ((managerListLength == 0) || ((managerListLength % 4) != 0)) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_OBJ_LEN_NOT_ALLOWED);
}
int managerCount = managerListLength / 4;
// the managerCount should be equal to the same number of
// managers sent on the excsat.
// read each of the manager levels returned from the server.
for (int i = 0; i < managerCount; i++) {
// first two byte are the manager's codepoint, next two bytes are the level.
int managerCodePoint = parseCODPNTDR();
int managerLevel = parseMGRLVLN();
// check each manager to make sure levels are within proper limits
// for this driver. Also make sure unexpected managers are not returned.
switch (managerCodePoint) {
case CodePoint.AGENT:
if ((managerLevel < NetConfiguration.MIN_AGENT_MGRLVL) ||
(managerLevel > netConnection.targetAgent_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetAgent_ = managerLevel;
break;
case CodePoint.CMNTCPIP:
if ((managerLevel < NetConfiguration.MIN_CMNTCPIP_MGRLVL) ||
(managerLevel > netConnection.targetCmntcpip_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetCmntcpip_ = managerLevel;
break;
case CodePoint.RDB:
if ((managerLevel < NetConfiguration.MIN_RDB_MGRLVL) ||
(managerLevel > netConnection.targetRdb_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetRdb_ = managerLevel;
break;
case CodePoint.SECMGR:
if ((managerLevel < NetConfiguration.MIN_SECMGR_MGRLVL) ||
(managerLevel > netConnection.targetSecmgr_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetSecmgr_ = managerLevel;
break;
case CodePoint.SQLAM:
if ((managerLevel < NetConfiguration.MIN_SQLAM_MGRLVL) ||
(managerLevel > netAgent_.targetSqlam_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netAgent_.orignalTargetSqlam_ = managerLevel;
break;
case CodePoint.CMNAPPC:
if ((managerLevel < NetConfiguration.MIN_CMNAPPC_MGRLVL) ||
(managerLevel > netConnection.targetCmnappc_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetCmnappc_ = managerLevel;
break;
case CodePoint.XAMGR:
if ((managerLevel != 0) &&
(managerLevel < NetConfiguration.MIN_XAMGR_MGRLVL) ||
(managerLevel > netConnection.targetXamgr_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetXamgr_ = managerLevel;
break;
case CodePoint.SYNCPTMGR:
if ((managerLevel != 0) &&
(managerLevel < NetConfiguration.MIN_SYNCPTMGR_MGRLVL) ||
(managerLevel > netConnection.targetSyncptmgr_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetSyncptmgr_ = managerLevel;
break;
case CodePoint.RSYNCMGR:
if ((managerLevel != 0) &&
(managerLevel < NetConfiguration.MIN_RSYNCMGR_MGRLVL) ||
(managerLevel > netConnection.targetRsyncmgr_)) {
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
}
netConnection.targetRsyncmgr_ = managerLevel;
break;
// The target server must not provide information for any target managers
// unless the source explicitly requests. The following managers are never requested.
default:
doMgrlvlrmSemantics(managerCodePoint, managerLevel);
break;
}
}
}
// The External Name is the name of the job, task, or process on a
// system for which a DDM server is active. On a source DDM server,
// the external name is the name of the job that is requesting
// access to remote resources. For a target DDM server,
// the external name is the name of the job the system
// creates or activates to run the DDM server.
// No semantic meaning is assigned to external names in DDM.
// External names are transmitted to aid in problem determination.
protected String parseEXTNAM() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.EXTNAM);
return readString();
}
// Server Class name specifies the name of a class of DDM servers.
// Server class names are assigned for each product involved in PROTOCOL.
protected String parseSRVCLSNM() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SRVCLSNM);
return readString();
}
// Server Name is the name of the DDM server.
// No semantic meaning is assigned to server names in DDM,
// but it is recommended that the server names are transmitted
// for problem determination.
protected String parseSRVNAM() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SRVNAM);
return readString();
}
// Server Product Release Level String specifies the product
// release level of a DDM server. The contents of the
// parameter are unarchitected. Up to 255 bytes can be sent.
// SRVRLSLV should not be used in place of product-defined
// extensions to carry information not related to the products
// release level.
protected String parseSRVRLSLV() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SRVRLSLV);
return readString();
}
// Manager-Level Number Attribute Binary Integer Number specifies
// the level of a defined DDM manager.
protected int parseMGRLVLN() throws DisconnectException {
return readUnsignedShort();
}
// Security Mechanims.
protected int[] parseSECMEC() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SECMEC);
return readUnsignedShortList();
}
// The Security Token Byte String is information provided and used
// by the various security mechanisms.
protected byte[] parseSECTKN(boolean skip) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SECTKN);
if (skip) {
skipBytes();
return null;
}
return readBytes();
}
// The Security Check Code String codifies the security information
// and condition for the SECCHKRM.
protected int parseSECCHKCD() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SECCHKCD);
int secchkcd = readUnsignedByte();
if ((secchkcd < CodePoint.SECCHKCD_00) || (secchkcd > CodePoint.SECCHKCD_15)) {
doValnsprmSemantics(CodePoint.SECCHKCD, secchkcd);
}
return secchkcd;
}
// Product specific Identifier specifies the product release level
// of a DDM server.
protected String parsePRDID(boolean skip) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.PRDID);
if (skip) {
skipBytes();
return null;
} else {
return readString();
}
}
// The User Id specifies an end-user name.
protected String parseUSRID(boolean skip) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.USRID);
if (skip) {
skipBytes();
return null;
}
return readString();
};
// Code Point Data Representation specifies the data representation
// of a dictionary codepoint. Code points are hexadecimal aliases for DDM
// named terms.
protected int parseCODPNTDR() throws DisconnectException {
return readUnsignedShort();
}
// Correlation Token specifies a token that is conveyed between source
// and target servers for correlating the processing between servers.
protected byte[] parseCRRTKN(boolean skip) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.CRRTKN);
if (skip) {
skipBytes();
return null;
}
return readBytes();
}
// Unit of Work Disposition Scalar Object specifies the disposition of the
// last unit of work.
protected int parseUOWDSP() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.UOWDSP);
int uowdsp = readUnsignedByte();
if ((uowdsp != CodePoint.UOWDSP_COMMIT) && (uowdsp != CodePoint.UOWDSP_ROLLBACK)) {
doValnsprmSemantics(CodePoint.UOWDSP, uowdsp);
}
return uowdsp;
}
// Relational Database Name specifies the name of a relational
// database of the server. A server can have more than one RDB.
protected String parseRDBNAM(boolean skip) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.RDBNAM);
if (skip) {
skipBytes();
return null;
}
return readString();
};
protected int parseXIDCNT() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.XIDCNT);
return readUnsignedShort();
}
protected Xid parseXID() throws DisconnectException {
return null;
}
protected java.util.Hashtable parseIndoubtList() throws DisconnectException {
return null;
}
// Syntax Error Code String specifies the condition that caused termination
// of data stream parsing.
protected int parseSYNERRCD() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SYNERRCD);
int synerrcd = readUnsignedByte();
if ((synerrcd < 0x01) || (synerrcd > 0x1D)) {
doValnsprmSemantics(CodePoint.SYNERRCD, synerrcd);
}
return synerrcd;
}
// The Code Point Data specifies a scalar value that is an architected code point.
protected int parseCODPNT() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.CODPNT);
return parseCODPNTDR();
}
// Conversational Protocol Error Code specifies the condition
// for which the PRCCNVRm was returned.
protected int parsePRCCNVCD() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.PRCCNVCD);
int prccnvcd = readUnsignedByte();
if ((prccnvcd != 0x01) && (prccnvcd != 0x02) && (prccnvcd != 0x03) &&
(prccnvcd != 0x04) && (prccnvcd != 0x05) && (prccnvcd != 0x06) &&
(prccnvcd != 0x10) && (prccnvcd != 0x11) && (prccnvcd != 0x12) &&
(prccnvcd != 0x13) && (prccnvcd != 0x15)) {
doValnsprmSemantics(CodePoint.PRCCNVCD, prccnvcd);
}
return prccnvcd;
}
// CCSID for Single-Byte Characters specifies a coded character
// set identifier for single-byte characters.
protected int parseCCSIDSBC() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.CCSIDSBC);
return readUnsignedShort();
}
// CCSID for Mixed-Byte Characters specifies a coded character
// set identifier for mixed-byte characters.
protected int parseCCSIDMBC() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.CCSIDMBC);
return readUnsignedShort();
}
// CCSID for Double-Byte Characters specifies a coded character
// set identifier for double-byte characters.
protected int parseCCSIDDBC() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.CCSIDDBC);
return readUnsignedShort();
}
// Severity Code is an indicator of the severity of a condition
// detected during the execution of a command.
protected int parseSVRCOD(int minSvrcod, int maxSvrcod) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SVRCOD);
int svrcod = readUnsignedShort();
if ((svrcod != CodePoint.SVRCOD_INFO) &&
(svrcod != CodePoint.SVRCOD_WARNING) &&
(svrcod != CodePoint.SVRCOD_ERROR) &&
(svrcod != CodePoint.SVRCOD_SEVERE) &&
(svrcod != CodePoint.SVRCOD_ACCDMG) &&
(svrcod != CodePoint.SVRCOD_PRMDMG) &&
(svrcod != CodePoint.SVRCOD_SESDMG)) {
doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
}
if (svrcod < minSvrcod || svrcod > maxSvrcod) {
doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
}
return svrcod;
}
protected int parseFastSVRCOD(int minSvrcod, int maxSvrcod) throws DisconnectException {
matchCodePoint(CodePoint.SVRCOD);
int svrcod = readFastUnsignedShort();
if ((svrcod != CodePoint.SVRCOD_INFO) &&
(svrcod != CodePoint.SVRCOD_WARNING) &&
(svrcod != CodePoint.SVRCOD_ERROR) &&
(svrcod != CodePoint.SVRCOD_SEVERE) &&
(svrcod != CodePoint.SVRCOD_ACCDMG) &&
(svrcod != CodePoint.SVRCOD_PRMDMG) &&
(svrcod != CodePoint.SVRCOD_SESDMG)) {
doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
}
if (svrcod < minSvrcod || svrcod > maxSvrcod) {
doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
}
return svrcod;
}
protected NetSqlca parseSQLCARD(Sqlca[] rowsetSqlca) throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.SQLCARD);
int ddmLength = getDdmLength();
ensureBLayerDataInBuffer(ddmLength);
NetSqlca netSqlca = parseSQLCARDrow(rowsetSqlca);
adjustLengths(getDdmLength());
return netSqlca;
}
//--------------------------parse FDOCA objects------------------------
// SQLCARD : FDOCA EARLY ROW
// SQL Communications Area Row Description
//
// FORMAT FOR ALL SQLAM LEVELS
// SQLCAGRP; GROUP LID 0x54; ELEMENT TAKEN 0(all); REP FACTOR 1
NetSqlca parseSQLCARDrow(Sqlca[] rowsetSqlca) throws DisconnectException {
return parseSQLCAGRP(rowsetSqlca);
}
// SQLNUMROW : FDOCA EARLY ROW
// SQL Number of Elements Row Description
//
// FORMAT FOR SQLAM LEVELS
// SQLNUMGRP; GROUP LID 0x58; ELEMENT TAKEN 0(all); REP FACTOR 1
int parseSQLNUMROW() throws DisconnectException {
return parseSQLNUMGRP();
}
int parseFastSQLNUMROW() throws DisconnectException {
return parseFastSQLNUMGRP();
}
// SQLNUMGRP : FDOCA EARLY GROUP
// SQL Number of Elements Group Description
//
// FORMAT FOR ALL SQLAM LEVELS
// SQLNUM; PROTOCOL TYPE I2; ENVLID 0x04; Length Override 2
private int parseSQLNUMGRP() throws DisconnectException {
return readShort();
}
private int parseFastSQLNUMGRP() throws DisconnectException {
return readFastShort();
}
// SQLCAGRP : FDOCA EARLY GROUP
// SQL Communcations Area Group Description
//
// FORMAT FOR SQLAM <= 6
// SQLCODE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLSTATE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 5
// SQLERRPROC; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
// SQLCAXGRP; PROTOCOL TYPE N-GDA; ENVLID 0x52; Length Override 0
//
// FORMAT FOR SQLAM >= 7
// SQLCODE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLSTATE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 5
// SQLERRPROC; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
// SQLCAXGRP; PROTOCOL TYPE N-GDA; ENVLID 0x52; Length Override 0
// SQLDIAGGRP; PROTOCOL TYPE N-GDA; ENVLID 0x56; Length Override 0
private NetSqlca parseSQLCAGRP(Sqlca[] rowsetSqlca) throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
return null;
}
int sqlcode = readFastInt();
byte[] sqlstate = readFastBytes(5);
byte[] sqlerrproc = readFastBytes(8);
NetSqlca netSqlca = null;
try
{
netSqlca = new NetSqlca(netAgent_.netConnection_,
sqlcode,
sqlstate,
sqlerrproc);
}
catch(SqlException sqle)
{
throw new DisconnectException(netAgent_,sqle);
}
parseSQLCAXGRP(netSqlca);
if (netAgent_.targetSqlam_ >= NetConfiguration.MGRLVL_7) {
netSqlca.setRowsetRowCount(parseSQLDIAGGRP(rowsetSqlca));
}
return netSqlca;
}
// SQLCAXGRP : EARLY FDOCA GROUP
// SQL Communications Area Exceptions Group Description
//
// FORMAT FOR SQLAM <= 6
// SQLRDBNME; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 18
// SQLERRD1; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD2; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD3; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD4; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD5; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD6; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLWARN0; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN1; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN2; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN3; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN4; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN5; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN6; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN7; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN8; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN9; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARNA; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLERRMSG_m; PROTOCOL TYPE VCM; ENVLID 0x3E; Length Override 70
// SQLERRMSG_s; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 70
//
// FORMAT FOR SQLAM >= 7
// SQLERRD1; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD2; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD3; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD4; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD5; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLERRD6; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLWARN0; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN1; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN2; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN3; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN4; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN5; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN6; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN7; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN8; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARN9; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLWARNA; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLRDBNAME; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
// SQLERRMSG_m; PROTOCOL TYPE VCM; ENVLID 0x3E; Length Override 70
// SQLERRMSG_s; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 70
private void parseSQLCAXGRP(NetSqlca netSqlca) throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
netSqlca.setContainsSqlcax(false);
return;
}
if (netAgent_.targetSqlam_ < NetConfiguration.MGRLVL_7) {
// skip over the rdbnam for now
// SQLRDBNME; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 18
skipFastBytes(18);
}
// SQLERRD1 to SQLERRD6; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
int[] sqlerrd = new int[6];
readFastIntArray(sqlerrd);
// SQLWARN0 to SQLWARNA; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
byte[] sqlwarn = readFastBytes(11);
if (netAgent_.targetSqlam_ >= NetConfiguration.MGRLVL_7) {
// skip over the rdbnam for now
// SQLRDBNAME; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
parseFastVCS();
}
int sqlerrmcCcsid = 0;
byte[] sqlerrmc = readFastLDBytes();
if (sqlerrmc != null) {
sqlerrmcCcsid = netAgent_.targetTypdef_.getCcsidMbc();
skipFastBytes(2);
} else {
sqlerrmc = readFastLDBytes();
sqlerrmcCcsid = netAgent_.targetTypdef_.getCcsidSbc();
}
netSqlca.setSqlerrd(sqlerrd);
netSqlca.setSqlwarnBytes(sqlwarn);
netSqlca.setSqlerrmcBytes(sqlerrmc, sqlerrmcCcsid); // sqlerrmc may be null
}
// SQLDIAGGRP : FDOCA EARLY GROUP
// SQL Diagnostics Group Description - Identity 0xD1
// Nullable Group
// SQLDIAGSTT; PROTOCOL TYPE N-GDA; ENVLID 0xD3; Length Override 0
// SQLDIAGCN; DRFA TYPE N-RLO; ENVLID 0xF6; Length Override 0
// SQLDIAGCI; PROTOCOL TYPE N-RLO; ENVLID 0xF5; Length Override 0
private long parseSQLDIAGGRP(Sqlca[] rowsetSqlca) throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
return 0;
}
long row_count = parseSQLDIAGSTT(rowsetSqlca);
parseSQLDIAGCI(rowsetSqlca);
parseSQLDIAGCN();
return row_count;
}
// this is duplicated in parseColumnMetaData, but different
// DAGroup under NETColumnMetaData requires a lot more stuffs including
// precsion, scale and other stuffs
protected String parseFastVCS() throws DisconnectException {
// doublecheck what readString() does if the length is 0
return readFastString(readFastUnsignedShort(),
netAgent_.targetTypdef_.getCcsidSbcEncoding());
}
//----------------------non-parsing computational helper methods--------------
protected boolean checkAndGetReceivedFlag(boolean receivedFlag) throws DisconnectException {
if (receivedFlag) {
// this method will throw a disconnect exception if
// the received flag is already true;
doSyntaxrmSemantics(CodePoint.SYNERRCD_DUP_OBJ_PRESENT);
}
return true;
}
protected void checkRequiredObjects(boolean receivedFlag) throws DisconnectException {
if (!receivedFlag) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
}
}
protected void checkRequiredObjects(boolean receivedFlag,
boolean receivedFlag2) throws DisconnectException {
if (!receivedFlag || !receivedFlag2) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
}
}
protected void checkRequiredObjects(boolean receivedFlag,
boolean receivedFlag2,
boolean receivedFlag3) throws DisconnectException {
if (!receivedFlag || !receivedFlag2 || !receivedFlag3) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
}
}
protected void checkRequiredObjects(boolean receivedFlag,
boolean receivedFlag2,
boolean receivedFlag3,
boolean receivedFlag4) throws DisconnectException {
if (!receivedFlag || !receivedFlag2 || !receivedFlag3 || !receivedFlag4) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
}
}
protected void checkRequiredObjects(boolean receivedFlag,
boolean receivedFlag2,
boolean receivedFlag3,
boolean receivedFlag4,
boolean receivedFlag5,
boolean receivedFlag6) throws DisconnectException {
if (!receivedFlag || !receivedFlag2 || !receivedFlag3 || !receivedFlag4 ||
!receivedFlag5 || !receivedFlag6) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
}
}
protected void checkRequiredObjects(boolean receivedFlag,
boolean receivedFlag2,
boolean receivedFlag3,
boolean receivedFlag4,
boolean receivedFlag5,
boolean receivedFlag6,
boolean receivedFlag7) throws DisconnectException {
if (!receivedFlag || !receivedFlag2 || !receivedFlag3 || !receivedFlag4 ||
!receivedFlag5 || !receivedFlag6 || !receivedFlag7) {
doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
}
}
// 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.
protected void doObjnsprmSemantics(int codePoint) throws DisconnectException {
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_DDM_OBJECT_NOT_SUPPORTED),
Integer.toHexString(codePoint)));
}
// Also called by NetStatementReply.
protected void doPrmnsprmSemantics(int codePoint) throws DisconnectException {
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_DDM_PARAM_NOT_SUPPORTED),
Integer.toHexString(codePoint)));
}
// Also called by NetStatementReply
void doValnsprmSemantics(int codePoint, int value) throws DisconnectException {
doValnsprmSemantics(codePoint, Integer.toString(value));
}
void doValnsprmSemantics(int codePoint, String value) throws DisconnectException {
// special case the FDODTA codepoint not to disconnect.
if (codePoint == CodePoint.FDODTA) {
agent_.accumulateReadException(new SqlException(agent_.logWriter_,
new ClientMessageId(SQLState.DRDA_DDM_PARAMVAL_NOT_SUPPORTED),
Integer.toHexString(codePoint)));
return;
}
if (codePoint == CodePoint.CCSIDSBC ||
codePoint == CodePoint.CCSIDDBC ||
codePoint == CodePoint.CCSIDMBC) {
// the server didn't like one of the ccsids.
// the message should reflect the error in question. right now these values
// will be hard coded but this won't be correct if our driver starts sending
// other values to the server. In order to pick up the correct values,
// a little reorganization may need to take place so that this code (or
// whatever code sets the message) has access to the correct values.
int cpValue = 0;
switch (codePoint) {
case CodePoint.CCSIDSBC:
cpValue = netAgent_.typdef_.getCcsidSbc();
break;
case CodePoint.CCSIDDBC:
cpValue = netAgent_.typdef_.getCcsidDbc();
break;
case CodePoint.CCSIDMBC:
cpValue = netAgent_.typdef_.getCcsidSbc();
break;
default:
// should never be in this default case...
cpValue = 0;
break;
}
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_NO_AVAIL_CODEPAGE_CONVERSION),
new Integer(cpValue), value));
return;
}
// the problem isn't with one of the ccsid values so...
// Returning more information would
// require rearranging this code a little.
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_DDM_PARAMVAL_NOT_SUPPORTED),
Integer.toHexString(codePoint)));
}
void doDtamchrmSemantics() throws DisconnectException {
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
msgutil_.getTextMessage(MessageId.CONN_DRDA_DTARMCHRM)));
}
// Messages
// SQLSTATE : 58010
// Execution failed due to a distribution protocol error that
// will affect the successful execution of subsequent DDM commands
// or SQL statements.
// SQLCODE : -30021
// Execution failed because of a Distributed Protocol
// Error that will affect the successful execution of subsequent
// commands and SQL statements: Manager <manager> at Level
// <level> not supported.
//
// A system erro occurred that prevented successful connection
// of the application to the remote database. This message (SQLCODE)
// is producted for SQL CONNECT statement.
private void doMgrlvlrmSemantics(String manager, String level) throws DisconnectException {
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_MGRLVLRM),
manager, level));
}
private void doMgrlvlrmSemantics(int manager, int level) throws DisconnectException {
doMgrlvlrmSemantics("0x" + Integer.toHexString(manager),
"0x" + Integer.toHexString(level));
}
private void doMgrlvlrmSemantics(int[] nameList, int[] levelList) throws DisconnectException {
StringBuffer managerNames = new StringBuffer(100);
StringBuffer managerLevels = new StringBuffer(100);
int count = nameList.length;
for (int i = 0; i < count; i++) {
managerNames.append("0x");
managerNames.append(nameList[i]);
managerLevels.append("0x");
managerLevels.append(levelList[i]);
if (i != (count - 1)) {
managerNames.append(",");
managerLevels.append(",");
}
}
doMgrlvlrmSemantics(managerNames.toString(), managerLevels.toString());
}
// The client can detect that a conversational protocol error has occurred.
// This can also be detected at the server in which case a PRCCNVRM is returned.
// The Conversation Protocol Error Code, PRCCNVRM, 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.
// Conversation Error Code Description of Error
// ----------------------- --------------------
// 0x01 RPYDSS received by target communications manager.
// 0x02 Multiple DSSs sent without chaining or multiple
// DSS chains sent.
// 0x03 OBJDSS sent when not allowed.
// 0x04 Request correlation identifier of an RQSDSS
// is less than or equal to the previous
// RQSDSS's request correlatio identifier in the chain.
// 0x05 Request correlation identifier of an OBJDSS
// does not equal the request correlation identifier
// of the preceding RQSDSS.
// 0x06 EXCSAT was not the first command after the connection
// was established.
// 0x10 ACCSEC or SECCHK command sent in wrong state.
// 0x11 SYNCCTL or SYNCRSY command is used incorrectly.
// 0x12 RDBNAM mismatch between ACCSEC, SECCHK, and ACCRDB.
// 0x13 A command follows one that returned EXTDTAs as reply object.
//
// When the client detects these errors, it will be handled as if a PRCCNVRM is returned
// from the server. In this PRCCNVRM case, PROTOCOL architects an SQLSTATE of 58008 or 58009
// depening of the SVRCOD. In this case, a 58009 will always be returned.
// 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.
protected void doPrccnvrmSemantics(int conversationProtocolErrorCode) throws DisconnectException {
// we may need to map the conversation protocol error code, prccnvcd, to some kind
// of reason code. For now just return the prccnvcd as the reason code
agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
msgutil_.getTextMessage(MessageId.CONN_DRDA_PRCCNVRM,
Integer.toHexString(conversationProtocolErrorCode))));
}
// SQL Diagnostics Condition Token Array - Identity 0xF7
// SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
// SQLTOKROW; ROW LID 0xE7; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
void parseSQLDCTOKS() throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
return;
}
int num = parseFastSQLNUMROW();
for (int i = 0; i < num; i++) {
parseSQLTOKROW();
}
}
// SQL Diagnostics Condition Information Array - Identity 0xF5
// SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
// SQLDCIROW; ROW LID 0xE5; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
private void parseSQLDIAGCI(Sqlca[] rowsetSqlca) throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
return;
}
int num = parseFastSQLNUMROW();
if (num == 0) {
resetRowsetSqlca(rowsetSqlca, 0);
}
// lastRow is the row number for the last row that had a non-null SQLCA.
int lastRow = 1;
for (int i = 0; i < num; i++) {
lastRow = parseSQLDCROW(rowsetSqlca, lastRow);
}
resetRowsetSqlca(rowsetSqlca, lastRow + 1);
}
// SQL Diagnostics Connection Array - Identity 0xF6
// SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
// SQLCNROW; ROW LID 0xE6; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
private void parseSQLDIAGCN() throws DisconnectException {
if (readUnsignedByte() == CodePoint.NULLDATA) {
return;
}
int num = parseFastSQLNUMROW();
for (int i = 0; i < num; i++) {
parseSQLCNROW();
}
}
// SQL Diagnostics Connection Row - Identity 0xE6
// SQLCNGRP; GROUP LID 0xD6; ELEMENT TAKEN 0(all); REP FACTOR 1
private void parseSQLCNROW() throws DisconnectException {
parseSQLCNGRP();
}
// SQL Diagnostics Condition Row - Identity 0xE5
// SQLDCGRP; GROUP LID 0xD5; ELEMENT TAKEN 0(all); REP FACTOR 1
private int parseSQLDCROW(Sqlca[] rowsetSqlca, int lastRow) throws DisconnectException {
return parseSQLDCGRP(rowsetSqlca, lastRow);
}
// SQL Diagnostics Token Row - Identity 0xE7
// SQLTOKGRP; GROUP LID 0xD7; ELEMENT TAKEN 0(all); REP FACTOR 1
private void parseSQLTOKROW() throws DisconnectException {
parseSQLTOKGRP();
}
// check on SQLTOKGRP format
private void parseSQLTOKGRP() throws DisconnectException {
skipFastNVCMorNVCS();
}
// SQL Diagnostics Statement Group Description - Identity 0xD3
// Nullable Group
// SQLDSFCOD; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDSCOST; PROTOCOL TYPE I4; ENVLID 0X02; Length Override 4
// SQLDSLROW; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDSNPM; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDSNRS; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDSRNS; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDSDCOD; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDSROWC; PROTOCOL TYPE FD; ENVLID 0x0E; Length Override 31
// SQLDSNROW; PROTOCOL TYPE FD; ENVLID 0x0E; Length Override 31
// SQLDSROWCS; PROTOCOL TYPE FD; ENVLID 0x0E; Length Override 31
// SQLDSACON; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSACRH; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSACRS; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSACSL; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSACSE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSACTY; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSCERR; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLDSMORE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
private long parseSQLDIAGSTT(Sqlca[] rowsetSqlca) throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
return 0;
}
int sqldsFcod = readFastInt(); // FUNCTION_CODE
int sqldsCost = readFastInt(); // COST_ESTIMATE
int sqldsLrow = readFastInt(); // LAST_ROW
skipFastBytes(16);
long sqldsRowc = readFastLong(); // ROW_COUNT
skipFastBytes(24);
return sqldsRowc;
}
// SQL Diagnostics Connection Group Description - Identity 0xD6
// Nullable
//
// SQLCNSTATE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLCNSTATUS; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLCNATYPE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLCNETYPE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
// SQLCNPRDID; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
// SQLCNRDB; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
// SQLCNCLASS; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
// SQLCNAUTHID; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
private void parseSQLCNGRP() throws DisconnectException {
skipBytes(18);
String sqlcnRDB = parseFastVCS(); // RDBNAM
String sqlcnClass = parseFastVCS(); // CLASS_NAME
String sqlcnAuthid = parseFastVCS(); // AUTHID
}
// SQL Diagnostics Condition Group Description
//
// SQLDCCODE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCSTATE; PROTOCOL TYPE FCS; ENVLID Ox30; Lengeh Override 5
// SQLDCREASON; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCLINEN; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCROWN; PROTOCOL TYPE FD; ENVLID 0x0E; Lengeh Override 31
// SQLDCER01; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCER02; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCER03; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCER04; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCPART; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCPPOP; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
// SQLDCMSGID; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 10
// SQLDCMDE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
// SQLDCPMOD; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 5
// SQLDCRDB; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
// SQLDCTOKS; PROTOCOL TYPE N-RLO; ENVLID 0xF7; Length Override 0
// SQLDCMSG_m; PROTOCOL TYPE NVMC; ENVLID 0x3F; Length Override 32672
// SQLDCMSG_S; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 32672
// SQLDCCOLN_m; PROTOCOL TYPE NVCM ; ENVLID 0x3F; Length Override 255
// SQLDCCOLN_s; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCCURN_m; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCCURN_s; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCPNAM_m; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCPNAM_s; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXGRP; PROTOCOL TYPE N-GDA; ENVLID 0xD3; Length Override 1
private int parseSQLDCGRP(Sqlca[] rowsetSqlca, int lastRow) throws DisconnectException {
int sqldcCode = readFastInt(); // SQLCODE
String sqldcState = readFastString(5, Typdef.UTF8ENCODING); // SQLSTATE
int sqldcReason = readFastInt(); // REASON_CODE
int sqldcLinen = readFastInt(); // LINE_NUMBER
int sqldcRown = (int) readFastLong(); // ROW_NUMBER
// save +20237 in the 0th entry of the rowsetSqlca's.
// this info is going to be used when a subsequent fetch prior is issued, and if already
// received a +20237 then we've gone beyond the first row and there is no need to
// flow another fetch to the server.
if (sqldcCode == 20237) {
rowsetSqlca[0] = new NetSqlca(netAgent_.netConnection_,
sqldcCode,
sqldcState,
null);
} else {
if (rowsetSqlca[sqldcRown] != null) {
rowsetSqlca[sqldcRown].resetRowsetSqlca(netAgent_.netConnection_,
sqldcCode,
sqldcState,
null);
} else {
rowsetSqlca[sqldcRown] = new NetSqlca(netAgent_.netConnection_,
sqldcCode,
sqldcState,
null);
}
}
// reset all entries between lastRow and sqldcRown to null
for (int i = lastRow + 1; i < sqldcRown; i++) {
rowsetSqlca[i] = null;
}
skipFastBytes(47);
String sqldcRdb = parseFastVCS(); // RDBNAM
// skip the tokens for now, since we already have the complete message.
parseSQLDCTOKS(); // MESSAGE_TOKENS
String sqldcMsg = parseFastNVCMorNVCS(); // MESSAGE_TEXT
// skip the following for now.
skipFastNVCMorNVCS(); // COLUMN_NAME
skipFastNVCMorNVCS(); // PARAMETER_NAME
skipFastNVCMorNVCS(); // EXTENDED_NAMES
parseSQLDCXGRP(); // SQLDCXGRP
return sqldcRown;
}
// SQL Diagnostics Extended Names Group Description - Identity 0xD5
// Nullable
//
// SQLDCXRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXTBLN_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXTBLN_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
//
// SQLDCXCRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXCSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXCNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXCRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXCSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXCNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
//
// SQLDCXRRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXRSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXRNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXRRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXRSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXRNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
//
// SQLDCXTRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXTSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXTNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
// SQLDCXTRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXTSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
// SQLDCXTNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
private void parseSQLDCXGRP() throws DisconnectException {
if (readFastUnsignedByte() == CodePoint.NULLDATA) {
return;
}
skipFastNVCMorNVCS(); // OBJECT_RDBNAM
skipFastNVCMorNVCS(); // OBJECT_SCHEMA
skipFastNVCMorNVCS(); // SPECIFIC_NAME
skipFastNVCMorNVCS(); // TABLE_NAME
String sqldcxCrdb = parseFastVCS(); // CONSTRAINT_RDBNAM
skipFastNVCMorNVCS(); // CONSTRAINT_SCHEMA
skipFastNVCMorNVCS(); // CONSTRAINT_NAME
parseFastVCS(); // ROUTINE_RDBNAM
skipFastNVCMorNVCS(); // ROUTINE_SCHEMA
skipFastNVCMorNVCS(); // ROUTINE_NAME
parseFastVCS(); // TRIGGER_RDBNAM
skipFastNVCMorNVCS(); // TRIGGER_SCHEMA
skipFastNVCMorNVCS(); // TRIGGER_NAME
}
private String parseFastNVCMorNVCS() throws DisconnectException {
String stringToBeSet = null;
int vcm_length = 0;
int vcs_length = 0;
if (readFastUnsignedByte() != CodePoint.NULLDATA) {
vcm_length = readFastUnsignedShort();
if (vcm_length > 0) {
stringToBeSet = readFastString(vcm_length, netAgent_.targetTypdef_.getCcsidMbcEncoding());
}
if (readFastUnsignedByte() != CodePoint.NULLDATA) {
agent_.accumulateChainBreakingReadExceptionAndThrow(
new DisconnectException(agent_,
new ClientMessageId(
SQLState.NET_NVCM_NVCS_BOTH_NON_NULL)));
}
} else {
if (readFastUnsignedByte() != CodePoint.NULLDATA) {
vcs_length = readFastUnsignedShort();
if (vcs_length > 0) {
stringToBeSet = readFastString(vcs_length, netAgent_.targetTypdef_.getCcsidSbcEncoding());
}
}
}
return stringToBeSet;
}
private void skipFastNVCMorNVCS() throws DisconnectException {
int vcm_length = 0;
int vcs_length = 0;
if (readFastUnsignedByte() != CodePoint.NULLDATA) {
vcm_length = readFastUnsignedShort();
if (vcm_length > 0)
//stringToBeSet = readString (vcm_length, netAgent_.targetTypdef_.getCcsidMbcEncoding());
{
skipFastBytes(vcm_length);
}
if (readFastUnsignedByte() != CodePoint.NULLDATA) {
agent_.accumulateChainBreakingReadExceptionAndThrow(
new DisconnectException(agent_,
new ClientMessageId(
SQLState.NET_NVCM_NVCS_BOTH_NON_NULL)));
}
} else {
if (readFastUnsignedByte() != CodePoint.NULLDATA) {
vcs_length = readFastUnsignedShort();
if (vcs_length > 0)
//stringToBeSet = readString (vcs_length, netAgent_.targetTypdef_.getCcsidSbcEncoding());
{
skipFastBytes(vcs_length);
}
}
}
}
void resetRowsetSqlca(Sqlca[] rowsetSqlca, int row) {
// rowsetSqlca can be null.
int count = ((rowsetSqlca == null) ? 0 : rowsetSqlca.length);
for (int i = row; i < count; i++) {
rowsetSqlca[i] = null;
}
}
/**
* Parse a PBSD - PiggyBackedSessionData code point. Can contain one or
* both of, a PBSD_ISO code point followed by a byte representing the jdbc
* isolation level, and a PBSD_SCHEMA code point followed by the name of the
* current schema as an UTF-8 String.
* @throws org.apache.derby.client.am.DisconnectException
*/
protected void parsePBSD() throws DisconnectException {
parseLengthAndMatchCodePoint(CodePoint.PBSD);
int peekCP = peekCodePoint();
while (peekCP != END_OF_SAME_ID_CHAIN) {
parseLengthAndMatchCodePoint(peekCP);
switch (peekCP) {
case CodePoint.PBSD_ISO:
netAgent_.netConnection_.
completePiggyBackIsolation(readUnsignedByte());
break;
case CodePoint.PBSD_SCHEMA:
netAgent_.netConnection_.
completePiggyBackSchema
(readString(getDdmLength(), "UTF-8"));
break;
default:
parseCommonError(peekCP);
}
peekCP = peekCodePoint();
}
}
}
The table below shows all metrics for NetConnectionReply.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 336.00 | Number of blocks | |
| BLOCK_COMMENT | 20.00 | Number of block comment lines | |
| COMMENTS | 1044.00 | Comment lines | |
| COMMENT_DENSITY | 0.68 | Comment density | |
| COMPARISONS | 207.00 | Number of comparison operators | |
| CYCLOMATIC | 415.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 93.00 | Comments in declarations | |
| DOC_COMMENT | 34.00 | Number of javadoc comment lines | |
| ELOC | 1538.00 | Effective lines of code | |
| EXEC_COMMENTS | 61.00 | Comments in executable code | |
| EXITS | 174.00 | Procedure exits | |
| FUNCTIONS | 133.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 127.54 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 868.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 1.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 8.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 4.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 0.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 0.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 0.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 10.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 1.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 0.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 0.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 0.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 1.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 0.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 0.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 0.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 54.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 1.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 2.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 0.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 2.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 2.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 12.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 16.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 11.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 2.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 21.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 0.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 0.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 0.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 0.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 0.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 0.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 3342.00 | Number of lines in the source file | |
| LINE_COMMENT | 990.00 | Number of line comments | |
| LOC | 1879.00 | Lines of code | |
| LOGICAL_LINES | 1031.00 | Number of statements | |
| LOOPS | 30.00 | Number of loops | |
| NEST_DEPTH | 4.00 | Maximum nesting depth | |
| OPERANDS | 3392.00 | Number of operands | |
| OPERATORS | 7062.00 | Number of operators | |
| PARAMS | 112.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 10454.00 | Halstead program length | |
| PROGRAM_VOCAB | 815.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 756.00 | Number of return points from functions | |
| SIZE | 136258.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 758.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 57.00 | Number of unique operators | |
| WHITESPACE | 419.00 | Number of whitespace lines | |