EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.client.net]

COVERAGE SUMMARY FOR SOURCE FILE [NetConnectionReply.java]

nameclass, %method, %block, %line, %
NetConnectionReply.java100% (1/1)44%  (58/131)34%  (1352/3940)36%  (461.4/1272)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class NetConnectionReply100% (1/1)44%  (58/131)34%  (1352/3940)36%  (461.4/1272)
NetConnectionReply (NetAgent, int): void 100% (1/1)100% (5/5)100% (2/2)
checkAndGetReceivedFlag (boolean): boolean 100% (1/1)57%  (4/7)67%  (2/3)
checkRequiredObjects (boolean): void 100% (1/1)50%  (3/6)67%  (2/3)
checkRequiredObjects (boolean, boolean): void 100% (1/1)62%  (5/8)67%  (2/3)
checkRequiredObjects (boolean, boolean, boolean): void 100% (1/1)70%  (7/10)67%  (2/3)
checkRequiredObjects (boolean, boolean, boolean, boolean): void 100% (1/1)75%  (9/12)67%  (2/3)
checkRequiredObjects (boolean, boolean, boolean, boolean, boolean, boolean): ... 0%   (0/1)0%   (0/16)0%   (0/3)
checkRequiredObjects (boolean, boolean, boolean, boolean, boolean, boolean, b... 0%   (0/1)0%   (0/18)0%   (0/3)
doDtamchrmSemantics (): void 0%   (0/1)0%   (0/11)0%   (0/2)
doMgrlvlrmSemantics (String, String): void 0%   (0/1)0%   (0/24)0%   (0/2)
doMgrlvlrmSemantics (int [], int []): void 0%   (0/1)0%   (0/60)0%   (0/13)
doMgrlvlrmSemantics (int, int): void 0%   (0/1)0%   (0/21)0%   (0/2)
doObjnsprmSemantics (int): void 0%   (0/1)0%   (0/19)0%   (0/2)
doPrccnvrmSemantics (int): void 0%   (0/1)0%   (0/19)0%   (0/2)
doPrmnsprmSemantics (int): void 0%   (0/1)0%   (0/19)0%   (0/2)
doValnsprmSemantics (int, String): void 0%   (0/1)0%   (0/100)0%   (0/17)
doValnsprmSemantics (int, int): void 0%   (0/1)0%   (0/6)0%   (0/2)
parseABNUOWRM (ConnectionCallbackInterface): void 100% (1/1)96%  (70/73)97%  (25.2/26)
parseACCRDBRM (NetConnection): void 100% (1/1)81%  (120/149)83%  (43.2/52)
parseACCRDBreply (NetConnection): void 100% (1/1)65%  (20/31)67%  (8/12)
parseACCSECRD (NetConnection, int): void 100% (1/1)69%  (62/90)73%  (23.2/32)
parseACCSECreply (NetConnection, int): void 100% (1/1)77%  (17/22)67%  (6/9)
parseAbnormalEndUow (ConnectionCallbackInterface): NetSqlca 100% (1/1)81%  (13/16)80%  (4/5)
parseAccessRdbError (NetConnection): void 100% (1/1)37%  (10/27)36%  (5/14)
parseAccessSecurityError (NetConnection): void 0%   (0/1)0%   (0/20)0%   (0/10)
parseCCSIDDBC (): int 0%   (0/1)0%   (0/6)0%   (0/2)
parseCCSIDMBC (): int 100% (1/1)100% (6/6)100% (2/2)
parseCCSIDSBC (): int 100% (1/1)100% (6/6)100% (2/2)
parseCMDCHKRM (): void 0%   (0/1)0%   (0/93)0%   (0/31)
parseCMDNSPRM (): void 0%   (0/1)0%   (0/112)0%   (0/35)
parseCODPNT (): int 0%   (0/1)0%   (0/6)0%   (0/2)
parseCODPNTDR (): int 100% (1/1)100% (3/3)100% (1/1)
parseCRRTKN (boolean): byte [] 0%   (0/1)0%   (0/12)0%   (0/5)
parseCommitError (ConnectionCallbackInterface): void 0%   (0/1)0%   (0/23)0%   (0/11)
parseCommonError (int): void 0%   (0/1)0%   (0/18)0%   (0/11)
parseConnectError (): void 0%   (0/1)0%   (0/15)0%   (0/8)
parseDummyEXCSATRD (NetConnection): void 0%   (0/1)0%   (0/115)0%   (0/43)
parseDummyEXCSATreply (NetConnection): void 0%   (0/1)0%   (0/11)0%   (0/5)
parseENDUOWRM (ConnectionCallbackInterface): void 100% (1/1)84%  (82/98)86%  (30.2/35)
parseEXCSATRD (NetConnection): void 100% (1/1)98%  (118/121)98%  (43.2/44)
parseEXCSATreply (NetConnection): void 100% (1/1)73%  (8/11)60%  (3/5)
parseEXTNAM (): String 100% (1/1)100% (6/6)100% (2/2)
parseExchangeServerAttributesError (): void 0%   (0/1)0%   (0/15)0%   (0/8)
parseFastNVCMorNVCS (): String 0%   (0/1)0%   (0/56)0%   (0/14)
parseFastSQLNUMGRP (): int 100% (1/1)100% (3/3)100% (1/1)
parseFastSQLNUMROW (): int 100% (1/1)100% (3/3)100% (1/1)
parseFastSVRCOD (int, int): int 100% (1/1)40%  (17/43)62%  (4.3/7)
parseFastVCS (): String 100% (1/1)100% (9/9)100% (1/1)
parseIndoubtList (): Hashtable 0%   (0/1)0%   (0/2)0%   (0/1)
parseMGRLVLLS (NetConnection): void 100% (1/1)50%  (91/182)51%  (24/47)
parseMGRLVLN (): int 100% (1/1)100% (3/3)100% (1/1)
parseMGRLVLRM (): void 0%   (0/1)0%   (0/115)0%   (0/36)
parseOBJNSPRM (): void 0%   (0/1)0%   (0/93)0%   (0/33)
parsePRCCNVCD (): int 0%   (0/1)0%   (0/45)0%   (0/5)
parsePRCCNVRM (): void 0%   (0/1)0%   (0/93)0%   (0/33)
parsePRDID (boolean): String 100% (1/1)67%  (8/12)60%  (3/5)
parseRDBACCRM (): void 0%   (0/1)0%   (0/81)0%   (0/26)
parseRDBAFLRM (): void 100% (1/1)96%  (68/71)97%  (24.2/25)
parseRDBATHRM (NetConnection): void 0%   (0/1)0%   (0/82)0%   (0/26)
parseRDBCMMreply (ConnectionCallbackInterface): void 100% (1/1)77%  (23/30)77%  (7.7/10)
parseRDBNACRM (): void 0%   (0/1)0%   (0/81)0%   (0/26)
parseRDBNAM (boolean): String 100% (1/1)75%  (9/12)80%  (4/5)
parseRDBNFNRM (NetConnection): void 100% (1/1)63%  (57/91)78%  (20.2/26)
parseRDBRLLBCKreply (ConnectionCallbackInterface): void 100% (1/1)87%  (20/23)78%  (7/9)
parseRdbAccessFailed (NetConnection): void 100% (1/1)87%  (26/30)82%  (9/11)
parseRollbackError (): void 0%   (0/1)0%   (0/15)0%   (0/8)
parseSECCHKCD (): int 100% (1/1)76%  (13/17)80%  (4/5)
parseSECCHKRM (NetConnection): void 100% (1/1)82%  (74/90)85%  (27.2/32)
parseSECCHKreply (NetConnection): void 100% (1/1)55%  (12/22)50%  (4/8)
parseSECMEC (): int [] 100% (1/1)100% (6/6)100% (2/2)
parseSECTKN (boolean): byte [] 0%   (0/1)0%   (0/12)0%   (0/5)
parseSQLCAGRP (Sqlca []): NetSqlca 100% (1/1)100% (46/46)100% (10/10)
parseSQLCARD (Sqlca []): NetSqlca 100% (1/1)100% (19/19)100% (6/6)
parseSQLCARDrow (Sqlca []): NetSqlca 100% (1/1)100% (4/4)100% (1/1)
parseSQLCAXGRP (NetSqlca): void 100% (1/1)90%  (62/69)86%  (18/21)
parseSQLCNGRP (): void 0%   (0/1)0%   (0/13)0%   (0/5)
parseSQLCNROW (): void 0%   (0/1)0%   (0/3)0%   (0/2)
parseSQLDCGRP (Sqlca [], int): int 0%   (0/1)0%   (0/122)0%   (0/24)
parseSQLDCROW (Sqlca [], int): int 0%   (0/1)0%   (0/5)0%   (0/1)
parseSQLDCTOKS (): void 0%   (0/1)0%   (0/18)0%   (0/6)
parseSQLDCXGRP (): void 0%   (0/1)0%   (0/35)0%   (0/16)
parseSQLDIAGCI (Sqlca []): void 0%   (0/1)0%   (0/35)0%   (0/10)
parseSQLDIAGCN (): void 0%   (0/1)0%   (0/18)0%   (0/6)
parseSQLDIAGGRP (Sqlca []): long 100% (1/1)35%  (6/17)33%  (2/6)
parseSQLDIAGSTT (Sqlca []): long 0%   (0/1)0%   (0/26)0%   (0/9)
parseSQLNUMGRP (): int 100% (1/1)100% (3/3)100% (1/1)
parseSQLNUMROW (): int 100% (1/1)100% (3/3)100% (1/1)
parseSQLTOKGRP (): void 0%   (0/1)0%   (0/3)0%   (0/2)
parseSQLTOKROW (): void 0%   (0/1)0%   (0/3)0%   (0/2)
parseSRVCLSNM (): String 100% (1/1)100% (6/6)100% (2/2)
parseSRVNAM (): String 100% (1/1)100% (6/6)100% (2/2)
parseSRVRLSLV (): String 100% (1/1)100% (6/6)100% (2/2)
parseSVRCOD (int, int): int 100% (1/1)53%  (23/43)65%  (4.6/7)
parseSYNCCRD (ConnectionCallbackInterface): int 0%   (0/1)0%   (0/2)0%   (0/1)
parseSYNCCTLError (int): void 0%   (0/1)0%   (0/18)0%   (0/11)
parseSYNCCTLreply (ConnectionCallbackInterface): int 0%   (0/1)0%   (0/2)0%   (0/1)
parseSYNCTYPE (): byte 0%   (0/1)0%   (0/2)0%   (0/1)
parseSYNERRCD (): int 0%   (0/1)0%   (0/18)0%   (0/5)
parseSYNTAXRM (): void 0%   (0/1)0%   (0/112)0%   (0/40)
parseSecurityCheckError (NetConnection): void 0%   (0/1)0%   (0/23)0%   (0/12)
parseTYPDEFNAM (): void 100% (1/1)100% (10/10)100% (3/3)
parseTYPDEFOVR (): void 100% (1/1)78%  (50/64)82%  (17.2/21)
parseTypdefsOrMgrlvlovrs (): int 100% (1/1)30%  (13/44)36%  (4.7/13)
parseUOWDSP (): int 100% (1/1)78%  (14/18)80%  (4/5)
parseUSRID (boolean): String 0%   (0/1)0%   (0/12)0%   (0/5)
parseVALNSPRM (): void 0%   (0/1)0%   (0/94)0%   (0/33)
parseXARETVAL (): int 0%   (0/1)0%   (0/2)0%   (0/1)
parseXID (): Xid 0%   (0/1)0%   (0/2)0%   (0/1)
parseXIDCNT (): int 0%   (0/1)0%   (0/6)0%   (0/2)
readAccessDatabase (Connection): void 100% (1/1)100% (12/12)100% (5/5)
readAccessSecurity (Connection, int): void 100% (1/1)100% (13/13)100% (5/5)
readCommitSubstitute (ConnectionCallbackInterface): void 0%   (0/1)0%   (0/9)0%   (0/4)
readDummyExchangeServerAttributes (Connection): void 0%   (0/1)0%   (0/12)0%   (0/5)
readExchangeServerAttributes (Connection): void 100% (1/1)100% (12/12)100% (5/5)
readLocalCommit (ConnectionCallbackInterface): void 100% (1/1)100% (8/8)100% (4/4)
readLocalRollback (ConnectionCallbackInterface): void 100% (1/1)100% (8/8)100% (4/4)
readLocalXACommit (ConnectionCallbackInterface): void 0%   (0/1)0%   (0/1)0%   (0/1)
readLocalXARollback (ConnectionCallbackInterface): void 0%   (0/1)0%   (0/1)0%   (0/1)
readLocalXAStart (ConnectionCallbackInterface): void 0%   (0/1)0%   (0/1)0%   (0/1)
readSecurityCheck (Connection): void 100% (1/1)100% (12/12)100% (5/5)
readXaCommit (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
readXaEndUnitOfWork (NetConnection): int 0%   (0/1)0%   (0/2)0%   (0/1)
readXaForget (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
readXaPrepare (NetConnection): int 0%   (0/1)0%   (0/2)0%   (0/1)
readXaRecover (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
readXaRollback (NetConnection): int 0%   (0/1)0%   (0/2)0%   (0/1)
readXaStartUnitOfWork (NetConnection): void 0%   (0/1)0%   (0/1)0%   (0/1)
resetRowsetSqlca (Sqlca [], int): void 0%   (0/1)0%   (0/19)0%   (0/4)
skipFastNVCMorNVCS (): void 0%   (0/1)0%   (0/43)0%   (0/13)
verifyConnectReply (int): void 0%   (0/1)0%   (0/35)0%   (0/13)
verifyDeferredReset (): void 0%   (0/1)0%   (0/24)0%   (0/10)

1/*
2 
3   Derby - Class org.apache.derby.client.net.NetConnectionReply
4 
5   Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors, where applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19*/
20 
21package org.apache.derby.client.net;
22 
23import javax.transaction.xa.Xid;
24 
25import org.apache.derby.client.am.Connection;
26import org.apache.derby.client.am.ConnectionCallbackInterface;
27import org.apache.derby.client.am.DisconnectException;
28import org.apache.derby.client.am.SqlException;
29import org.apache.derby.client.am.ClientMessageId;
30import org.apache.derby.client.am.Sqlca;
31import java.io.UnsupportedEncodingException;
32 
33import org.apache.derby.shared.common.reference.SQLState;
34import org.apache.derby.shared.common.reference.MessageId;
35import org.apache.derby.shared.common.i18n.MessageUtil;
36 
37 
38public class NetConnectionReply extends Reply
39        implements ConnectionReplyInterface {
40    private static MessageUtil msgutil_ = SqlException.getMessageUtil();
41    
42    NetConnectionReply(NetAgent netAgent, int bufferSize) {
43        super(netAgent, bufferSize);
44    }
45 
46    // NET only entry point
47    void readExchangeServerAttributes(Connection connection) throws SqlException {
48        startSameIdChainParse();
49        parseEXCSATreply((NetConnection) connection);
50        endOfSameIdChainData();
51        agent_.checkForChainBreakingException_();
52    }
53 
54    void verifyDeferredReset() throws SqlException {
55        readDssHeader();
56        verifyConnectReply(CodePoint.EXCSATRD);
57        readDssHeader();
58        verifyConnectReply(CodePoint.ACCSECRD);
59        readDssHeader();
60        verifyConnectReply(CodePoint.SECCHKRM);
61        readDssHeader();
62        verifyConnectReply(CodePoint.ACCRDBRM);
63        agent_.checkForChainBreakingException_();
64    }
65 
66    void verifyConnectReply(int codept) throws SqlException {
67        if (peekCodePoint() != codept) {
68            parseConnectError();
69            return;
70        }
71        readLengthAndCodePoint();
72        skipBytes();
73 
74        if (codept == CodePoint.ACCRDBRM) {
75            int peekCP = peekCodePoint();
76            if (peekCP == Reply.END_OF_SAME_ID_CHAIN) {
77                return;
78            }
79 
80            parseTypdefsOrMgrlvlovrs();
81            NetSqlca netSqlca = parseSQLCARD(null);
82            netAgent_.netConnection_.completeSqlca(netSqlca);
83        }
84    }
85 
86    void parseConnectError() throws DisconnectException {
87        int peekCP = peekCodePoint();
88        switch (peekCP) {
89        case CodePoint.CMDCHKRM:
90            parseCMDCHKRM();
91            break;
92        case CodePoint.MGRLVLRM:
93            parseMGRLVLRM();
94            break;
95        default:
96            parseCommonError(peekCP);
97        }
98    }
99 
100    void readDummyExchangeServerAttributes(Connection connection) throws SqlException {
101        startSameIdChainParse();
102        parseDummyEXCSATreply((NetConnection) connection);
103        endOfSameIdChainData();
104        agent_.checkForChainBreakingException_();
105    }
106 
107    // NET only entry point
108    void readAccessSecurity(Connection connection,
109                            int securityMechanism) throws SqlException {
110        startSameIdChainParse();
111        parseACCSECreply((NetConnection) connection, securityMechanism);
112        endOfSameIdChainData();
113        agent_.checkForChainBreakingException_();
114    }
115 
116    // NET only entry point
117    void readSecurityCheck(Connection connection) throws SqlException {
118        startSameIdChainParse();
119        parseSECCHKreply((NetConnection) connection);
120        endOfSameIdChainData();
121        agent_.checkForChainBreakingException_();
122    }
123 
124    // NET only entry point
125    void readAccessDatabase(Connection connection) throws SqlException {
126        startSameIdChainParse();
127        parseACCRDBreply((NetConnection) connection);
128        endOfSameIdChainData();
129        agent_.checkForChainBreakingException_();
130    }
131 
132 
133    public void readCommitSubstitute(ConnectionCallbackInterface connection) throws DisconnectException {
134        startSameIdChainParse();
135        parseDummyEXCSATreply((NetConnection) connection);
136        endOfSameIdChainData();
137    }
138 
139    public void readLocalCommit(ConnectionCallbackInterface connection) throws DisconnectException {
140        startSameIdChainParse();
141        parseRDBCMMreply(connection);
142        endOfSameIdChainData();
143    }
144 
145    public void readLocalRollback(ConnectionCallbackInterface connection) throws DisconnectException {
146        startSameIdChainParse();
147        parseRDBRLLBCKreply(connection);
148        endOfSameIdChainData();
149    }
150 
151 
152    public void readLocalXAStart(ConnectionCallbackInterface connection) throws DisconnectException {
153    }
154 
155    public void readLocalXACommit(ConnectionCallbackInterface connection) throws DisconnectException {
156    }
157 
158    public void readLocalXARollback(ConnectionCallbackInterface connection) throws DisconnectException {
159    }
160 
161 
162    protected void readXaStartUnitOfWork(NetConnection conn) throws DisconnectException {
163    }
164 
165    protected int readXaEndUnitOfWork(NetConnection conn) throws DisconnectException {
166        return 0;
167    }
168 
169    protected int readXaPrepare(NetConnection conn) throws DisconnectException {
170        return 0;
171    }
172 
173    protected void readXaCommit(NetConnection conn) throws DisconnectException {
174    }
175 
176    protected int readXaRollback(NetConnection conn) throws DisconnectException {
177        return 0;
178    }
179 
180    protected void readXaRecover(NetConnection conn) throws DisconnectException {
181    }
182 
183    protected void readXaForget(NetConnection conn) throws DisconnectException {
184    }
185 
186 
187    //------------------parse reply for specific command--------------------------
188    // These methods are "private protected", which is not a recognized java privilege,
189    // but means that these methods are private to this class and to subclasses,
190    // and should not be used as package-wide friendly methods.
191 
192    // Parse the reply for the RDB Commit Unit of Work Command.
193    // This method handles the parsing of all command replies and reply data
194    // for the rdbcmm command.
195    private void parseRDBCMMreply(ConnectionCallbackInterface connection) throws DisconnectException {
196        int peekCP = parseTypdefsOrMgrlvlovrs();
197 
198        if (peekCP != CodePoint.ENDUOWRM && peekCP != CodePoint.SQLCARD) {
199            parseCommitError(connection);
200            return;
201        }
202 
203        if (peekCP == CodePoint.ENDUOWRM) {
204            parseENDUOWRM(connection);
205            peekCP = parseTypdefsOrMgrlvlovrs();
206        }
207 
208        NetSqlca netSqlca = parseSQLCARD(null);
209        connection.completeSqlca(netSqlca);
210    }
211 
212    // Parse the reply for the RDB Rollback Unit of Work Command.
213    // This method handles the parsing of all command replies and reply data
214    // for the rdbrllbck command.
215    private void parseRDBRLLBCKreply(ConnectionCallbackInterface connection) throws DisconnectException {
216        int peekCP = parseTypdefsOrMgrlvlovrs();
217        if (peekCP != CodePoint.ENDUOWRM) {
218            parseRollbackError();
219            return;
220        }
221 
222        parseENDUOWRM(connection);
223        peekCP = parseTypdefsOrMgrlvlovrs();
224 
225        NetSqlca netSqlca = parseSQLCARD(null);
226        connection.completeSqlca(netSqlca);
227    }
228 
229    // Parse the reply for the Exchange Server Attributes Command.
230    // This method handles the parsing of all command replies and reply data
231    // for the excsat command.
232    private void parseEXCSATreply(NetConnection netConnection) throws DisconnectException {
233        if (peekCodePoint() != CodePoint.EXCSATRD) {
234            parseExchangeServerAttributesError();
235            return;
236        }
237        parseEXCSATRD(netConnection);
238    }
239 
240    // Parse the reply for the Exchange Server Attributes Command (Dummy)
241    // This method handles the parsing of all command replies and reply data
242    // for the excsat command.
243    private void parseDummyEXCSATreply(NetConnection netConnection) throws DisconnectException {
244        if (peekCodePoint() != CodePoint.EXCSATRD) {
245            parseExchangeServerAttributesError();
246            return;
247        }
248        parseDummyEXCSATRD(netConnection);
249    }
250 
251    // Parse the reply for the Access Security Command.
252    // This method handles the parsing of all command replies and reply data
253    // for the accsec command.
254    private void parseACCSECreply(NetConnection netConnection, int securityMechanism) throws DisconnectException {
255        int peekCP = peekCodePoint();
256        if (peekCP != CodePoint.ACCSECRD) {
257            parseAccessSecurityError(netConnection);
258            return;
259        }
260        parseACCSECRD(netConnection, securityMechanism);
261 
262        peekCP = peekCodePoint();
263        if (peekCP == Reply.END_OF_SAME_ID_CHAIN) {
264            return;
265        }
266 
267    }
268 
269    // Parse the reply for the Security Check Command.
270    // This method handles the parsing of all command replies and reply data
271    // for the secchk command.
272    private void parseSECCHKreply(NetConnection netConnection) throws DisconnectException {
273        if (peekCodePoint() != CodePoint.SECCHKRM) {
274            parseSecurityCheckError(netConnection);
275            return;
276        }
277 
278        parseSECCHKRM(netConnection);
279        if (peekCodePoint() == CodePoint.SECTKN) {
280            // rpydta used only if the security mechanism returns
281            // a security token that must be sent back to the source system.
282            // this is only used for DCSSEC.  In the case of DCESEC,
283            // the sectkn must be returned as reply data if DCE is using
284            // mutual authentication.
285            // Need to double check what to map this to.  This is probably
286            // incorrect but consider it a conversation protocol error
287            // 0x03 - OBJDSS sent when not allowed.
288            //parseSECTKN (true);
289            boolean done = false;
290            byte[] bytes = parseSECTKN(false);
291        }
292    }
293 
294    // Parse the reply for the Access RDB Command.
295    // This method handles the parsing of all command replies and reply data
296    // for the accrdb command.
297    private void parseACCRDBreply(NetConnection netConnection) throws DisconnectException {
298        int peekCP = peekCodePoint();
299        if (peekCP != CodePoint.ACCRDBRM) {
300            parseAccessRdbError(netConnection);
301            return;
302        }
303 
304        parseACCRDBRM(netConnection);
305        peekCP = peekCodePoint();
306        if (peekCP == Reply.END_OF_SAME_ID_CHAIN) {
307            return;
308        }
309 
310        parseTypdefsOrMgrlvlovrs();
311        NetSqlca netSqlca = parseSQLCARD(null);
312        netConnection.completeSqlca(netSqlca);
313    }
314 
315 
316    protected int parseTypdefsOrMgrlvlovrs() throws DisconnectException {
317        boolean targetTypedefCloned = false;
318        while (true) {
319            int peekCP = peekCodePoint();
320            if (peekCP == CodePoint.TYPDEFNAM) {
321                if (!targetTypedefCloned) {
322                    netAgent_.targetTypdef_ = (Typdef) netAgent_.targetTypdef_.clone();
323                    targetTypedefCloned = true;
324                }
325                parseTYPDEFNAM();
326            } else if (peekCP == CodePoint.TYPDEFOVR) {
327                if (!targetTypedefCloned) {
328                    netAgent_.targetTypdef_ = (Typdef) netAgent_.targetTypdef_.clone();
329                    targetTypedefCloned = true;
330                }
331                parseTYPDEFOVR();
332            } else {
333                return peekCP;
334            }
335        }
336    }
337 
338 
339    //-----------------------------parse DDM Reply Messages-----------------------
340 
341    protected void parseCommitError(ConnectionCallbackInterface connection) throws DisconnectException {
342        int peekCP = peekCodePoint();
343        switch (peekCP) {
344        case CodePoint.ABNUOWRM:
345            NetSqlca sqlca = parseAbnormalEndUow(connection);
346            connection.completeSqlca(sqlca);
347            break;
348        case CodePoint.CMDCHKRM:
349            parseCMDCHKRM();
350            break;
351        case CodePoint.RDBNACRM:
352            parseRDBNACRM();
353            break;
354        default:
355            parseCommonError(peekCP);
356            break;
357        }
358    }
359 
360    void parseRollbackError() throws DisconnectException {
361        int peekCP = peekCodePoint();
362        switch (peekCP) {
363        case CodePoint.CMDCHKRM:
364            parseCMDCHKRM();
365            break;
366        case CodePoint.RDBNACRM:
367            parseRDBNACRM();
368            break;
369        default:
370            parseCommonError(peekCP);
371            break;
372        }
373    }
374 
375    void parseExchangeServerAttributesError() throws DisconnectException {
376        int peekCP = peekCodePoint();
377        switch (peekCP) {
378        case CodePoint.CMDCHKRM:
379            parseCMDCHKRM();
380            break;
381        case CodePoint.MGRLVLRM:
382            parseMGRLVLRM();
383            break;
384        default:
385            parseCommonError(peekCP);
386        }
387    }
388 
389    void parseAccessSecurityError(NetConnection netConnection) throws DisconnectException {
390        int peekCP = peekCodePoint();
391        switch (peekCP) {
392        case CodePoint.CMDCHKRM:
393            parseCMDCHKRM();
394            break;
395        case CodePoint.RDBNFNRM:
396            parseRDBNFNRM(netConnection);
397            break;
398        case CodePoint.RDBAFLRM:
399            parseRdbAccessFailed(netConnection);
400            break;
401        default:
402            parseCommonError(peekCP);
403        }
404    }
405 
406    void parseSecurityCheckError(NetConnection netConnection) throws DisconnectException {
407        int peekCP = peekCodePoint();
408        switch (peekCP) {
409        case CodePoint.CMDCHKRM:
410            parseCMDCHKRM();
411            break;
412        case CodePoint.OBJNSPRM:
413            parseOBJNSPRM();
414            break;
415        case CodePoint.RDBNFNRM:
416            parseRDBNFNRM(netConnection);
417            break;
418        case CodePoint.RDBAFLRM:
419            parseRdbAccessFailed(netConnection);
420            break;
421        default:
422            parseCommonError(peekCP);
423        }
424    }
425 
426    void parseAccessRdbError(NetConnection netConnection) throws DisconnectException {
427        int peekCP = peekCodePoint();
428        switch (peekCP) {
429        case CodePoint.CMDCHKRM:
430            parseCMDCHKRM();
431            break;
432        case CodePoint.RDBACCRM:
433            parseRDBACCRM();
434            break;
435        case CodePoint.RDBAFLRM:
436            parseRdbAccessFailed(netConnection);
437            break;
438        case CodePoint.RDBATHRM:
439            parseRDBATHRM(netConnection);
440            break;
441        case CodePoint.RDBNFNRM:
442            parseRDBNFNRM(netConnection);
443            break;
444        default:
445            parseCommonError(peekCP);
446        }
447    }
448 
449 
450    // Called by all the NET*Reply classes.
451    void parseCommonError(int peekCP) throws DisconnectException {
452        switch (peekCP) {
453        case CodePoint.CMDNSPRM:
454            parseCMDNSPRM();
455            break;
456        case CodePoint.PRCCNVRM:
457            parsePRCCNVRM();
458            break;
459        case CodePoint.SYNTAXRM:
460            parseSYNTAXRM();
461            break;
462        case CodePoint.VALNSPRM:
463            parseVALNSPRM();
464            break;
465        default:
466            doObjnsprmSemantics(peekCP);
467        }
468    }
469 
470    NetSqlca parseAbnormalEndUow(ConnectionCallbackInterface connection) throws DisconnectException {
471        parseABNUOWRM(connection);
472        if (peekCodePoint() != CodePoint.SQLCARD) {
473            parseTypdefsOrMgrlvlovrs();
474        }
475 
476        NetSqlca netSqlca = parseSQLCARD(null);
477        return netSqlca;
478    }
479 
480    void parseRdbAccessFailed(NetConnection netConnection) throws DisconnectException {
481        parseRDBAFLRM();
482 
483        // an SQLCARD is returned if an RDBALFRM is returned.
484        // this SQLCARD always follows the RDBALFRM.
485        // TYPDEFNAM and TYPDEFOVR are MTLINC
486 
487        if (peekCodePoint() == CodePoint.TYPDEFNAM) {
488            parseTYPDEFNAM();
489            parseTYPDEFOVR();
490        } else {
491            parseTYPDEFOVR();
492            parseTYPDEFNAM();
493        }
494 
495        NetSqlca netSqlca = parseSQLCARD(null);
496        
497        //Check if the SQLCARD has null SQLException
498        if(netSqlca.getSqlErrmc() == null)
499                netConnection.setConnectionNull(true);
500        else
501                netConnection.completeSqlca(netSqlca);
502    }
503 
504 
505    // The Security Check (SECCHKRM) Reply Message indicates the acceptability
506    // of the security information.
507    // this method returns the security check code. it is up to the caller to check
508    // the value of this return code and take the appropriate action.
509    //
510    // Returned from Server:
511    // SVRCOD - required  (0 - INFO, 8 - ERROR, 16 -SEVERE)
512    // SECCHKCD - required
513    // SECTKN - optional, ignorable
514    // SVCERRNO - optional
515    private void parseSECCHKRM(NetConnection netConnection) throws DisconnectException {
516        boolean svrcodReceived = false;
517        int svrcod = CodePoint.SVRCOD_INFO;
518        boolean secchkcdReceived = false;
519        int secchkcd = CodePoint.SECCHKCD_00;
520        boolean sectknReceived = false;
521        byte[] sectkn = null;
522 
523        parseLengthAndMatchCodePoint(CodePoint.SECCHKRM);
524        pushLengthOnCollectionStack();
525        int peekCP = peekCodePoint();
526 
527        while (peekCP != Reply.END_OF_COLLECTION) {
528 
529            boolean foundInPass = false;
530 
531            if (peekCP == CodePoint.SVRCOD) {
532                // severity code.  it's value is dictated by the SECCHKCD.
533                // right now it will not be checked that it is the correct value
534                // for the SECCHKCD.  maybe this will be done in the future.
535                foundInPass = true;
536                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
537                svrcod = parseSVRCOD(CodePoint.SVRCOD_INFO, CodePoint.SVRCOD_SEVERE);
538                peekCP = peekCodePoint();
539            }
540 
541            if (peekCP == CodePoint.SECCHKCD) {
542                // security check code. this specifies the state of the security information.
543                // there is a relationship between this value and the SVRCOD value.
544                // right now this driver will not check these values against each other.
545                foundInPass = true;
546                secchkcdReceived = checkAndGetReceivedFlag(secchkcdReceived);
547                secchkcd = parseSECCHKCD();
548                peekCP = peekCodePoint();
549            }
550 
551            if (peekCP == CodePoint.SECTKN) {
552                // security token.
553                // used when mutual authentication of the source and target servers
554                // is requested.  The architecture lists this as an instance variable
555                // and also says that the SECTKN flows as reply data to the secchk cmd and
556                // it must flow after the secchkrm message.  Right now this driver doesn't
557                // support ay mutual authentication so it will be ignored (it is listed
558                // as an ignorable instance variable in the ddm manual).
559                foundInPass = true;
560                sectknReceived = checkAndGetReceivedFlag(sectknReceived);
561                sectkn = parseSECTKN(true);
562                peekCP = peekCodePoint();
563            }
564 
565            if (!foundInPass) {
566                doPrmnsprmSemantics(peekCP);
567            }
568 
569        }
570        popCollectionStack();
571        // check for the required instance variables.
572        checkRequiredObjects(svrcodReceived, secchkcdReceived);
573 
574        netConnection.securityCheckComplete(svrcod, secchkcd);
575    }
576 
577 
578    // Access to RDB Completed (ACRDBRM) Reply Message specifies that an
579    // instance of the SQL application manager has been created and is bound
580    // to the specified relation database (RDB).
581    //
582    // Returned from Server:
583    // SVRCOD - required  (0 - INFO, 4 - WARNING)
584    // PRDID - required
585    // TYPDEFNAM - required (MINLVL 4) (QTDSQLJVM)
586    // TYPDEFOVR - required
587    // RDBINTTKN - optional
588    // CRRTKN - optional
589    // USRID - optional
590    // SRVLST - optional (MINLVL 5)
591    private void parseACCRDBRM(NetConnection netConnection) throws DisconnectException {
592        boolean svrcodReceived = false;
593        int svrcod = CodePoint.SVRCOD_INFO;
594        boolean prdidReceived = false;
595        String prdid = null;
596        boolean typdefnamReceived = false;
597        boolean typdefovrReceived = false;
598        boolean rdbinttknReceived = false;
599        boolean crrtknReceived = false;
600        byte[] crrtkn = null;
601        boolean usridReceived = false;
602        String usrid = null;
603 
604        parseLengthAndMatchCodePoint(CodePoint.ACCRDBRM);
605        pushLengthOnCollectionStack();
606        int peekCP = peekCodePoint();
607 
608        while (peekCP != Reply.END_OF_COLLECTION) {
609 
610            boolean foundInPass = false;
611 
612            if (peekCP == CodePoint.SVRCOD) {
613                // severity code.  If the target SQLAM cannot support the typdefovr
614                // parameter values specified for the double-byte and mixed-byte CCSIDs
615                // on the corresponding ACCRDB command, then the severity code WARNING
616                // is specified on the ACCRDBRM.
617                foundInPass = true;
618                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
619                svrcod = parseSVRCOD(CodePoint.SVRCOD_INFO, CodePoint.SVRCOD_WARNING);
620                peekCP = peekCodePoint();
621            }
622 
623            // this is the product release level of the target RDB server.
624            if (peekCP == CodePoint.PRDID) {
625                foundInPass = true;
626                prdidReceived = checkAndGetReceivedFlag(prdidReceived);
627                prdid = parsePRDID(false); // false means do not skip the bytes
628                peekCP = peekCodePoint();
629            }
630 
631            if (peekCP == CodePoint.TYPDEFNAM) {
632                // this is the name of the data type to the data representation mapping
633                // definitions tha the target SQLAM uses when sending reply data objects.
634                foundInPass = true;
635                typdefnamReceived = checkAndGetReceivedFlag(typdefnamReceived);
636                parseTYPDEFNAM();
637                peekCP = peekCodePoint();
638            }
639 
640            if (peekCP == CodePoint.TYPDEFOVR) {
641                // this is the single-byte, double-byte, and mixed-byte CCSIDs of the
642                // scalar data arrays (SDA) in the identified data type to data representation
643                // mapping definitions.
644                foundInPass = true;
645                typdefovrReceived = checkAndGetReceivedFlag(typdefovrReceived);
646                parseTYPDEFOVR();
647                peekCP = peekCodePoint();
648            }
649 
650 
651            if (peekCP == CodePoint.USRID) {
652                // specifies the target defined user ID.  It is returned if the value of
653                // TRGDFTRT is TRUE in ACCRDB.  Right now this driver always sets this
654                // value to false so this should never get returned here.
655                // if it is returned, it could be considered an error but for now
656                // this driver will just skip the bytes.
657                foundInPass = true;
658                usridReceived = checkAndGetReceivedFlag(usridReceived);
659                usrid = parseUSRID(true);
660                peekCP = peekCodePoint();
661            }
662 
663            if (peekCP == CodePoint.CRRTKN) {
664                // carries information to correlate with the work being done on bahalf
665                // of an application at the source and at the target server.
666                // defualt value is ''.
667                // this parameter is only retunred if an only if the CRRTKN parameter
668                // is not received on ACCRDB.  We will rely on server to send us this
669                // in ACCRDBRM
670                foundInPass = true;
671                crrtknReceived = checkAndGetReceivedFlag(crrtknReceived);
672                crrtkn = parseCRRTKN(false);
673                peekCP = peekCodePoint();
674            }
675 
676 
677            if (!foundInPass) {
678                doPrmnsprmSemantics(peekCP);
679            }
680        }
681        popCollectionStack();
682        // check for the required instance variables.
683        checkRequiredObjects(svrcodReceived,
684                prdidReceived,
685                typdefnamReceived,
686                typdefovrReceived);
687 
688        netConnection.rdbAccessed(svrcod,
689                prdid,
690                crrtknReceived,
691                crrtkn);
692    }
693 
694 
695    // The End Unit of Work Condition (ENDUOWRM) Reply Mesage specifies
696    // that the unit of work has ended as a result of the last command.
697    //
698    // Returned from Server:
699    //   SVRCOD - required  (4 WARNING)
700    //   UOWDSP - required
701    //   RDBNAM - optional
702    void parseENDUOWRM(ConnectionCallbackInterface connection) throws DisconnectException {
703        boolean svrcodReceived = false;
704        int svrcod = CodePoint.SVRCOD_INFO;
705        boolean uowdspReceived = false;
706        int uowdsp = 0;
707        boolean rdbnamReceived = false;
708        String rdbnam = null;
709 
710        parseLengthAndMatchCodePoint(CodePoint.ENDUOWRM);
711        pushLengthOnCollectionStack();
712        int peekCP = peekCodePoint();
713 
714        while (peekCP != Reply.END_OF_COLLECTION) {
715 
716            boolean foundInPass = false;
717 
718            if (peekCP == CodePoint.SVRCOD) {
719                foundInPass = true;
720                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
721                svrcod = parseSVRCOD(CodePoint.SVRCOD_WARNING, CodePoint.SVRCOD_WARNING);
722                peekCP = peekCodePoint();
723            }
724 
725            if (peekCP == CodePoint.UOWDSP) {
726                foundInPass = true;
727                uowdspReceived = checkAndGetReceivedFlag(uowdspReceived);
728                uowdsp = parseUOWDSP();
729                peekCP = peekCodePoint();
730            }
731 
732            if (peekCP == CodePoint.RDBNAM) {
733                foundInPass = true;
734                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
735                rdbnam = parseRDBNAM(true);
736                peekCP = peekCodePoint();
737            }
738 
739 
740            if (!foundInPass) {
741                doPrmnsprmSemantics(peekCP);
742            }
743        }
744        popCollectionStack();
745        checkRequiredObjects(svrcodReceived, uowdspReceived);
746 
747        netAgent_.setSvrcod(svrcod);
748        if (uowdsp == CodePoint.UOWDSP_COMMIT) {
749            connection.completeLocalCommit();
750        } else {
751            connection.completeLocalRollback();
752        }
753    }
754 
755    // Command Check Reply Message indicates that the requested
756    // command encountered an unarchitected and implementation-specific
757    // condition for which there is no architected message.  If the severity
758    // code value is ERROR or greater, the command has failed.  The
759    // message can be accompanied by other messages that help to identify
760    // the specific condition.
761    // The CMDCHKRM should not be used as a general catch-all in place of
762    // product-defined messages when using product extensions to DDM.
763    // PROTOCOL architects the SQLSTATE value depending on SVRCOD
764    // SVRCOD 0 -> SQLSTATE is not returned
765    // SVRCOD 8 -> SQLSTATE of 58008 or 58009
766    // SVRCOD 16,32,64,128 -> SQLSTATE of 58009
767    //
768    // Messages
769    //   SQLSTATE : 58009
770    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
771    //     SQLCODE : -30020
772    //     Execution failed because of a Distributed Protocol
773    //       Error that will affect the successful execution of subsequent
774    //       commands and SQL statements: Reason Code <reason-code>.
775    //     Some possible reason codes include:
776    //       121C Indicates that the user is not authorized to perform the requested command.
777    //       1232 The command could not be completed because of a permanent error.
778    //         In most cases, the server will be in the process of an abend.
779    //       220A The target server has received an invalid data description.
780    //         If a user SQLDA is specified, ensure that the fields are
781    //         initialized correctly. Also, ensure that the length does not
782    //         exceed the maximum allowed length for the data type being used.
783    //
784    // The command or statement cannot be processed.  The current
785    // transaction is rolled back and the application is disconnected
786    //  from the remote database.
787    //
788    //
789    // Returned from Server:
790    //   SVRCOD - required  (0 - INFO, 4 - WARNING, 8 - ERROR, 16 - SEVERE,
791    //                       32 - ACCDMG, 64 - PRMDMG, 128 - SESDMG))
792    //   RDBNAM - optional (MINLVL 3)
793    //   RECCNT - optional (MINVAL 0, MINLVL 3)
794    //
795    // Called by all the Reply classesCMDCHKRM
796    protected void parseCMDCHKRM() throws DisconnectException {
797        boolean svrcodReceived = false;
798        int svrcod = CodePoint.SVRCOD_INFO;
799        boolean rdbnamReceived = false;
800        String rdbnam = null;
801        parseLengthAndMatchCodePoint(CodePoint.CMDCHKRM);
802        pushLengthOnCollectionStack();
803        int peekCP = peekCodePoint();
804 
805        while (peekCP != Reply.END_OF_COLLECTION) {
806 
807            boolean foundInPass = false;
808 
809            if (peekCP == CodePoint.SVRCOD) {
810                foundInPass = true;
811                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
812                svrcod = parseSVRCOD(CodePoint.SVRCOD_INFO, CodePoint.SVRCOD_SESDMG);
813                peekCP = peekCodePoint();
814            }
815 
816            if (peekCP == CodePoint.RDBNAM) {
817                foundInPass = true;
818                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
819                rdbnam = parseRDBNAM(true);
820                peekCP = peekCodePoint();
821            }
822            // skip over the RECCNT since it can't be found in the DDM book.
823 
824            if (peekCP == 0x115C) {
825                foundInPass = true;
826                parseLengthAndMatchCodePoint(0x115C);
827                skipBytes();
828                peekCP = peekCodePoint();
829            }
830 
831            if (!foundInPass) {
832                doPrmnsprmSemantics(peekCP);
833            }
834 
835        }
836        popCollectionStack();
837        checkRequiredObjects(svrcodReceived);
838 
839        netAgent_.setSvrcod(svrcod);
840        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
841            new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
842            msgutil_.getTextMessage(MessageId.CONN_DRDA_CMDCHKRM)));
843    }
844 
845 
846    // RDB Not Accessed Reply Message indicates that the access relational
847    // database command (ACCRDB) was not issued prior to a command
848    // requesting the RDB Services.
849    // PROTOCOL Architects an SQLSTATE of 58008 or 58009.
850    //
851    // Messages
852    // SQLSTATE : 58009
853    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
854    //     SQLCODE : -30020
855    //     Execution failed because of a Distributed Protocol
856    //         Error that will affect the successful execution of subsequent
857    //         commands and SQL statements: Reason Code <reason-code>.
858    //      Some possible reason codes include:
859    //      121C Indicates that the user is not authorized to perform the requested command.
860    //      1232 The command could not be completed because of a permanent error.
861    //          In most cases, the server will be in the process of an abend.
862    //      220A The target server has received an invalid data description.
863    //          If a user SQLDA is specified, ensure that the fields are
864    //          initialized correctly. Also, ensure that the length does not
865    //          exceed the maximum allowed length for the data type being used.
866    //
867    //      The command or statement cannot be processed.  The current
868    //      transaction is rolled back and the application is disconnected
869    //      from the remote database.
870    //
871    //
872    // Returned from Server:
873    // SVRCOD - required  (8 - ERROR)
874    // RDBNAM - required
875    //
876    // Called by all the NET*Reply classes.
877    void parseRDBNACRM() throws DisconnectException {
878        boolean svrcodReceived = false;
879        int svrcod = CodePoint.SVRCOD_INFO;
880        boolean rdbnamReceived = false;
881        String rdbnam = null;
882 
883        parseLengthAndMatchCodePoint(CodePoint.RDBNACRM);
884        pushLengthOnCollectionStack();
885        int peekCP = peekCodePoint();
886 
887        while (peekCP != Reply.END_OF_COLLECTION) {
888 
889            boolean foundInPass = false;
890 
891            if (peekCP == CodePoint.SVRCOD) {
892                foundInPass = true;
893                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
894                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
895                peekCP = peekCodePoint();
896            }
897 
898            if (peekCP == CodePoint.RDBNAM) {
899                foundInPass = true;
900                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
901                rdbnam = parseRDBNAM(true);
902                peekCP = peekCodePoint();
903            }
904 
905            if (!foundInPass) {
906                doPrmnsprmSemantics(peekCP);
907            }
908 
909        }
910        popCollectionStack();
911        checkRequiredObjects(svrcodReceived, rdbnamReceived);
912 
913        netAgent_.setSvrcod(svrcod);
914        agent_.accumulateChainBreakingReadExceptionAndThrow(
915            new DisconnectException(agent_,
916                new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
917                msgutil_.getTextMessage(MessageId.CONN_DRDA_RDBNACRM)));            
918    }
919 
920    // RDB Not Found Reply Message indicates that the target
921    // server cannot find the specified relational database.
922    // PROTOCOL architects an SQLSTATE of 08004.
923    //
924    // Messages
925    // SQLSTATE : 8004
926    //     The application server rejected establishment of the connection.
927    //     SQLCODE : -30061
928    //     The database alias or database name <name> was not found at the remote node.
929    //     The statement cannot be processed.
930    //
931    //
932    // Returned from Server:
933    // SVRCOD - required  (8 - ERROR)
934    // RDBNAM - required
935    //
936    private void parseRDBNFNRM(NetConnection netConnection) throws DisconnectException {
937        boolean svrcodReceived = false;
938        int svrcod = CodePoint.SVRCOD_INFO;
939        boolean rdbnamReceived = false;
940        String rdbnam = null;
941 
942        parseLengthAndMatchCodePoint(CodePoint.RDBNFNRM);
943        pushLengthOnCollectionStack();
944        int peekCP = peekCodePoint();
945 
946        while (peekCP != Reply.END_OF_COLLECTION) {
947 
948            boolean foundInPass = false;
949 
950            if (peekCP == CodePoint.SVRCOD) {
951                foundInPass = true;
952                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
953                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
954                peekCP = peekCodePoint();
955            }
956 
957            if (peekCP == CodePoint.RDBNAM) {
958                foundInPass = true;
959                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
960                rdbnam = parseRDBNAM(true);
961                peekCP = peekCodePoint();
962            }
963 
964 
965            if (!foundInPass) {
966                doPrmnsprmSemantics(peekCP);
967            }
968 
969        }
970        popCollectionStack();
971        checkRequiredObjects(svrcodReceived, rdbnamReceived);
972 
973        netAgent_.setSvrcod(svrcod);
974        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
975            new ClientMessageId(SQLState.NET_DATABASE_NOT_FOUND),
976            netConnection.databaseName_));
977    }
978 
979 
980    // Not Authorized to RDB Reply Message specifies that
981    // the requester is not authorized to access the specified
982    // relational database.
983    // PROTOCOL architects an SQLSTATE of 08004
984    //
985    // Messages
986    // SQLSTATE : 8004
987    //     Authorization ID <authorization-ID> attempted to perform the specified
988    //     <operation> without having been granted the proper authorization to do so.
989    //     SQLCODE : -30060
990    //      <authorization-ID> does not have the privilege to perform operation <operation>.
991    //
992    //
993    // Returned from Server:
994    // SVRCOD - required  (8 - ERROR)
995    // RDBNAM - required
996    //
997    private void parseRDBATHRM(NetConnection netConnection) throws DisconnectException {
998        boolean svrcodReceived = false;
999        int svrcod = CodePoint.SVRCOD_INFO;
1000        boolean rdbnamReceived = false;
1001        String rdbnam = null;
1002 
1003        parseLengthAndMatchCodePoint(CodePoint.RDBATHRM);
1004        pushLengthOnCollectionStack();
1005        int peekCP = peekCodePoint();
1006 
1007        while (peekCP != Reply.END_OF_COLLECTION) {
1008 
1009            boolean foundInPass = false;
1010 
1011            if (peekCP == CodePoint.SVRCOD) {
1012                foundInPass = true;
1013                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1014                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1015                peekCP = peekCodePoint();
1016            }
1017 
1018            if (peekCP == CodePoint.RDBNAM) {
1019                foundInPass = true;
1020                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1021                rdbnam = parseRDBNAM(true);
1022                peekCP = peekCodePoint();
1023            }
1024 
1025            if (!foundInPass) {
1026                doPrmnsprmSemantics(peekCP);
1027            }
1028 
1029        }
1030        popCollectionStack();
1031        checkRequiredObjects(svrcodReceived, rdbnamReceived);
1032 
1033        netAgent_.setSvrcod(svrcod);
1034        netAgent_.accumulateReadException(new SqlException(agent_.logWriter_,
1035            new ClientMessageId(SQLState.NET_CONNECT_AUTH_FAILED),
1036            msgutil_.getTextMessage(MessageId.CONN_USER_NOT_AUTHORIZED_TO_DB)));
1037    }
1038 
1039    // Data Stream Syntax Error Reply Message indicates that the data
1040    // sent to the target agent does not structurally conform to the requirements
1041    // of the DDM architecture.  The target agent terminated paring of the DSS
1042    // when the condition SYNERRCD specified was detected.
1043    // PROTOCOL architects an SQLSTATE of 58008 or 58009.
1044    //
1045    // Messages
1046    // SQLSTATE : 58009
1047    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
1048    //     SQLCODE : -30020
1049    //     Execution failed because of a Distributed Protocol
1050    //         Error that will affect the successful execution of subsequent
1051    //         commands and SQL statements: Reason Code <reason-code>.
1052    //      Some possible reason codes include:
1053    //      121C Indicates that the user is not authorized to perform the requested command.
1054    //      1232 The command could not be completed because of a permanent error.
1055    //          In most cases, the server will be in the process of an abend.
1056    //      220A The target server has received an invalid data description.
1057    //          If a user SQLDA is specified, ensure that the fields are
1058    //          initialized correctly. Also, ensure that the length does not
1059    //          exceed the maximum allowed length for the data type being used.
1060    //
1061    //      The command or statement cannot be processed.  The current
1062    //          transaction is rolled back and the application is disconnected
1063    //          from the remote database.
1064    //
1065    //
1066    // Returned from Server:
1067    // SVRCOD - required  (8 - ERROR)
1068    // SYNERRCD - required
1069    // RECCNT - optional (MINVAL 0, MINLVL 3) (will not be returned - should be ignored)
1070    // CODPNT - optional (MINLVL 3)
1071    // RDBNAM - optional (MINLVL 3)
1072    //
1073    protected void parseSYNTAXRM() throws DisconnectException {
1074        boolean svrcodReceived = false;
1075        int svrcod = CodePoint.SVRCOD_INFO;
1076        boolean synerrcdReceived = false;
1077        int synerrcd = 0;
1078        boolean rdbnamReceived = false;
1079        String rdbnam = null;
1080        boolean codpntReceived = false;
1081        int codpnt = 0;
1082 
1083        parseLengthAndMatchCodePoint(CodePoint.SYNTAXRM);
1084        pushLengthOnCollectionStack();
1085        int peekCP = peekCodePoint();
1086 
1087        while (peekCP != Reply.END_OF_COLLECTION) {
1088 
1089            boolean foundInPass = false;
1090 
1091            if (peekCP == CodePoint.SVRCOD) {
1092                foundInPass = true;
1093                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1094                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1095                peekCP = peekCodePoint();
1096            }
1097 
1098            if (peekCP == CodePoint.SYNERRCD) {
1099                foundInPass = true;
1100                synerrcdReceived = checkAndGetReceivedFlag(synerrcdReceived);
1101                synerrcd = parseSYNERRCD();
1102                peekCP = peekCodePoint();
1103            }
1104 
1105            if (peekCP == CodePoint.RDBNAM) {
1106                foundInPass = true;
1107                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1108                rdbnam = parseRDBNAM(true);
1109                peekCP = peekCodePoint();
1110            }
1111 
1112            if (peekCP == CodePoint.CODPNT) {
1113                foundInPass = true;
1114                codpntReceived = checkAndGetReceivedFlag(codpntReceived);
1115                codpnt = parseCODPNT();
1116                peekCP = peekCodePoint();
1117            }
1118 
1119            // RECCNT will be skipped.
1120 
1121            if (!foundInPass) {
1122                doPrmnsprmSemantics(peekCP);
1123            }
1124        }
1125        popCollectionStack();
1126        checkRequiredObjects(svrcodReceived, synerrcdReceived);
1127 
1128        netAgent_.setSvrcod(svrcod);
1129        doSyntaxrmSemantics(codpnt);
1130    }
1131 
1132    // RDB Currently Accessed Reply Message inidcates that the
1133    // ACCRDB command cannot be issued because the requester
1134    // has access to a relational database.
1135    // PROTOCOL architects an SQLSTATE of 58008 or 58009.
1136    //
1137    // Messages
1138    // SQLSTATE : 58009
1139    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
1140    //     SQLCODE : -30020
1141    //     Execution failed because of a Distributed Protocol
1142    //         Error that will affect the successful execution of subsequent
1143    //         commands and SQL statements: Reason Code <reason-code>.
1144    //      Some possible reason codes include:
1145    //      121C Indicates that the user is not authorized to perform the requested command.
1146    //      1232 The command could not be completed because of a permanent error.
1147    //          In most cases, the server will be in the process of an abend.
1148    //      220A The target server has received an invalid data description.
1149    //          If a user SQLDA is specified, ensure that the fields are
1150    //          initialized correctly. Also, ensure that the length does not
1151    //          exceed the maximum allowed length for the data type being used.
1152    //
1153    //      The command or statement cannot be processed.  The current
1154    //      transaction is rolled back and the application is disconnected
1155    //      from the remote database.
1156    //
1157    //
1158    // Returned from Server:
1159    // SVRCOD - required  (8 - ERROR)
1160    // RDBNAM - required
1161    //
1162    private void parseRDBACCRM() throws DisconnectException {
1163        boolean svrcodReceived = false;
1164        int svrcod = CodePoint.SVRCOD_INFO;
1165        boolean rdbnamReceived = false;
1166        String rdbnam = null;
1167 
1168        parseLengthAndMatchCodePoint(CodePoint.RDBACCRM);
1169        pushLengthOnCollectionStack();
1170        int peekCP = peekCodePoint();
1171 
1172        while (peekCP != Reply.END_OF_COLLECTION) {
1173 
1174            boolean foundInPass = false;
1175 
1176            if (peekCP == CodePoint.SVRCOD) {
1177                foundInPass = true;
1178                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1179                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1180                peekCP = peekCodePoint();
1181            }
1182 
1183            if (peekCP == CodePoint.RDBNAM) {
1184                foundInPass = true;
1185                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1186                rdbnam = parseRDBNAM(true);
1187                peekCP = peekCodePoint();
1188            }
1189 
1190            if (!foundInPass) {
1191                doPrmnsprmSemantics(peekCP);
1192            }
1193 
1194        }
1195        popCollectionStack();
1196        checkRequiredObjects(svrcodReceived, rdbnamReceived);
1197 
1198        netAgent_.setSvrcod(svrcod);
1199        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
1200            new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
1201            msgutil_.getTextMessage(MessageId.CONN_DRDA_RDBACCRM)));
1202    }
1203 
1204    // RDB Access Failed Reply Message specifies that the relational
1205    // database failed the attempted connection.
1206    // An SQLCARD object must also be returned, following the
1207    // RDBAFLRM, to explain why the RDB failed the connection.
1208    // In addition, the target SQLAM instance is destroyed.
1209    // The SQLSTATE is returned in the SQLCARD.
1210    //
1211    // Messages
1212    // SQLSTATE : 58009
1213    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
1214    //     SQLCODE : -30020
1215    //     Execution failed because of a Distributed Protocol
1216    //         Error that will affect the successful execution of subsequent
1217    //         commands and SQL statements: Reason Code <reason-code>.
1218    //      Some possible reason codes include:
1219    //      121C Indicates that the user is not authorized to perform the requested command.
1220    //      1232 The command could not be completed because of a permanent error.
1221    //          In most cases, the server will be in the process of an abend.
1222    //      220A The target server has received an invalid data description.
1223    //          If a user SQLDA is specified, ensure that the fields are
1224    //          initialized correctly. Also, ensure that the length does not
1225    //          exceed the maximum allowed length for the data type being used.
1226    //
1227    //      The command or statement cannot be processed.  The current
1228    //      transaction is rolled back and the application is disconnected
1229    //      from the remote database.
1230    //
1231    //
1232    // Returned from Server:
1233    // SVRCOD - required  (8 - ERROR)
1234    // RDBNAM - required
1235    //
1236    private void parseRDBAFLRM() throws DisconnectException {
1237        boolean svrcodReceived = false;
1238        int svrcod = CodePoint.SVRCOD_INFO;
1239        boolean rdbnamReceived = false;
1240        String rdbnam = null;
1241 
1242        parseLengthAndMatchCodePoint(CodePoint.RDBAFLRM);
1243        pushLengthOnCollectionStack();
1244        int peekCP = peekCodePoint();
1245 
1246        while (peekCP != Reply.END_OF_COLLECTION) {
1247 
1248            boolean foundInPass = false;
1249 
1250            if (peekCP == CodePoint.SVRCOD) {
1251                foundInPass = true;
1252                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1253                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1254                peekCP = peekCodePoint();
1255            }
1256 
1257            if (peekCP == CodePoint.RDBNAM) {
1258                foundInPass = true;
1259                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1260                rdbnam = parseRDBNAM(true);
1261                peekCP = peekCodePoint();
1262            }
1263 
1264            if (!foundInPass) {
1265                doPrmnsprmSemantics(peekCP);
1266            }
1267 
1268        }
1269        popCollectionStack();
1270        checkRequiredObjects(svrcodReceived, rdbnamReceived);
1271 
1272        netAgent_.setSvrcod(svrcod);
1273    }
1274 
1275 
1276    // Parameter Value Not Supported Reply Message indicates
1277    // that the parameter value specified is either not recognized
1278    // or not supported for the specified parameter.
1279    // The VALNSPRM can only be specified in accordance with
1280    // the rules specified for DDM subsetting.
1281    // The code point of the command parameter in error is
1282    // returned as a parameter in this message.
1283    // PROTOCOL Architects an SQLSTATE of 58017.
1284    //
1285    // if codepoint is 0x119C,0x119D, or 0x119E then SQLSTATE 58017, SQLCODE -332
1286    // else SQLSTATE 58017, SQLCODE -30073
1287    //
1288    // Messages
1289    // SQLSTATE : 58017
1290    //     The DDM parameter value is not supported.
1291    //     SQLCODE : -332
1292    //     There is no available conversion for the source code page
1293    //         <code page> to the target code page <code page>.
1294    //         Reason code <reason-code>.
1295    //     The reason codes are as follows:
1296    //     1 source and target code page combination is not supported
1297    //         by the database manager.
1298    //     2 source and target code page combination is either not
1299    //         supported by the database manager or by the operating
1300    //         system character conversion utility on the client node.
1301    //     3 source and target code page combination is either not
1302    //         supported by the database manager or by the operating
1303    //         system character conversion utility on the server node.
1304    //
1305    // SQLSTATE : 58017
1306    //     The DDM parameter value is not supported.
1307    //     SQLCODE : -30073
1308    //     <parameter-identifier> Parameter value <value> is not supported.
1309    //     Some possible parameter identifiers include:
1310    //     002F  The target server does not support the data type
1311    //         requested by the application requester.
1312    //         The target server does not support the CCSID
1313    //         requested by the application requester. Ensure the CCSID
1314    //         used by the requester is supported by the server.
1315    //         119C - Verify the single-byte CCSID.
1316    //         119D - Verify the double-byte CCSID.
1317    //         119E - Verify the mixed-byte CCSID.
1318    //
1319    //     The current environment command or SQL statement
1320    //         cannot be processed successfully, nor can any subsequent
1321    //         commands or SQL statements.  The current transaction is
1322    //         rolled back and the application is disconnected
1323    //         from the remote database. The command cannot be processed.
1324    //
1325    // Returned from Server:
1326    // SVRCOD - required  (8 - ERROR)
1327    // CODPNT - required
1328    // RECCNT - optional (MINLVL 3, MINVAL 0) (will not be returned - should be ignored)
1329    // RDBNAM - optional (MINLVL 3)
1330    //
1331    protected void parseVALNSPRM() throws DisconnectException {
1332        boolean svrcodReceived = false;
1333        int svrcod = CodePoint.SVRCOD_INFO;
1334        boolean rdbnamReceived = false;
1335        String rdbnam = null;
1336        boolean codpntReceived = false;
1337        int codpnt = 0;
1338 
1339        parseLengthAndMatchCodePoint(CodePoint.VALNSPRM);
1340        pushLengthOnCollectionStack();
1341        int peekCP = peekCodePoint();
1342 
1343        while (peekCP != Reply.END_OF_COLLECTION) {
1344 
1345            boolean foundInPass = false;
1346 
1347            if (peekCP == CodePoint.SVRCOD) {
1348                foundInPass = true;
1349                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1350                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1351                peekCP = peekCodePoint();
1352            }
1353 
1354            if (peekCP == CodePoint.RDBNAM) {
1355                foundInPass = true;
1356                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1357                rdbnam = parseRDBNAM(true);
1358                peekCP = peekCodePoint();
1359            }
1360 
1361            if (peekCP == CodePoint.CODPNT) {
1362                foundInPass = true;
1363                codpntReceived = checkAndGetReceivedFlag(codpntReceived);
1364                codpnt = parseCODPNT();
1365                peekCP = peekCodePoint();
1366            }
1367 
1368            // RECCNT will be skipped
1369 
1370            if (!foundInPass) {
1371                doPrmnsprmSemantics(peekCP);
1372            }
1373 
1374        }
1375        popCollectionStack();
1376        checkRequiredObjects(svrcodReceived, codpntReceived);
1377 
1378        netAgent_.setSvrcod(svrcod);
1379        doValnsprmSemantics(codpnt, "\"\"");
1380    }
1381 
1382 
1383    // Conversational Protocol Error Reply Message
1384    // indicates that a conversational protocol error occurred.
1385    // PROTOCOL architects the SQLSTATE value depending on SVRCOD
1386    // SVRCOD 8 -> SQLSTATE of 58008 or 58009
1387    // SVRCOD 16,128 -> SQLSTATE of 58009
1388    //
1389    // Messages
1390    // SQLSTATE : 58009
1391    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
1392    //     SQLCODE : -30020
1393    //     Execution failed because of a Distributed Protocol
1394    //         Error that will affect the successful execution of subsequent
1395    //         commands and SQL statements: Reason Code <reason-code>.
1396    //      Some possible reason codes include:
1397    //      121C Indicates that the user is not authorized to perform the requested command.
1398    //      1232 The command could not be completed because of a permanent error.
1399    //          In most cases, the server will be in the process of an abend.
1400    //      220A The target server has received an invalid data description.
1401    //          If a user SQLDA is specified, ensure that the fields are
1402    //          initialized correctly. Also, ensure that the length does not
1403    //          exceed the maximum allowed length for the data type being used.
1404    //
1405    //      The command or statement cannot be processed.  The current
1406    //      transaction is rolled back and the application is disconnected
1407    //      from the remote database.
1408    //
1409    //
1410    // Returned from Server:
1411    // SVRCOD - required  (8 - ERROR, 16 - SEVERE, 128 - SESDMG)
1412    // PRCCNVCD - required
1413    // RECCNT - optional (MINVAL 0, MINLVL 3)
1414    // RDBNAM - optional (NINLVL 3)
1415    //
1416    protected void parsePRCCNVRM() throws DisconnectException {
1417        boolean svrcodReceived = false;
1418        int svrcod = CodePoint.SVRCOD_INFO;
1419        boolean rdbnamReceived = false;
1420        String rdbnam = null;
1421        boolean prccnvcdReceived = false;
1422        int prccnvcd = 0;
1423 
1424        parseLengthAndMatchCodePoint(CodePoint.PRCCNVRM);
1425        pushLengthOnCollectionStack();
1426        int peekCP = peekCodePoint();
1427 
1428        while (peekCP != Reply.END_OF_COLLECTION) {
1429 
1430            boolean foundInPass = false;
1431 
1432            if (peekCP == CodePoint.SVRCOD) {
1433                foundInPass = true;
1434                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1435                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_SESDMG);
1436                peekCP = peekCodePoint();
1437            }
1438 
1439            if (peekCP == CodePoint.RDBNAM) {
1440                foundInPass = true;
1441                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1442                rdbnam = parseRDBNAM(true);
1443                peekCP = peekCodePoint();
1444            }
1445 
1446            if (peekCP == CodePoint.PRCCNVCD) {
1447                foundInPass = true;
1448                prccnvcdReceived = checkAndGetReceivedFlag(prccnvcdReceived);
1449                prccnvcd = parsePRCCNVCD();
1450                peekCP = peekCodePoint();
1451            }
1452 
1453            if (!foundInPass) {
1454                doPrmnsprmSemantics(peekCP);
1455            }
1456 
1457        }
1458        popCollectionStack();
1459        checkRequiredObjects(svrcodReceived, prccnvcdReceived);
1460 
1461        netAgent_.setSvrcod(svrcod);
1462        doPrccnvrmSemantics(CodePoint.PRCCNVRM);
1463    }
1464 
1465    // Object Not Supported Reply Message indicates that the target
1466    // server does not recognize or support the object
1467    // specified as data in an OBJDSS for the command associated
1468    // with the object.
1469    // The OBJNSPRM is also returned if an object is found in a
1470    // valid collection in an OBJDSS (such as RECAL collection)
1471    // that that is not valid for that collection.
1472    // PROTOCOL Architects an SQLSTATE of 58015.
1473    //
1474    // Messages
1475    // SQLSTATE : 58015
1476    //     The DDM object is not supported.
1477    //     SQLCODE : -30071
1478    //      <object-identifier> Object is not supported.
1479    //     The current transaction is rolled back and the application
1480    //     is disconnected from the remote database. The command
1481    //     cannot be processed.
1482    //
1483    //
1484    // Returned from Server:
1485    // SVRCOD - required  (8 - ERROR, 16 - SEVERE)
1486    // CODPNT - required
1487    // RECCNT - optional (MINVAL 0)  (will not be returned - should be ignored)
1488    // RDBNAM - optional (MINLVL 3)
1489    //
1490    // Also called by NetPackageReply and NetStatementReply
1491    void parseOBJNSPRM() throws DisconnectException {
1492        boolean svrcodReceived = false;
1493        int svrcod = CodePoint.SVRCOD_INFO;
1494        boolean rdbnamReceived = false;
1495        String rdbnam = null;
1496        boolean codpntReceived = false;
1497        int codpnt = 0;
1498 
1499        parseLengthAndMatchCodePoint(CodePoint.OBJNSPRM);
1500        pushLengthOnCollectionStack();
1501        int peekCP = peekCodePoint();
1502 
1503        while (peekCP != Reply.END_OF_COLLECTION) {
1504 
1505            boolean foundInPass = false;
1506 
1507            if (peekCP == CodePoint.SVRCOD) {
1508                foundInPass = true;
1509                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1510                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_SEVERE);
1511                peekCP = peekCodePoint();
1512            }
1513 
1514            if (peekCP == CodePoint.RDBNAM) {
1515                foundInPass = true;
1516                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1517                rdbnam = parseRDBNAM(true);
1518                peekCP = peekCodePoint();
1519            }
1520 
1521            if (peekCP == CodePoint.CODPNT) {
1522                foundInPass = true;
1523                codpntReceived = checkAndGetReceivedFlag(codpntReceived);
1524                codpnt = parseCODPNT();
1525                peekCP = peekCodePoint();
1526            }
1527 
1528            // skip the RECCNT
1529 
1530            if (!foundInPass) {
1531                doPrmnsprmSemantics(peekCP);
1532            }
1533 
1534        }
1535        popCollectionStack();
1536        checkRequiredObjects(svrcodReceived, codpntReceived);
1537 
1538        netAgent_.setSvrcod(svrcod);
1539        doObjnsprmSemantics(codpnt);
1540    }
1541 
1542 
1543    // Manager-Level Conflict (MGRLVLRM) Reply Message indicates that
1544    // the manager levels specified in the MGRLVLLS conflict amoung
1545    // themselves or with previously specified manager levels.
1546    // - The manager-level dependencies of one specified manager violates another
1547    //   specified maanger level.
1548    // - The manager- level specified attempts to respecify a manager level that
1549    //   previously EXCSAT command specified.
1550    // PROTOCOL architects an SQLSTATE of 58010.
1551    //
1552    // Messages
1553    // SQLSTATE : 58010
1554    //     Execution failed due to a distributed protocol error that will affect
1555    //     the successful execution of subsequent DDM commands or SQL statements.
1556    //     SQLCODE : -30021
1557    //     Execution failed due to a distribution protocol error
1558    //     that will affect the successful execution of subsequent
1559    //     commands and SQL statements: Manager <manager> at Level <level>
1560    //     not supported.
1561    //
1562    //     A system error occurred that prevented successful connection
1563    //     of the application to the remote database.
1564    //
1565    //
1566    // Returned from Server:
1567    // SVRCOD - required  (8 - ERROR)
1568    // MGRLVLLS - required
1569    //
1570    private void parseMGRLVLRM() throws DisconnectException {
1571        boolean svrcodReceived = false;
1572        int svrcod = CodePoint.SVRCOD_INFO;
1573        boolean mgrlvllsReceived = false;
1574        int[] managerCodePoint = null;
1575        int[] managerLevel = null;
1576 
1577        parseLengthAndMatchCodePoint(CodePoint.MGRLVLRM);
1578        pushLengthOnCollectionStack();
1579        int peekCP = peekCodePoint();
1580 
1581        while (peekCP != Reply.END_OF_COLLECTION) {
1582 
1583            boolean foundInPass = false;
1584 
1585            if (peekCP == CodePoint.SVRCOD) {
1586                foundInPass = true;
1587                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1588                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1589                peekCP = peekCodePoint();
1590            }
1591 
1592            if (peekCP == CodePoint.MGRLVLLS) {
1593                foundInPass = true;
1594                mgrlvllsReceived = checkAndGetReceivedFlag(mgrlvllsReceived);
1595 
1596                parseLengthAndMatchCodePoint(CodePoint.MGRLVLLS);
1597                int managerListLength = getDdmLength();
1598                if ((managerListLength == 0) || ((managerListLength % 7) != 0)) {
1599                    doSyntaxrmSemantics(CodePoint.SYNERRCD_OBJ_LEN_NOT_ALLOWED);
1600                }
1601 
1602                int managerCount = managerListLength / 7;
1603                managerCodePoint = new int[managerCount];
1604                managerLevel = new int[managerCount];
1605                for (int i = 0; i < managerCount; i++) {
1606                    managerCodePoint[i] = parseCODPNTDR();
1607                    managerLevel[i] = parseMGRLVLN();
1608                }
1609                peekCP = peekCodePoint();
1610            }
1611 
1612 
1613            if (!foundInPass) {
1614                doPrmnsprmSemantics(peekCP);
1615            }
1616 
1617        }
1618        popCollectionStack();
1619        checkRequiredObjects(svrcodReceived, mgrlvllsReceived);
1620 
1621        netAgent_.setSvrcod(svrcod);
1622        doMgrlvlrmSemantics(managerCodePoint, managerLevel);
1623    }
1624 
1625 
1626    // Command Not Supported Reply Message indicates that the specified
1627    // command is not recognized or not supported for the
1628    // specified target.  The reply message can be returned
1629    // only in accordance with the architected rules for DDM subsetting.
1630    // PROTOCOL architects an SQLSTATE of 58014.
1631    //
1632    // Messages
1633    // SQLSTATE : 58014
1634    //     The DDM command is not supported.
1635    //     SQLCODE : -30070
1636    //      <command-identifier> Command is not supported.
1637    //     The current transaction is rolled back and the application is
1638    //     disconnected from the remote database. The statement cannot be processed.
1639    //
1640    //
1641    // Returned from Server:
1642    // SVRCOD - required  (4 - WARNING, 8 - ERROR) (MINLVL 2)
1643    // CODPNT - required
1644    // RDBNAM - optional (MINLVL 3)
1645    //
1646    protected void parseCMDNSPRM() throws DisconnectException {
1647        boolean svrcodReceived = false;
1648        int svrcod = CodePoint.SVRCOD_INFO;
1649        boolean rdbnamReceived = false;
1650        String rdbnam = null;
1651        boolean srvdgnReceived = false;
1652        byte[] srvdgn = null;
1653        boolean codpntReceived = false;
1654        int codpnt = 0;
1655 
1656        parseLengthAndMatchCodePoint(CodePoint.CMDNSPRM);
1657        pushLengthOnCollectionStack();
1658        int peekCP = peekCodePoint();
1659 
1660        while (peekCP != Reply.END_OF_COLLECTION) {
1661 
1662            boolean foundInPass = false;
1663 
1664            if (peekCP == CodePoint.SVRCOD) {
1665                foundInPass = true;
1666                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1667                svrcod = parseSVRCOD(CodePoint.SVRCOD_WARNING, CodePoint.SVRCOD_ERROR);
1668                peekCP = peekCodePoint();
1669            }
1670 
1671            if (peekCP == CodePoint.RDBNAM) {
1672                foundInPass = true;
1673                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1674                rdbnam = parseRDBNAM(true);
1675                peekCP = peekCodePoint();
1676            }
1677 
1678 
1679            if (peekCP == CodePoint.CODPNT) {
1680                foundInPass = true;
1681                codpntReceived = checkAndGetReceivedFlag(codpntReceived);
1682                codpnt = parseCODPNT();
1683                peekCP = peekCodePoint();
1684            }
1685 
1686            if (!foundInPass) {
1687                doPrmnsprmSemantics(peekCP);
1688            }
1689 
1690        }
1691        popCollectionStack();
1692        checkRequiredObjects(svrcodReceived, codpntReceived);
1693 
1694        netAgent_.setSvrcod(svrcod);
1695        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
1696            new ClientMessageId(SQLState.DRDA_DDM_COMMAND_NOT_SUPPORTED),
1697                Integer.toHexString(codpnt)));
1698    }
1699 
1700    // Abnormal End Unit of Work Condition Reply Message indicates
1701    // that the current unit of work ended abnormally because
1702    // of some action at the target server.  This can be caused by a
1703    // deadlock resolution, operator intervention, or some similar
1704    // situation that caused the relational database to rollback
1705    // the current unit of work.  This reply message is returned only
1706    // if an SQLAM issues the command.  Whenever an ABNUOWRM is returned
1707    // in response to a command, an SQLCARD object must also be returned
1708    // following the ABNUOWRM.  The SQLSTATE is returned in the SQLCARD.
1709    //
1710    // Returned from Server:
1711    //   SVRCOD - required (8 - ERROR)
1712    //   RDBNAM - required
1713    //
1714    // Called by all the NET*Reply classes.
1715    void parseABNUOWRM(ConnectionCallbackInterface connection) throws DisconnectException {
1716        boolean svrcodReceived = false;
1717        int svrcod = CodePoint.SVRCOD_INFO;
1718        boolean rdbnamReceived = false;
1719        String rdbnam = null;
1720 
1721        parseLengthAndMatchCodePoint(CodePoint.ABNUOWRM);
1722        pushLengthOnCollectionStack();
1723        int peekCP = peekCodePoint();
1724 
1725        while (peekCP != Reply.END_OF_COLLECTION) {
1726 
1727            boolean foundInPass = false;
1728 
1729            if (peekCP == CodePoint.SVRCOD) {
1730                foundInPass = true;
1731                svrcodReceived = checkAndGetReceivedFlag(svrcodReceived);
1732                svrcod = parseSVRCOD(CodePoint.SVRCOD_ERROR, CodePoint.SVRCOD_ERROR);
1733                peekCP = peekCodePoint();
1734            }
1735 
1736            if (peekCP == CodePoint.RDBNAM) {
1737                // skip the rbbnam since it doesn't tell us anything new.
1738                // there is no way to return it to the application anyway.
1739                // not having to convert this to a string is a time saver also.
1740                foundInPass = true;
1741                rdbnamReceived = checkAndGetReceivedFlag(rdbnamReceived);
1742                rdbnam = parseRDBNAM(true);
1743                peekCP = peekCodePoint();
1744            }
1745 
1746            if (!foundInPass) {
1747                doPrmnsprmSemantics(peekCP);
1748            }
1749        }
1750 
1751        popCollectionStack();
1752        checkRequiredObjects(svrcodReceived, rdbnamReceived);
1753 
1754        // the abnuowrm has been received, do whatever state changes are necessary
1755        netAgent_.setSvrcod(svrcod);
1756        connection.completeAbnormalUnitOfWork();
1757 
1758    }
1759 
1760    //--------------------- parse DDM Reply Data--------------------------------------
1761 
1762    // The Server Attributes Reply Data (EXCSATRD) returns the following
1763    // information in response to an EXCSAT command:
1764    // - the target server's class name
1765    // - the target server's support level for each class of manager
1766    //   the source requests
1767    // - the target server's product release level
1768    // - the target server's external name
1769    // - the target server's name
1770    //
1771    // Returned from Server:
1772    // EXTNAM - optional
1773    // MGRLVLLS - optional
1774    // SRVCLSNM - optional
1775    // SRVNAM - optional
1776    // SRVRLSLV - optional
1777    private void parseEXCSATRD(NetConnection netConnection) throws DisconnectException {
1778        boolean extnamReceived = false;
1779        String extnam = null;
1780        boolean mgrlvllsReceived = false;
1781        boolean srvclsnmReceived = false;
1782        String srvclsnm = null;
1783        boolean srvnamReceived = false;
1784        String srvnam = null;
1785        boolean srvrlslvReceived = false;
1786        String srvrlslv = null;
1787 
1788        parseLengthAndMatchCodePoint(CodePoint.EXCSATRD);
1789        pushLengthOnCollectionStack();
1790        int peekCP = peekCodePoint();
1791 
1792        while (peekCP != Reply.END_OF_COLLECTION) {
1793 
1794            boolean foundInPass = false;
1795 
1796            if (peekCP == CodePoint.EXTNAM) {
1797                // External Name is the name of the job, task, or process
1798                // on a system for which a DDM server is active.  For a target
1799                // DDM server, the external name is the name of the job the system creates
1800                // or activates to run the DDM server.
1801                // No semantic meaning is assigned to external names in DDM.
1802                // External names are transmitted to aid in problem determination.
1803                // This driver will save the external name of the target (the
1804                // driver may use it for logging purposes later).
1805                foundInPass = true;
1806                extnamReceived = checkAndGetReceivedFlag(extnamReceived);
1807                extnam = parseEXTNAM();
1808                peekCP = peekCodePoint();
1809            }
1810 
1811            if (peekCP == CodePoint.MGRLVLLS) {
1812                // Manager-Level List
1813                // specifies a list of code points and support levels for the
1814                // classes of managers a server supports
1815                foundInPass = true;
1816                mgrlvllsReceived = checkAndGetReceivedFlag(mgrlvllsReceived);
1817                parseMGRLVLLS(netConnection);  // need to review this one, check input and output
1818                peekCP = peekCodePoint();
1819            }
1820 
1821            if (peekCP == CodePoint.SRVCLSNM) {
1822                // Server Class Name
1823                // specifies the name of a class of ddm servers.
1824                foundInPass = true;
1825                srvclsnmReceived = checkAndGetReceivedFlag(srvclsnmReceived);
1826                srvclsnm = parseSRVCLSNM();
1827                peekCP = peekCodePoint();
1828            }
1829 
1830            if (peekCP == CodePoint.SRVNAM) {
1831                // Server Name
1832                // no semantic meaning is assigned to server names in DDM,
1833                // it is recommended (by the DDM manual) that the server's
1834                // physical or logical location identifier be used as a server name.
1835                // server names are transmitted for problem determination purposes.
1836                // this driver will save this name and in the future may use it
1837                // for logging errors.
1838                foundInPass = true;
1839                srvnamReceived = checkAndGetReceivedFlag(srvnamReceived);
1840                srvnam = parseSRVNAM();
1841                peekCP = peekCodePoint();
1842            }
1843 
1844            if (peekCP == CodePoint.SRVRLSLV) {
1845                // Server Product Release Level
1846                // specifies the procuct release level of a ddm server.
1847                // the contents are unarchitected.
1848                // this driver will save this information and in the future may
1849                // use it for logging purposes.
1850                foundInPass = true;
1851                srvrlslvReceived = checkAndGetReceivedFlag(srvrlslvReceived);
1852                srvrlslv = parseSRVRLSLV();
1853                peekCP = peekCodePoint();
1854            }
1855 
1856            if (!foundInPass) {
1857                doPrmnsprmSemantics(peekCP);
1858            }
1859 
1860        }
1861        popCollectionStack();
1862        // according the the DDM book, all these instance variables are optional
1863        netConnection.setServerAttributeData(extnam, srvclsnm, srvnam, srvrlslv);
1864    }
1865 
1866    // Must make a version that does not change state in the associated connection
1867    private void parseDummyEXCSATRD(NetConnection netConnection) throws DisconnectException {
1868        boolean extnamReceived = false;
1869        String extnam = null;
1870        boolean mgrlvllsReceived = false;
1871        boolean srvclsnmReceived = false;
1872        String srvclsnm = null;
1873        boolean srvnamReceived = false;
1874        String srvnam = null;
1875        boolean srvrlslvReceived = false;
1876        String srvrlslv = null;
1877 
1878        parseLengthAndMatchCodePoint(CodePoint.EXCSATRD);
1879        pushLengthOnCollectionStack();
1880        int peekCP = peekCodePoint();
1881 
1882        while (peekCP != Reply.END_OF_COLLECTION) {
1883 
1884            boolean foundInPass = false;
1885 
1886            if (peekCP == CodePoint.EXTNAM) {
1887                // External Name is the name of the job, task, or process
1888                // on a system for which a DDM server is active.  For a target
1889                // DDM server, the external name is the name of the job the system creates
1890                // or activates to run the DDM server.
1891                // No semantic meaning is assigned to external names in DDM.
1892                // External names are transmitted to aid in problem determination.
1893                // This driver will save the external name of the target (the
1894                // driver may use it for logging purposes later).
1895                foundInPass = true;
1896                extnamReceived = checkAndGetReceivedFlag(extnamReceived);
1897                extnam = parseEXTNAM();
1898                peekCP = peekCodePoint();
1899            }
1900 
1901            if (peekCP == CodePoint.MGRLVLLS) {
1902                // Manager-Level List
1903                // specifies a list of code points and support levels for the
1904                // classes of managers a server supports
1905                foundInPass = true;
1906                mgrlvllsReceived = checkAndGetReceivedFlag(mgrlvllsReceived);
1907                parseMGRLVLLS(netConnection);  // need to review this one, check input and output
1908                peekCP = peekCodePoint();
1909            }
1910 
1911            if (peekCP == CodePoint.SRVCLSNM) {
1912                // Server Class Name
1913                // specifies the name of a class of ddm servers.
1914                foundInPass = true;
1915                srvclsnmReceived = checkAndGetReceivedFlag(srvclsnmReceived);
1916                srvclsnm = parseSRVCLSNM();
1917                peekCP = peekCodePoint();
1918            }
1919 
1920            if (peekCP == CodePoint.SRVNAM) {
1921                // Server Name
1922                // no semantic meaning is assigned to server names in DDM,
1923                // it is recommended (by the DDM manual) that the server's
1924                // physical or logical location identifier be used as a server name.
1925                // server names are transmitted for problem determination purposes.
1926                // this driver will save this name and in the future may use it
1927                // for logging errors.
1928                foundInPass = true;
1929                srvnamReceived = checkAndGetReceivedFlag(srvnamReceived);
1930                srvnam = parseSRVNAM();
1931                peekCP = peekCodePoint();
1932            }
1933 
1934            if (peekCP == CodePoint.SRVRLSLV) {
1935                // Server Product Release Level
1936                // specifies the procuct release level of a ddm server.
1937                // the contents are unarchitected.
1938                // this driver will save this information and in the future may
1939                // use it for logging purposes.
1940                foundInPass = true;
1941                srvrlslvReceived = checkAndGetReceivedFlag(srvrlslvReceived);
1942                srvrlslv = parseSRVRLSLV();
1943                peekCP = peekCodePoint();
1944            }
1945 
1946            if (!foundInPass) {
1947                doPrmnsprmSemantics(peekCP);
1948            }
1949 
1950        }
1951        popCollectionStack();
1952        // according the the DDM book, all these instance variables are optional
1953        // don't change state of netConnection because this is a DUMMY flow
1954        //netConnection.setServerAttributeData (extnam, srvclsnm, srvnam, srvrlslv);
1955    }
1956 
1957    // The Access Security Reply Data (ACSECRD) Collection Object contains
1958    // the security information from a target server's security manager.
1959    // this method returns the security check code received from the server
1960    // (if the server does not return a security check code, this method
1961    // will return 0).  it is up to the caller to check
1962    // the value of this return code and take the appropriate action.
1963    //
1964    // Returned from Server:
1965    // SECMEC - required
1966    // SECTKN - optional (MINLVL 6)
1967    // SECCHKCD - optional
1968    private void parseACCSECRD(NetConnection netConnection, int securityMechanism) throws DisconnectException {
1969        boolean secmecReceived = false;
1970        int[] secmecList = null;
1971        boolean sectknReceived = false;
1972        byte[] sectkn = null;
1973        boolean secchkcdReceived = false;
1974        int secchkcd = 0;
1975 
1976        parseLengthAndMatchCodePoint(CodePoint.ACCSECRD);
1977        pushLengthOnCollectionStack();
1978        int peekCP = peekCodePoint();
1979 
1980        while (peekCP != Reply.END_OF_COLLECTION) {
1981 
1982            boolean foundInPass = false;
1983 
1984            if (peekCP == CodePoint.SECMEC) {
1985                // security mechanism.
1986                // this value must either reflect the value sent in the ACCSEC command
1987                // if the target server supports it; or the values the target server
1988                // does support when it does not support or accept the value
1989                // requested by the source server.
1990                // the secmecs returned are treated as a list and stored in
1991                // targetSecmec_List.
1992                // if the target server supports the source's secmec, it
1993                // will be saved in the variable targetSecmec_ (NOTE: so
1994                // after calling this method, if targetSecmec_'s value is zero,
1995                // then the target did NOT support the source secmec.  any alternate
1996                // secmecs would be contained in targetSecmec_List).
1997                foundInPass = true;
1998                secmecReceived = checkAndGetReceivedFlag(secmecReceived);
1999                secmecList = parseSECMEC();
2000                peekCP = peekCodePoint();
2001            }
2002 
2003            if (peekCP == CodePoint.SECTKN) {
2004                // security token
2005                foundInPass = true;
2006                sectknReceived = checkAndGetReceivedFlag(sectknReceived);
2007                sectkn = parseSECTKN(false);
2008                peekCP = peekCodePoint();
2009            }
2010 
2011            if (peekCP == CodePoint.SECCHKCD) {
2012                // security check code.
2013                // included if and only if an error is detected when processing
2014                // the ACCSEC command.  this has an implied severity code
2015                // of ERROR.
2016                foundInPass = true;
2017                secchkcdReceived = checkAndGetReceivedFlag(secchkcdReceived);
2018                secchkcd = parseSECCHKCD();
2019                peekCP = peekCodePoint();
2020            }
2021 
2022            if (!foundInPass) {
2023                doPrmnsprmSemantics(peekCP);
2024            }
2025        }
2026        popCollectionStack();
2027        checkRequiredObjects(secmecReceived);
2028 
2029        netConnection.setAccessSecurityData(secchkcd,
2030                securityMechanism,
2031                secmecList,
2032                sectknReceived,
2033                sectkn);
2034    }
2035 
2036    // Called by all the NET*Reply classes.
2037    void parseTYPDEFNAM() throws DisconnectException {
2038        parseLengthAndMatchCodePoint(CodePoint.TYPDEFNAM);
2039        netAgent_.targetTypdef_.setTypdefnam(readString());
2040    }
2041 
2042    // Called by all the NET*Reply classes.
2043    void parseTYPDEFOVR() throws DisconnectException {
2044        parseLengthAndMatchCodePoint(CodePoint.TYPDEFOVR);
2045        pushLengthOnCollectionStack();
2046        int peekCP = peekCodePoint();
2047 
2048        while (peekCP != Reply.END_OF_COLLECTION) {
2049 
2050            boolean foundInPass = false;
2051 
2052            if (peekCP == CodePoint.CCSIDSBC) {
2053                foundInPass = true;
2054                netAgent_.targetTypdef_.setCcsidSbc(parseCCSIDSBC());
2055                peekCP = peekCodePoint();
2056            }
2057 
2058            if (peekCP == CodePoint.CCSIDDBC) {
2059                foundInPass = true;
2060                netAgent_.targetTypdef_.setCcsidDbc(parseCCSIDDBC());
2061                peekCP = peekCodePoint();
2062            }
2063 
2064            if (peekCP == CodePoint.CCSIDMBC) {
2065                foundInPass = true;
2066                netAgent_.targetTypdef_.setCcsidMbc(parseCCSIDMBC());
2067                peekCP = peekCodePoint();
2068            }
2069 
2070            if (!foundInPass) {
2071                doPrmnsprmSemantics(peekCP);
2072            }
2073 
2074        }
2075        popCollectionStack();
2076    }
2077 
2078 
2079    // The SYNCCRD Reply Mesage
2080    //
2081    // Returned from Server:
2082    //   XARETVAL - required
2083    int parseSYNCCRD(ConnectionCallbackInterface connection) throws DisconnectException {
2084        return 0;
2085    }
2086 
2087    // Process XA return value
2088    protected int parseXARETVAL() throws DisconnectException {
2089        return 0;
2090    }
2091 
2092    // Process XA return value
2093    protected byte parseSYNCTYPE() throws DisconnectException {
2094        return 0;
2095    }
2096 
2097    // This method handles the parsing of all command replies and reply data
2098    // for the SYNCCTL command.
2099    protected int parseSYNCCTLreply(ConnectionCallbackInterface connection) throws DisconnectException {
2100        return 0;
2101    }
2102 
2103    // Called by the XA commit and rollback parse reply methods.
2104    void parseSYNCCTLError(int peekCP) throws DisconnectException {
2105        switch (peekCP) {
2106        case CodePoint.CMDCHKRM:
2107            parseCMDCHKRM();
2108            break;
2109        case CodePoint.PRCCNVRM:
2110            parsePRCCNVRM();
2111            break;
2112        case CodePoint.SYNTAXRM:
2113            parseSYNTAXRM();
2114            break;
2115        case CodePoint.VALNSPRM:
2116            parseVALNSPRM();
2117            break;
2118        default:
2119            doObjnsprmSemantics(peekCP);
2120        }
2121    }
2122 
2123 
2124    // Manager-Level List.
2125    // Specifies a list of code points and support levels for the
2126    // classes of managers a server supports.
2127    // The target server must not provide information for any target
2128    // managers unless the source explicitly requests it.
2129    // For each manager class, if the target server's support level
2130    // is greater than or equal to the source server's level, then the source
2131    // server's level is returned for that class if the target server can operate
2132    // at the source's level; otherwise a level 0 is returned.  If the target
2133    // server's support level is less than the source server's level, the
2134    // target server's level is returned for that class.  If the target server
2135    // does not recognize the code point of a manager class or does not support
2136    // that class, it returns a level of 0.  The target server then waits
2137    // for the next command or for the source server to terminate communications.
2138    // When the source server receives EXCSATRD, it must compare each of the entries
2139    // in the mgrlvlls parameter it received to the corresponding entries in the mgrlvlls
2140    // parameter it sent.  If any level mismatches, the source server must decide
2141    // whether it can use or adjust to the lower level of target support for that manager
2142    // class.  There are no architectural criteria for making this decision.
2143    // The source server can terminate communications or continue at the target
2144    // servers level of support.  It can also attempt to use whatever
2145    // commands its user requests while receiving eror reply messages for real
2146    // functional mismatches.
2147    // The manager levels the source server specifies or the target server
2148    // returns must be compatible with the manager-level dependencies of the specified
2149    // manangers.  Incompatible manager levels cannot be specified.
2150    // After this method successfully returns, the targetXXXX values (where XXXX
2151    // represents a manager name.  example targetAgent) contain the negotiated
2152    // manager levels for this particular connection.
2153    private void parseMGRLVLLS(NetConnection netConnection) throws DisconnectException {
2154        parseLengthAndMatchCodePoint(CodePoint.MGRLVLLS);
2155 
2156        // each manager class and level is 4 bytes long.
2157        // get the length of the mgrlvls bytes, make sure it contains
2158        // the correct number of bytes for a mgrlvlls object, and calculate
2159        // the number of manager's returned from the server.
2160        int managerListLength = getDdmLength();
2161        if ((managerListLength == 0) || ((managerListLength % 4) != 0)) {
2162            doSyntaxrmSemantics(CodePoint.SYNERRCD_OBJ_LEN_NOT_ALLOWED);
2163        }
2164        int managerCount = managerListLength / 4;
2165 
2166        // the managerCount should be equal to the same number of
2167        // managers sent on the excsat.
2168 
2169        // read each of the manager levels returned from the server.
2170        for (int i = 0; i < managerCount; i++) {
2171 
2172            // first two byte are the manager's codepoint, next two bytes are the level.
2173            int managerCodePoint = parseCODPNTDR();
2174            int managerLevel = parseMGRLVLN();
2175 
2176            // check each manager to make sure levels are within proper limits
2177            // for this driver.  Also make sure unexpected managers are not returned.
2178            switch (managerCodePoint) {
2179 
2180            case CodePoint.AGENT:
2181                if ((managerLevel < NetConfiguration.MIN_AGENT_MGRLVL) ||
2182                        (managerLevel > netConnection.targetAgent_)) {
2183                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2184                }
2185                netConnection.targetAgent_ = managerLevel;
2186                break;
2187 
2188            case CodePoint.CMNTCPIP:
2189                if ((managerLevel < NetConfiguration.MIN_CMNTCPIP_MGRLVL) ||
2190                        (managerLevel > netConnection.targetCmntcpip_)) {
2191                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2192                }
2193                netConnection.targetCmntcpip_ = managerLevel;
2194                break;
2195 
2196            case CodePoint.RDB:
2197                if ((managerLevel < NetConfiguration.MIN_RDB_MGRLVL) ||
2198                        (managerLevel > netConnection.targetRdb_)) {
2199                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2200                }
2201                netConnection.targetRdb_ = managerLevel;
2202                break;
2203 
2204            case CodePoint.SECMGR:
2205                if ((managerLevel < NetConfiguration.MIN_SECMGR_MGRLVL) ||
2206                        (managerLevel > netConnection.targetSecmgr_)) {
2207                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2208                }
2209                netConnection.targetSecmgr_ = managerLevel;
2210                break;
2211 
2212            case CodePoint.SQLAM:
2213                if ((managerLevel < NetConfiguration.MIN_SQLAM_MGRLVL) ||
2214                        (managerLevel > netAgent_.targetSqlam_)) {
2215                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2216                }
2217                netAgent_.orignalTargetSqlam_ = managerLevel;
2218                break;
2219 
2220            case CodePoint.CMNAPPC:
2221                if ((managerLevel < NetConfiguration.MIN_CMNAPPC_MGRLVL) ||
2222                        (managerLevel > netConnection.targetCmnappc_)) {
2223                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2224                }
2225                netConnection.targetCmnappc_ = managerLevel;
2226                break;
2227 
2228            case CodePoint.XAMGR:
2229                if ((managerLevel != 0) &&
2230                        (managerLevel < NetConfiguration.MIN_XAMGR_MGRLVL) ||
2231                        (managerLevel > netConnection.targetXamgr_)) {
2232                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2233                }
2234                netConnection.targetXamgr_ = managerLevel;
2235                break;
2236 
2237            case CodePoint.SYNCPTMGR:
2238                if ((managerLevel != 0) &&
2239                        (managerLevel < NetConfiguration.MIN_SYNCPTMGR_MGRLVL) ||
2240                        (managerLevel > netConnection.targetSyncptmgr_)) {
2241                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2242                }
2243                netConnection.targetSyncptmgr_ = managerLevel;
2244                break;
2245 
2246            case CodePoint.RSYNCMGR:
2247                if ((managerLevel != 0) &&
2248                        (managerLevel < NetConfiguration.MIN_RSYNCMGR_MGRLVL) ||
2249                        (managerLevel > netConnection.targetRsyncmgr_)) {
2250                    doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2251                }
2252                netConnection.targetRsyncmgr_ = managerLevel;
2253                break;
2254                // The target server must not provide information for any target managers
2255                // unless the source explicitly requests.  The following managers are never requested.
2256            default:
2257                doMgrlvlrmSemantics(managerCodePoint, managerLevel);
2258                break;
2259            }
2260        }
2261    }
2262 
2263    // The External Name is the name of the job, task, or process on a
2264    // system for which a DDM server is active.  On a source DDM server,
2265    // the external name is the name of the job that is requesting
2266    // access to remote resources.  For a target DDM server,
2267    // the external name is the name of the job the system
2268    // creates or activates to run the DDM server.
2269    // No semantic meaning is assigned to external names in DDM.
2270    // External names are transmitted to aid in problem determination.
2271    protected String parseEXTNAM() throws DisconnectException {
2272        parseLengthAndMatchCodePoint(CodePoint.EXTNAM);
2273        return readString();
2274    }
2275 
2276    // Server Class name specifies the name of a class of DDM servers.
2277    // Server class names are assigned for each product involved in PROTOCOL.
2278    protected String parseSRVCLSNM() throws DisconnectException {
2279        parseLengthAndMatchCodePoint(CodePoint.SRVCLSNM);
2280        return readString();
2281    }
2282 
2283    // Server Name is the name of the DDM server.
2284    // No semantic meaning is assigned to server names in DDM,
2285    // but it is recommended that the server names are transmitted
2286    // for problem determination.
2287    protected String parseSRVNAM() throws DisconnectException {
2288        parseLengthAndMatchCodePoint(CodePoint.SRVNAM);
2289        return readString();
2290    }
2291 
2292    // Server Product Release Level String specifies the product
2293    // release level of a DDM server.  The contents of the
2294    // parameter are unarchitected.  Up to 255 bytes can be sent.
2295    // SRVRLSLV should not be used in place of product-defined
2296    // extensions to carry information not related to the products
2297    // release level.
2298    protected String parseSRVRLSLV() throws DisconnectException {
2299        parseLengthAndMatchCodePoint(CodePoint.SRVRLSLV);
2300        return readString();
2301    }
2302 
2303    // Manager-Level Number Attribute Binary Integer Number specifies
2304    // the level of a defined DDM manager.
2305    protected int parseMGRLVLN() throws DisconnectException {
2306        return readUnsignedShort();
2307    }
2308 
2309    // Security Mechanims.
2310    protected int[] parseSECMEC() throws DisconnectException {
2311        parseLengthAndMatchCodePoint(CodePoint.SECMEC);
2312        return readUnsignedShortList();
2313    }
2314 
2315    // The Security Token Byte String is information provided and used
2316    // by the various security mechanisms.
2317    protected byte[] parseSECTKN(boolean skip) throws DisconnectException {
2318        parseLengthAndMatchCodePoint(CodePoint.SECTKN);
2319        if (skip) {
2320            skipBytes();
2321            return null;
2322        }
2323        return readBytes();
2324    }
2325 
2326 
2327    // The Security Check Code String codifies the security information
2328    // and condition for the SECCHKRM.
2329    protected int parseSECCHKCD() throws DisconnectException {
2330        parseLengthAndMatchCodePoint(CodePoint.SECCHKCD);
2331        int secchkcd = readUnsignedByte();
2332        if ((secchkcd < CodePoint.SECCHKCD_00) || (secchkcd > CodePoint.SECCHKCD_15)) {
2333            doValnsprmSemantics(CodePoint.SECCHKCD, secchkcd);
2334        }
2335        return secchkcd;
2336    }
2337 
2338    // Product specific Identifier specifies the product release level
2339    // of a DDM server.
2340    protected String parsePRDID(boolean skip) throws DisconnectException {
2341        parseLengthAndMatchCodePoint(CodePoint.PRDID);
2342        if (skip) {
2343            skipBytes();
2344            return null;
2345        } else {
2346            return readString();
2347        }
2348    }
2349 
2350    // The User Id specifies an end-user name.
2351    protected String parseUSRID(boolean skip) throws DisconnectException {
2352        parseLengthAndMatchCodePoint(CodePoint.USRID);
2353        if (skip) {
2354            skipBytes();
2355            return null;
2356        }
2357        return readString();
2358    };
2359 
2360    // Code Point Data Representation specifies the data representation
2361    // of a dictionary codepoint.  Code points are hexadecimal aliases for DDM
2362    // named terms.
2363    protected int parseCODPNTDR() throws DisconnectException {
2364        return readUnsignedShort();
2365    }
2366 
2367    // Correlation Token specifies a token that is conveyed between source
2368    // and target servers for correlating the processing between servers.
2369    protected byte[] parseCRRTKN(boolean skip) throws DisconnectException {
2370        parseLengthAndMatchCodePoint(CodePoint.CRRTKN);
2371        if (skip) {
2372            skipBytes();
2373            return null;
2374        }
2375        return readBytes();
2376    }
2377 
2378    // Unit of Work Disposition Scalar Object specifies the disposition of the
2379    // last unit of work.
2380    protected int parseUOWDSP() throws DisconnectException {
2381        parseLengthAndMatchCodePoint(CodePoint.UOWDSP);
2382        int uowdsp = readUnsignedByte();
2383        if ((uowdsp != CodePoint.UOWDSP_COMMIT) && (uowdsp != CodePoint.UOWDSP_ROLLBACK)) {
2384            doValnsprmSemantics(CodePoint.UOWDSP, uowdsp);
2385        }
2386        return uowdsp;
2387    }
2388 
2389 
2390    // Relational Database Name specifies the name of a relational
2391    // database of the server.  A server can have more than one RDB.
2392    protected String parseRDBNAM(boolean skip) throws DisconnectException {
2393        parseLengthAndMatchCodePoint(CodePoint.RDBNAM);
2394        if (skip) {
2395            skipBytes();
2396            return null;
2397        }
2398        return readString();
2399    };
2400 
2401 
2402 
2403    protected int parseXIDCNT() throws DisconnectException {
2404        parseLengthAndMatchCodePoint(CodePoint.XIDCNT);
2405        return readUnsignedShort();
2406    }
2407 
2408    protected Xid parseXID() throws DisconnectException {
2409        return null;
2410    }
2411 
2412    protected java.util.Hashtable parseIndoubtList() throws DisconnectException {
2413        return null;
2414    }
2415 
2416 
2417    // Syntax Error Code String specifies the condition that caused termination
2418    // of data stream parsing.
2419    protected int parseSYNERRCD() throws DisconnectException {
2420        parseLengthAndMatchCodePoint(CodePoint.SYNERRCD);
2421        int synerrcd = readUnsignedByte();
2422        if ((synerrcd < 0x01) || (synerrcd > 0x1D)) {
2423            doValnsprmSemantics(CodePoint.SYNERRCD, synerrcd);
2424        }
2425        return synerrcd;
2426    }
2427 
2428    // The Code Point Data specifies a scalar value that is an architected code point.
2429    protected int parseCODPNT() throws DisconnectException {
2430        parseLengthAndMatchCodePoint(CodePoint.CODPNT);
2431        return parseCODPNTDR();
2432    }
2433 
2434    // Conversational Protocol Error Code specifies the condition
2435    // for which the PRCCNVRm was returned.
2436    protected int parsePRCCNVCD() throws DisconnectException {
2437        parseLengthAndMatchCodePoint(CodePoint.PRCCNVCD);
2438        int prccnvcd = readUnsignedByte();
2439        if ((prccnvcd != 0x01) && (prccnvcd != 0x02) && (prccnvcd != 0x03) &&
2440                (prccnvcd != 0x04) && (prccnvcd != 0x05) && (prccnvcd != 0x06) &&
2441                (prccnvcd != 0x10) && (prccnvcd != 0x11) && (prccnvcd != 0x12) &&
2442                (prccnvcd != 0x13) && (prccnvcd != 0x15)) {
2443            doValnsprmSemantics(CodePoint.PRCCNVCD, prccnvcd);
2444        }
2445        return prccnvcd;
2446    }
2447 
2448    // CCSID for Single-Byte Characters specifies a coded character
2449    // set identifier for single-byte characters.
2450    protected int parseCCSIDSBC() throws DisconnectException {
2451        parseLengthAndMatchCodePoint(CodePoint.CCSIDSBC);
2452        return readUnsignedShort();
2453    }
2454 
2455    // CCSID for Mixed-Byte Characters specifies a coded character
2456    // set identifier for mixed-byte characters.
2457    protected int parseCCSIDMBC() throws DisconnectException {
2458        parseLengthAndMatchCodePoint(CodePoint.CCSIDMBC);
2459        return readUnsignedShort();
2460    }
2461 
2462    // CCSID for Double-Byte Characters specifies a coded character
2463    // set identifier for double-byte characters.
2464    protected int parseCCSIDDBC() throws DisconnectException {
2465        parseLengthAndMatchCodePoint(CodePoint.CCSIDDBC);
2466        return readUnsignedShort();
2467    }
2468 
2469    // Severity Code is an indicator of the severity of a condition
2470    // detected during the execution of a command.
2471    protected int parseSVRCOD(int minSvrcod, int maxSvrcod) throws DisconnectException {
2472        parseLengthAndMatchCodePoint(CodePoint.SVRCOD);
2473 
2474        int svrcod = readUnsignedShort();
2475        if ((svrcod != CodePoint.SVRCOD_INFO) &&
2476                (svrcod != CodePoint.SVRCOD_WARNING) &&
2477                (svrcod != CodePoint.SVRCOD_ERROR) &&
2478                (svrcod != CodePoint.SVRCOD_SEVERE) &&
2479                (svrcod != CodePoint.SVRCOD_ACCDMG) &&
2480                (svrcod != CodePoint.SVRCOD_PRMDMG) &&
2481                (svrcod != CodePoint.SVRCOD_SESDMG)) {
2482            doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
2483        }
2484 
2485        if (svrcod < minSvrcod || svrcod > maxSvrcod) {
2486            doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
2487        }
2488 
2489        return svrcod;
2490    }
2491 
2492    protected int parseFastSVRCOD(int minSvrcod, int maxSvrcod) throws DisconnectException {
2493        matchCodePoint(CodePoint.SVRCOD);
2494 
2495        int svrcod = readFastUnsignedShort();
2496        if ((svrcod != CodePoint.SVRCOD_INFO) &&
2497                (svrcod != CodePoint.SVRCOD_WARNING) &&
2498                (svrcod != CodePoint.SVRCOD_ERROR) &&
2499                (svrcod != CodePoint.SVRCOD_SEVERE) &&
2500                (svrcod != CodePoint.SVRCOD_ACCDMG) &&
2501                (svrcod != CodePoint.SVRCOD_PRMDMG) &&
2502                (svrcod != CodePoint.SVRCOD_SESDMG)) {
2503            doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
2504        }
2505 
2506        if (svrcod < minSvrcod || svrcod > maxSvrcod) {
2507            doValnsprmSemantics(CodePoint.SVRCOD, svrcod);
2508        }
2509 
2510        return svrcod;
2511    }
2512 
2513    protected NetSqlca parseSQLCARD(Sqlca[] rowsetSqlca) throws DisconnectException {
2514        parseLengthAndMatchCodePoint(CodePoint.SQLCARD);
2515        int ddmLength = getDdmLength();
2516        ensureBLayerDataInBuffer(ddmLength);
2517        NetSqlca netSqlca = parseSQLCARDrow(rowsetSqlca);
2518        adjustLengths(getDdmLength());
2519        return netSqlca;
2520    }
2521    //--------------------------parse FDOCA objects------------------------
2522 
2523    // SQLCARD : FDOCA EARLY ROW
2524    // SQL Communications Area Row Description
2525    //
2526    // FORMAT FOR ALL SQLAM LEVELS
2527    //   SQLCAGRP; GROUP LID 0x54; ELEMENT TAKEN 0(all); REP FACTOR 1
2528 
2529    NetSqlca parseSQLCARDrow(Sqlca[] rowsetSqlca) throws DisconnectException {
2530        return parseSQLCAGRP(rowsetSqlca);
2531    }
2532 
2533    // SQLNUMROW : FDOCA EARLY ROW
2534    // SQL Number of Elements Row Description
2535    //
2536    // FORMAT FOR SQLAM LEVELS
2537    //   SQLNUMGRP; GROUP LID 0x58; ELEMENT TAKEN 0(all); REP FACTOR 1
2538    int parseSQLNUMROW() throws DisconnectException {
2539        return parseSQLNUMGRP();
2540    }
2541 
2542    int parseFastSQLNUMROW() throws DisconnectException {
2543        return parseFastSQLNUMGRP();
2544    }
2545 
2546    // SQLNUMGRP : FDOCA EARLY GROUP
2547    // SQL Number of Elements Group Description
2548    //
2549    // FORMAT FOR ALL SQLAM LEVELS
2550    //   SQLNUM; PROTOCOL TYPE I2; ENVLID 0x04; Length Override 2
2551    private int parseSQLNUMGRP() throws DisconnectException {
2552        return readShort();
2553    }
2554 
2555    private int parseFastSQLNUMGRP() throws DisconnectException {
2556        return readFastShort();
2557    }
2558 
2559    // SQLCAGRP : FDOCA EARLY GROUP
2560    // SQL Communcations Area Group Description
2561    //
2562    // FORMAT FOR SQLAM <= 6
2563    //   SQLCODE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2564    //   SQLSTATE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 5
2565    //   SQLERRPROC; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
2566    //   SQLCAXGRP; PROTOCOL TYPE N-GDA; ENVLID 0x52; Length Override 0
2567    //
2568    // FORMAT FOR SQLAM >= 7
2569    //   SQLCODE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2570    //   SQLSTATE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 5
2571    //   SQLERRPROC; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
2572    //   SQLCAXGRP; PROTOCOL TYPE N-GDA; ENVLID 0x52; Length Override 0
2573    //   SQLDIAGGRP; PROTOCOL TYPE N-GDA; ENVLID 0x56; Length Override 0
2574    private NetSqlca parseSQLCAGRP(Sqlca[] rowsetSqlca) throws DisconnectException {
2575        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
2576            return null;
2577        }
2578 
2579        int sqlcode = readFastInt();
2580        byte[] sqlstate = readFastBytes(5);
2581        byte[] sqlerrproc = readFastBytes(8);
2582        NetSqlca netSqlca = null;
2583        
2584        try
2585        {
2586            netSqlca = new NetSqlca(netAgent_.netConnection_,
2587                    sqlcode,
2588                    sqlstate,
2589                    sqlerrproc);
2590        }
2591        catch(SqlException sqle)
2592        {
2593            throw new DisconnectException(netAgent_,sqle);
2594        }
2595        parseSQLCAXGRP(netSqlca);
2596 
2597        if (netAgent_.targetSqlam_ >= NetConfiguration.MGRLVL_7) {
2598            netSqlca.setRowsetRowCount(parseSQLDIAGGRP(rowsetSqlca));
2599        }
2600 
2601        return netSqlca;
2602    }
2603 
2604    // SQLCAXGRP : EARLY FDOCA GROUP
2605    // SQL Communications Area Exceptions Group Description
2606    //
2607    // FORMAT FOR SQLAM <= 6
2608    //   SQLRDBNME; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 18
2609    //   SQLERRD1; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2610    //   SQLERRD2; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2611    //   SQLERRD3; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2612    //   SQLERRD4; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2613    //   SQLERRD5; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2614    //   SQLERRD6; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2615    //   SQLWARN0; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2616    //   SQLWARN1; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2617    //   SQLWARN2; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2618    //   SQLWARN3; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2619    //   SQLWARN4; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2620    //   SQLWARN5; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2621    //   SQLWARN6; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2622    //   SQLWARN7; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2623    //   SQLWARN8; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2624    //   SQLWARN9; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2625    //   SQLWARNA; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2626    //   SQLERRMSG_m; PROTOCOL TYPE VCM; ENVLID 0x3E; Length Override 70
2627    //   SQLERRMSG_s; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 70
2628    //
2629    // FORMAT FOR SQLAM >= 7
2630    //   SQLERRD1; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2631    //   SQLERRD2; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2632    //   SQLERRD3; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2633    //   SQLERRD4; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2634    //   SQLERRD5; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2635    //   SQLERRD6; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2636    //   SQLWARN0; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2637    //   SQLWARN1; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2638    //   SQLWARN2; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2639    //   SQLWARN3; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2640    //   SQLWARN4; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2641    //   SQLWARN5; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2642    //   SQLWARN6; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2643    //   SQLWARN7; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2644    //   SQLWARN8; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2645    //   SQLWARN9; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2646    //   SQLWARNA; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2647    //   SQLRDBNAME; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
2648    //   SQLERRMSG_m; PROTOCOL TYPE VCM; ENVLID 0x3E; Length Override 70
2649    //   SQLERRMSG_s; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 70
2650    private void parseSQLCAXGRP(NetSqlca netSqlca) throws DisconnectException {
2651        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
2652            netSqlca.setContainsSqlcax(false);
2653            return;
2654        }
2655 
2656        if (netAgent_.targetSqlam_ < NetConfiguration.MGRLVL_7) {
2657            // skip over the rdbnam for now
2658            //   SQLRDBNME; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 18
2659            skipFastBytes(18);
2660        }
2661        //   SQLERRD1 to SQLERRD6; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
2662        int[] sqlerrd = new int[6];
2663        readFastIntArray(sqlerrd);
2664 
2665        //   SQLWARN0 to SQLWARNA; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
2666        byte[] sqlwarn = readFastBytes(11);
2667 
2668        if (netAgent_.targetSqlam_ >= NetConfiguration.MGRLVL_7) {
2669            // skip over the rdbnam for now
2670            // SQLRDBNAME; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
2671            parseFastVCS();
2672        }
2673 
2674 
2675        int sqlerrmcCcsid = 0;
2676        byte[] sqlerrmc = readFastLDBytes();
2677        if (sqlerrmc != null) {
2678            sqlerrmcCcsid = netAgent_.targetTypdef_.getCcsidMbc();
2679            skipFastBytes(2);
2680        } else {
2681            sqlerrmc = readFastLDBytes();
2682            sqlerrmcCcsid = netAgent_.targetTypdef_.getCcsidSbc();
2683        }
2684 
2685        netSqlca.setSqlerrd(sqlerrd);
2686        netSqlca.setSqlwarnBytes(sqlwarn);
2687        netSqlca.setSqlerrmcBytes(sqlerrmc, sqlerrmcCcsid); // sqlerrmc may be null
2688    }
2689 
2690    // SQLDIAGGRP : FDOCA EARLY GROUP
2691    // SQL Diagnostics Group Description - Identity 0xD1
2692    // Nullable Group
2693    // SQLDIAGSTT; PROTOCOL TYPE N-GDA; ENVLID 0xD3; Length Override 0
2694    // SQLDIAGCN;  DRFA TYPE N-RLO; ENVLID 0xF6; Length Override 0
2695    // SQLDIAGCI;  PROTOCOL TYPE N-RLO; ENVLID 0xF5; Length Override 0
2696    private long parseSQLDIAGGRP(Sqlca[] rowsetSqlca) throws DisconnectException {
2697        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
2698            return 0;
2699        }
2700 
2701        long row_count = parseSQLDIAGSTT(rowsetSqlca);
2702        parseSQLDIAGCI(rowsetSqlca);
2703        parseSQLDIAGCN();
2704 
2705        return row_count;
2706    }
2707 
2708    // this is duplicated in parseColumnMetaData, but different
2709    // DAGroup under NETColumnMetaData requires a lot more stuffs including
2710    // precsion, scale and other stuffs
2711    protected String parseFastVCS() throws DisconnectException {
2712        // doublecheck what readString() does if the length is 0
2713        return readFastString(readFastUnsignedShort(),
2714                netAgent_.targetTypdef_.getCcsidSbcEncoding());
2715    }
2716    //----------------------non-parsing computational helper methods--------------
2717 
2718    protected boolean checkAndGetReceivedFlag(boolean receivedFlag) throws DisconnectException {
2719        if (receivedFlag) {
2720            // this method will throw a disconnect exception if
2721            // the received flag is already true;
2722            doSyntaxrmSemantics(CodePoint.SYNERRCD_DUP_OBJ_PRESENT);
2723        }
2724        return true;
2725    }
2726 
2727    protected void checkRequiredObjects(boolean receivedFlag) throws DisconnectException {
2728        if (!receivedFlag) {
2729            doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
2730        }
2731    }
2732 
2733    protected void checkRequiredObjects(boolean receivedFlag,
2734                                        boolean receivedFlag2) throws DisconnectException {
2735        if (!receivedFlag || !receivedFlag2) {
2736            doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
2737        }
2738    }
2739 
2740    protected void checkRequiredObjects(boolean receivedFlag,
2741                                        boolean receivedFlag2,
2742                                        boolean receivedFlag3) throws DisconnectException {
2743        if (!receivedFlag || !receivedFlag2 || !receivedFlag3) {
2744            doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
2745        }
2746    }
2747 
2748    protected void checkRequiredObjects(boolean receivedFlag,
2749                                        boolean receivedFlag2,
2750                                        boolean receivedFlag3,
2751                                        boolean receivedFlag4) throws DisconnectException {
2752        if (!receivedFlag || !receivedFlag2 || !receivedFlag3 || !receivedFlag4) {
2753            doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
2754        }
2755    }
2756 
2757    protected void checkRequiredObjects(boolean receivedFlag,
2758                                        boolean receivedFlag2,
2759                                        boolean receivedFlag3,
2760                                        boolean receivedFlag4,
2761                                        boolean receivedFlag5,
2762                                        boolean receivedFlag6) throws DisconnectException {
2763        if (!receivedFlag || !receivedFlag2 || !receivedFlag3 || !receivedFlag4 ||
2764                !receivedFlag5 || !receivedFlag6) {
2765            doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
2766        }
2767 
2768    }
2769 
2770    protected void checkRequiredObjects(boolean receivedFlag,
2771                                        boolean receivedFlag2,
2772                                        boolean receivedFlag3,
2773                                        boolean receivedFlag4,
2774                                        boolean receivedFlag5,
2775                                        boolean receivedFlag6,
2776                                        boolean receivedFlag7) throws DisconnectException {
2777        if (!receivedFlag || !receivedFlag2 || !receivedFlag3 || !receivedFlag4 ||
2778                !receivedFlag5 || !receivedFlag6 || !receivedFlag7) {
2779            doSyntaxrmSemantics(CodePoint.SYNERRCD_REQ_OBJ_NOT_FOUND);
2780        }
2781    }
2782 
2783    // These methods are "private protected", which is not a recognized java privilege,
2784    // but means that these methods are private to this class and to subclasses,
2785    // and should not be used as package-wide friendly methods.
2786 
2787    protected void doObjnsprmSemantics(int codePoint) throws DisconnectException {
2788        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2789            new ClientMessageId(SQLState.DRDA_DDM_OBJECT_NOT_SUPPORTED),
2790            Integer.toHexString(codePoint)));
2791    }
2792 
2793    // Also called by NetStatementReply.
2794    protected void doPrmnsprmSemantics(int codePoint) throws DisconnectException {
2795        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2796            new ClientMessageId(SQLState.DRDA_DDM_PARAM_NOT_SUPPORTED),
2797            Integer.toHexString(codePoint)));
2798    }
2799 
2800    // Also called by NetStatementReply
2801    void doValnsprmSemantics(int codePoint, int value) throws DisconnectException {
2802        doValnsprmSemantics(codePoint, Integer.toString(value));
2803    }
2804 
2805    void doValnsprmSemantics(int codePoint, String value) throws DisconnectException {
2806 
2807        // special case the FDODTA codepoint not to disconnect.
2808        if (codePoint == CodePoint.FDODTA) {
2809            agent_.accumulateReadException(new SqlException(agent_.logWriter_,
2810                new ClientMessageId(SQLState.DRDA_DDM_PARAMVAL_NOT_SUPPORTED),
2811                Integer.toHexString(codePoint)));
2812            return;
2813        }
2814 
2815        if (codePoint == CodePoint.CCSIDSBC ||
2816                codePoint == CodePoint.CCSIDDBC ||
2817                codePoint == CodePoint.CCSIDMBC) {
2818            // the server didn't like one of the ccsids.
2819            // the message should reflect the error in question.  right now these values
2820            // will be hard coded but this won't be correct if our driver starts sending
2821            // other values to the server.  In order to pick up the correct values,
2822            // a little reorganization may need to take place so that this code (or
2823            // whatever code sets the message) has access to the correct values.
2824            int cpValue = 0;
2825            switch (codePoint) {
2826            case CodePoint.CCSIDSBC:
2827                cpValue = netAgent_.typdef_.getCcsidSbc();
2828                break;
2829            case CodePoint.CCSIDDBC:
2830                cpValue = netAgent_.typdef_.getCcsidDbc();
2831                break;
2832            case CodePoint.CCSIDMBC:
2833                cpValue = netAgent_.typdef_.getCcsidSbc();
2834                break;
2835            default:
2836                // should never be in this default case...
2837                cpValue = 0;
2838                break;
2839            }
2840            agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2841                new ClientMessageId(SQLState.DRDA_NO_AVAIL_CODEPAGE_CONVERSION),
2842                new Integer(cpValue), value));
2843            return;
2844        }
2845        // the problem isn't with one of the ccsid values so...
2846 
2847        // Returning more information would
2848        // require rearranging this code a little.
2849        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2850            new ClientMessageId(SQLState.DRDA_DDM_PARAMVAL_NOT_SUPPORTED),
2851            Integer.toHexString(codePoint)));
2852    }
2853 
2854    void doDtamchrmSemantics() throws DisconnectException {
2855        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2856            new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
2857                msgutil_.getTextMessage(MessageId.CONN_DRDA_DTARMCHRM)));
2858    }
2859 
2860    // Messages
2861    //  SQLSTATE : 58010
2862    //      Execution failed due to a distribution protocol error that
2863    //      will affect the successful execution of subsequent DDM commands
2864    //      or SQL statements.
2865    //  SQLCODE : -30021
2866    //       Execution failed because of a Distributed Protocol
2867    //       Error that will affect the successful execution of subsequent
2868    //       commands and SQL statements: Manager <manager> at Level
2869    //       <level> not supported.
2870    //
2871    //       A system erro occurred that prevented successful connection
2872    //       of the application to the remote database.  This message (SQLCODE)
2873    //       is producted for SQL CONNECT statement.
2874    private void doMgrlvlrmSemantics(String manager, String level) throws DisconnectException {
2875        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2876            new ClientMessageId(SQLState.DRDA_MGRLVLRM),
2877            manager, level));
2878    }
2879 
2880    private void doMgrlvlrmSemantics(int manager, int level) throws DisconnectException {
2881        doMgrlvlrmSemantics("0x" + Integer.toHexString(manager),
2882                "0x" + Integer.toHexString(level));
2883    }
2884 
2885    private void doMgrlvlrmSemantics(int[] nameList, int[] levelList) throws DisconnectException {
2886        StringBuffer managerNames = new StringBuffer(100);
2887        StringBuffer managerLevels = new StringBuffer(100);
2888 
2889        int count = nameList.length;
2890        for (int i = 0; i < count; i++) {
2891            managerNames.append("0x");
2892            managerNames.append(nameList[i]);
2893            managerLevels.append("0x");
2894            managerLevels.append(levelList[i]);
2895            if (i != (count - 1)) {
2896                managerNames.append(",");
2897                managerLevels.append(",");
2898            }
2899        }
2900        doMgrlvlrmSemantics(managerNames.toString(), managerLevels.toString());
2901    }
2902 
2903    // The client can detect that a conversational protocol error has occurred.
2904    // This can also be detected at the server in which case a PRCCNVRM is returned.
2905    // The Conversation Protocol Error Code, PRCCNVRM, describes the various errors.
2906    //
2907    // Note: Not all of these may be valid at the client.  See descriptions for
2908    // which ones make sense for client side errors/checks.
2909    // Conversation Error Code                  Description of Error
2910    // -----------------------                  --------------------
2911    // 0x01                                     RPYDSS received by target communications manager.
2912    // 0x02                                     Multiple DSSs sent without chaining or multiple
2913    //                                          DSS chains sent.
2914    // 0x03                                     OBJDSS sent when not allowed.
2915    // 0x04                                     Request correlation identifier of an RQSDSS
2916    //                                          is less than or equal to the previous
2917    //                                          RQSDSS's request correlatio identifier in the chain.
2918    // 0x05                                     Request correlation identifier of an OBJDSS
2919    //                                          does not equal the request correlation identifier
2920    //                                          of the preceding RQSDSS.
2921    // 0x06                                     EXCSAT was not the first command after the connection
2922    //                                          was established.
2923    // 0x10                                     ACCSEC or SECCHK command sent in wrong state.
2924    // 0x11                                     SYNCCTL or SYNCRSY command is used incorrectly.
2925    // 0x12                                     RDBNAM mismatch between ACCSEC, SECCHK, and ACCRDB.
2926    // 0x13                                     A command follows one that returned EXTDTAs as reply object.
2927    //
2928    // When the client detects these errors, it will be handled as if a PRCCNVRM is returned
2929    // from the server.  In this PRCCNVRM case, PROTOCOL architects an SQLSTATE of 58008 or 58009
2930    // depening of the SVRCOD.  In this case, a 58009 will always be returned.
2931    // Messages
2932    // SQLSTATE : 58009
2933    //     Execution failed due to a distribution protocol error that caused deallocation of the conversation.
2934    //     SQLCODE : -30020
2935    //     Execution failed because of a Distributed Protocol
2936    //         Error that will affect the successful execution of subsequent
2937    //         commands and SQL statements: Reason Code <reason-code>.
2938    //      Some possible reason codes include:
2939    //      121C Indicates that the user is not authorized to perform the requested command.
2940    //      1232 The command could not be completed because of a permanent error.
2941    //          In most cases, the server will be in the process of an abend.
2942    //      220A The target server has received an invalid data description.
2943    //          If a user SQLDA is specified, ensure that the fields are
2944    //          initialized correctly. Also, ensure that the length does not
2945    //          exceed the maximum allowed length for the data type being used.
2946    //
2947    //      The command or statement cannot be processed.  The current
2948    //          transaction is rolled back and the application is disconnected
2949    //          from the remote database.
2950    protected void doPrccnvrmSemantics(int conversationProtocolErrorCode) throws DisconnectException {
2951        // we may need to map the conversation protocol error code, prccnvcd, to some kind
2952        // of reason code.  For now just return the prccnvcd as the reason code
2953        agent_.accumulateChainBreakingReadExceptionAndThrow(new DisconnectException(agent_,
2954            new ClientMessageId(SQLState.DRDA_CONNECTION_TERMINATED),
2955                msgutil_.getTextMessage(MessageId.CONN_DRDA_PRCCNVRM, 
2956                    Integer.toHexString(conversationProtocolErrorCode))));
2957    }
2958 
2959    // SQL Diagnostics Condition Token Array - Identity 0xF7
2960    // SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
2961    // SQLTOKROW; ROW LID 0xE7; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
2962    void parseSQLDCTOKS() throws DisconnectException {
2963        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
2964            return;
2965        }
2966        int num = parseFastSQLNUMROW();
2967        for (int i = 0; i < num; i++) {
2968            parseSQLTOKROW();
2969        }
2970    }
2971 
2972    // SQL Diagnostics Condition Information Array - Identity 0xF5
2973    // SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
2974    // SQLDCIROW; ROW LID 0xE5; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
2975    private void parseSQLDIAGCI(Sqlca[] rowsetSqlca) throws DisconnectException {
2976        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
2977            return;
2978        }
2979        int num = parseFastSQLNUMROW();
2980        if (num == 0) {
2981            resetRowsetSqlca(rowsetSqlca, 0);
2982        }
2983 
2984        // lastRow is the row number for the last row that had a non-null SQLCA.
2985        int lastRow = 1;
2986        for (int i = 0; i < num; i++) {
2987            lastRow = parseSQLDCROW(rowsetSqlca, lastRow);
2988        }
2989        resetRowsetSqlca(rowsetSqlca, lastRow + 1);
2990    }
2991 
2992    // SQL Diagnostics Connection Array - Identity 0xF6
2993    // SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
2994    // SQLCNROW;  ROW LID 0xE6; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
2995    private void parseSQLDIAGCN() throws DisconnectException {
2996        if (readUnsignedByte() == CodePoint.NULLDATA) {
2997            return;
2998        }
2999        int num = parseFastSQLNUMROW();
3000        for (int i = 0; i < num; i++) {
3001            parseSQLCNROW();
3002        }
3003    }
3004 
3005    // SQL Diagnostics Connection Row - Identity 0xE6
3006    // SQLCNGRP; GROUP LID 0xD6; ELEMENT TAKEN 0(all); REP FACTOR 1
3007    private void parseSQLCNROW() throws DisconnectException {
3008        parseSQLCNGRP();
3009    }
3010 
3011    // SQL Diagnostics Condition Row - Identity 0xE5
3012    // SQLDCGRP; GROUP LID 0xD5; ELEMENT TAKEN 0(all); REP FACTOR 1
3013    private int parseSQLDCROW(Sqlca[] rowsetSqlca, int lastRow) throws DisconnectException {
3014        return parseSQLDCGRP(rowsetSqlca, lastRow);
3015    }
3016 
3017    // SQL Diagnostics Token Row - Identity 0xE7
3018    // SQLTOKGRP; GROUP LID 0xD7; ELEMENT TAKEN 0(all); REP FACTOR 1
3019    private void parseSQLTOKROW() throws DisconnectException {
3020        parseSQLTOKGRP();
3021    }
3022 
3023    // check on SQLTOKGRP format
3024    private void parseSQLTOKGRP() throws DisconnectException {
3025        skipFastNVCMorNVCS();
3026    }
3027 
3028    // SQL Diagnostics Statement Group Description - Identity 0xD3
3029    // Nullable Group
3030    // SQLDSFCOD; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3031    // SQLDSCOST; PROTOCOL TYPE I4; ENVLID 0X02; Length Override 4
3032    // SQLDSLROW; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3033    // SQLDSNPM; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3034    // SQLDSNRS; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3035    // SQLDSRNS; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3036    // SQLDSDCOD; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3037    // SQLDSROWC; PROTOCOL TYPE FD; ENVLID 0x0E; Length Override 31
3038    // SQLDSNROW; PROTOCOL TYPE FD; ENVLID 0x0E; Length Override 31
3039    // SQLDSROWCS; PROTOCOL TYPE FD; ENVLID 0x0E; Length Override 31
3040    // SQLDSACON; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3041    // SQLDSACRH; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3042    // SQLDSACRS; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3043    // SQLDSACSL; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3044    // SQLDSACSE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3045    // SQLDSACTY; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3046    // SQLDSCERR; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3047    // SQLDSMORE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3048    private long parseSQLDIAGSTT(Sqlca[] rowsetSqlca) throws DisconnectException {
3049        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
3050            return 0;
3051        }
3052        int sqldsFcod = readFastInt(); // FUNCTION_CODE
3053        int sqldsCost = readFastInt(); // COST_ESTIMATE
3054        int sqldsLrow = readFastInt(); // LAST_ROW
3055 
3056        skipFastBytes(16);
3057 
3058        long sqldsRowc = readFastLong(); // ROW_COUNT
3059 
3060        skipFastBytes(24);
3061 
3062        return sqldsRowc;
3063    }
3064 
3065    // SQL Diagnostics Connection Group Description - Identity 0xD6
3066    // Nullable
3067    //
3068    // SQLCNSTATE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3069    // SQLCNSTATUS; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3070    // SQLCNATYPE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3071    // SQLCNETYPE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 1
3072    // SQLCNPRDID; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
3073    // SQLCNRDB; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
3074    // SQLCNCLASS; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
3075    // SQLCNAUTHID; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
3076    private void parseSQLCNGRP() throws DisconnectException {
3077        skipBytes(18);
3078        String sqlcnRDB = parseFastVCS();    // RDBNAM
3079        String sqlcnClass = parseFastVCS();  // CLASS_NAME
3080        String sqlcnAuthid = parseFastVCS(); // AUTHID
3081    }
3082 
3083    // SQL Diagnostics Condition Group Description
3084    //
3085    // SQLDCCODE; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3086    // SQLDCSTATE; PROTOCOL TYPE FCS; ENVLID Ox30; Lengeh Override 5
3087    // SQLDCREASON; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3088    // SQLDCLINEN; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3089    // SQLDCROWN; PROTOCOL TYPE FD; ENVLID 0x0E; Lengeh Override 31
3090    // SQLDCER01; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3091    // SQLDCER02; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3092    // SQLDCER03; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3093    // SQLDCER04; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3094    // SQLDCPART; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3095    // SQLDCPPOP; PROTOCOL TYPE I4; ENVLID 0x02; Length Override 4
3096    // SQLDCMSGID; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 10
3097    // SQLDCMDE; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 8
3098    // SQLDCPMOD; PROTOCOL TYPE FCS; ENVLID 0x30; Length Override 5
3099    // SQLDCRDB; PROTOCOL TYPE VCS; ENVLID 0x32; Length Override 255
3100    // SQLDCTOKS; PROTOCOL TYPE N-RLO; ENVLID 0xF7; Length Override 0
3101    // SQLDCMSG_m; PROTOCOL TYPE NVMC; ENVLID 0x3F; Length Override 32672
3102    // SQLDCMSG_S; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 32672
3103    // SQLDCCOLN_m; PROTOCOL TYPE NVCM ; ENVLID 0x3F; Length Override 255
3104    // SQLDCCOLN_s; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3105    // SQLDCCURN_m; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3106    // SQLDCCURN_s; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3107    // SQLDCPNAM_m; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3108    // SQLDCPNAM_s; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3109    // SQLDCXGRP; PROTOCOL TYPE N-GDA; ENVLID 0xD3; Length Override 1
3110    private int parseSQLDCGRP(Sqlca[] rowsetSqlca, int lastRow) throws DisconnectException {
3111        int sqldcCode = readFastInt(); // SQLCODE
3112        String sqldcState = readFastString(5, Typdef.UTF8ENCODING); // SQLSTATE
3113        int sqldcReason = readFastInt();  // REASON_CODE
3114        int sqldcLinen = readFastInt(); // LINE_NUMBER
3115        int sqldcRown = (int) readFastLong(); // ROW_NUMBER
3116 
3117        // save +20237 in the 0th entry of the rowsetSqlca's.
3118        // this info is going to be used when a subsequent fetch prior is issued, and if already
3119        // received a +20237 then we've gone beyond the first row and there is no need to
3120        // flow another fetch to the server.
3121        if (sqldcCode == 20237) {
3122            rowsetSqlca[0] = new NetSqlca(netAgent_.netConnection_,
3123                    sqldcCode,
3124                    sqldcState,
3125                    null);
3126        } else {
3127            if (rowsetSqlca[sqldcRown] != null) {
3128                rowsetSqlca[sqldcRown].resetRowsetSqlca(netAgent_.netConnection_,
3129                        sqldcCode,
3130                        sqldcState,
3131                        null);
3132            } else {
3133                rowsetSqlca[sqldcRown] = new NetSqlca(netAgent_.netConnection_,
3134                        sqldcCode,
3135                        sqldcState,
3136                        null);
3137            }
3138        }
3139 
3140        // reset all entries between lastRow and sqldcRown to null
3141        for (int i = lastRow + 1; i < sqldcRown; i++) {
3142            rowsetSqlca[i] = null;
3143        }
3144 
3145        skipFastBytes(47);
3146        String sqldcRdb = parseFastVCS(); // RDBNAM
3147        // skip the tokens for now, since we already have the complete message.
3148        parseSQLDCTOKS(); // MESSAGE_TOKENS
3149        String sqldcMsg = parseFastNVCMorNVCS(); // MESSAGE_TEXT
3150 
3151        // skip the following for now.
3152        skipFastNVCMorNVCS();  // COLUMN_NAME
3153        skipFastNVCMorNVCS();  // PARAMETER_NAME
3154        skipFastNVCMorNVCS();  // EXTENDED_NAMES
3155 
3156        parseSQLDCXGRP(); // SQLDCXGRP
3157        return sqldcRown;
3158    }
3159 
3160    // SQL Diagnostics Extended Names Group Description - Identity 0xD5
3161    // Nullable
3162    //
3163    // SQLDCXRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3164    // SQLDCXSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3165    // SQLDCXNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3166    // SQLDCXTBLN_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3167    // SQLDCXRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3168    // SQLDCXSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3169    // SQLDCXNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3170    // SQLDCXTBLN_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3171    //
3172    // SQLDCXCRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3173    // SQLDCXCSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3174    // SQLDCXCNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3175    // SQLDCXCRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3176    // SQLDCXCSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3177    // SQLDCXCNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3178    //
3179    // SQLDCXRRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3180    // SQLDCXRSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3181    // SQLDCXRNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3182    // SQLDCXRRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3183    // SQLDCXRSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3184    // SQLDCXRNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3185    //
3186    // SQLDCXTRDB_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3187    // SQLDCXTSCH_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3188    // SQLDCXTNAM_m ; PROTOCOL TYPE NVCM; ENVLID 0x3F; Length Override 255
3189    // SQLDCXTRDB_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3190    // SQLDCXTSCH_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3191    // SQLDCXTNAM_s ; PROTOCOL TYPE NVCS; ENVLID 0x33; Length Override 255
3192    private void parseSQLDCXGRP() throws DisconnectException {
3193        if (readFastUnsignedByte() == CodePoint.NULLDATA) {
3194            return;
3195        }
3196        skipFastNVCMorNVCS();  // OBJECT_RDBNAM
3197        skipFastNVCMorNVCS();  // OBJECT_SCHEMA
3198        skipFastNVCMorNVCS();  // SPECIFIC_NAME
3199        skipFastNVCMorNVCS();  // TABLE_NAME
3200        String sqldcxCrdb = parseFastVCS();        // CONSTRAINT_RDBNAM
3201        skipFastNVCMorNVCS();  // CONSTRAINT_SCHEMA
3202        skipFastNVCMorNVCS();  // CONSTRAINT_NAME
3203        parseFastVCS();        // ROUTINE_RDBNAM
3204        skipFastNVCMorNVCS();  // ROUTINE_SCHEMA
3205        skipFastNVCMorNVCS();  // ROUTINE_NAME
3206        parseFastVCS();        // TRIGGER_RDBNAM
3207        skipFastNVCMorNVCS();  // TRIGGER_SCHEMA
3208        skipFastNVCMorNVCS();  // TRIGGER_NAME
3209    }
3210 
3211    private String parseFastNVCMorNVCS() throws DisconnectException {
3212        String stringToBeSet = null;
3213        int vcm_length = 0;
3214        int vcs_length = 0;
3215        if (readFastUnsignedByte() != CodePoint.NULLDATA) {
3216            vcm_length = readFastUnsignedShort();
3217            if (vcm_length > 0) {
3218                stringToBeSet = readFastString(vcm_length, netAgent_.targetTypdef_.getCcsidMbcEncoding());
3219            }
3220            if (readFastUnsignedByte() != CodePoint.NULLDATA) {
3221                agent_.accumulateChainBreakingReadExceptionAndThrow(
3222                    new DisconnectException(agent_,
3223                        new ClientMessageId(
3224                            SQLState.NET_NVCM_NVCS_BOTH_NON_NULL)));
3225            }
3226        } else {
3227            if (readFastUnsignedByte() != CodePoint.NULLDATA) {
3228                vcs_length = readFastUnsignedShort();
3229                if (vcs_length > 0) {
3230                    stringToBeSet = readFastString(vcs_length, netAgent_.targetTypdef_.getCcsidSbcEncoding());
3231                }
3232            }
3233        }
3234        return stringToBeSet;
3235    }
3236 
3237    private void skipFastNVCMorNVCS() throws DisconnectException {
3238        int vcm_length = 0;
3239        int vcs_length = 0;
3240        if (readFastUnsignedByte() != CodePoint.NULLDATA) {
3241            vcm_length = readFastUnsignedShort();
3242            if (vcm_length > 0)
3243            //stringToBeSet = readString (vcm_length, netAgent_.targetTypdef_.getCcsidMbcEncoding());
3244            {
3245                skipFastBytes(vcm_length);
3246            }
3247            if (readFastUnsignedByte() != CodePoint.NULLDATA) {
3248                agent_.accumulateChainBreakingReadExceptionAndThrow(
3249                    new DisconnectException(agent_,
3250                        new ClientMessageId(
3251                            SQLState.NET_NVCM_NVCS_BOTH_NON_NULL)));
3252            }
3253        } else {
3254            if (readFastUnsignedByte() != CodePoint.NULLDATA) {
3255                vcs_length = readFastUnsignedShort();
3256                if (vcs_length > 0)
3257                //stringToBeSet = readString (vcs_length, netAgent_.targetTypdef_.getCcsidSbcEncoding());
3258                {
3259                    skipFastBytes(vcs_length);
3260                }
3261            }
3262        }
3263    }
3264 
3265    void resetRowsetSqlca(Sqlca[] rowsetSqlca, int row) {
3266        // rowsetSqlca can be null.
3267        int count = ((rowsetSqlca == null) ? 0 : rowsetSqlca.length);
3268        for (int i = row; i < count; i++) {
3269            rowsetSqlca[i] = null;
3270        }
3271    }
3272}
3273 
3274 
3275 

[all classes][org.apache.derby.client.net]
EMMA 2.0.5312 (C) Vladimir Roubtsov