Class DRDAConnThread

  • All Implemented Interfaces:
    java.lang.Runnable

    class DRDAConnThread
    extends java.lang.Thread
    This class translates DRDA protocol from an application requester to JDBC for Derby and then translates the results from Derby to DRDA for return to the application requester.
    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      private static class  DRDAConnThread.PublicBufferOutputStream  
      • Nested classes/interfaces inherited from class java.lang.Thread

        java.lang.Thread.State, java.lang.Thread.UncaughtExceptionHandler
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      protected void agentError​(java.lang.String msg)
      Agent error - something very bad happened
      private void badObjectLength​(int codePoint)
      Object length not allowed
      private java.lang.String buildDataTruncationSqlerrmc​(java.sql.DataTruncation dt)
      Build the SQLERRMC for a java.sql.DataTruncation warning.
      private java.lang.String buildPreformattedSqlerrmc​(java.sql.SQLException se)
      Build preformatted SQLException text for severe exceptions or SQLExceptions that are not Derby exceptions.
      protected java.lang.String buildRuntimeInfo​(java.lang.String indent, LocalizedResource localLangUtil)  
      private java.lang.String buildSqlerrmc​(java.sql.SQLException se)
      Create error message or message argements to return to client.
      private java.lang.String buildTokenizedSqlerrmc​(java.sql.SQLException se)
      Build Tokenized SQLERRMC to just send the tokenized arguments to the client.
      private boolean canIgnoreStmt​(java.lang.String stmt)  
      private void checkLength​(int codepoint, int reqlen)
      Check that the length is equal to the required length for this codepoint
      private void checkRequired​(int codePoint)
      Check whether we have seen all the required code points
      private void checkValidTypDefNam​(java.lang.String typdefnam)
      check that the given typdefnam is acceptable
      private void checkWarning​(java.sql.Connection conn, java.sql.Statement stmt, java.sql.ResultSet rs, long updateCount, boolean alwaysSend, boolean sendWarn)
      Check SQLWarning and write SQLCARD as needed.
      private void cleanUpAndCloseResultSet​(DRDAStatement stmt, java.sql.SQLException sqle, int writerMark)
      Cleans up and closes a result set if an exception is thrown when collecting QRYDTA in response to OPNQRY or CNTQRY.
      protected void close()
      Close DRDA connection thread
      private boolean closed()
      Test if DRDA connection thread is closed
      private void closeSession()
      Close the current session
      private static void closeStream​(java.io.InputStream stream)
      Close a stream.
      protected void codePointNotSupported​(int codePoint)
      Don't support this code point
      private static java.io.InputStream convertAsByteArrayInputStream​(EXTDTAReaderInputStream stream)  
      private java.lang.String convertToHexString​(byte[] buf)
      convert byte array to a Hex string
      private void copyToRequired​(int[] req)
      Copy a list of required code points to template for checking
      private void doneData​(DRDAStatement stmt, java.sql.ResultSet rs)
      Done data Send SQLCARD for the end of the data
      private void errorInChain​(java.sql.SQLException e)
      If there's a severe error in the DDM chain, and if the header indicates "terminate chain on error", we stop processing further commands in the chain nor do we send any reply for them.
      private void exchangeServerAttributes()
      Exchange server attributes with application requester
      private void finalizeChain()
      Finalize the current DSS chain and send it if needed.
      private static java.lang.Object findService​(java.lang.String factoryInterface, java.lang.String serviceName)
      Privileged service lookup.
      private java.lang.String formatDate​(java.sql.Date date)
      Convert a java.sql.Date to a string with the format expected by the client.
      private java.lang.String formatTime​(java.sql.Time time)
      Convert a java.sql.Time to a string with the format expected by the client.
      private java.lang.String formatTimestamp​(java.sql.Timestamp ts)
      Convert a java.sql.Timestamp to a string with the format expected by the client.
      private int getByteOrder()  
      (package private) long getBytesRead()  
      (package private) long getBytesWritten()  
      private int getConnFromDatabaseName()
      Get connection from a database name Username and password is verified by making a connection to the database
      protected int getCorrelationID()
      Get correlation id
      protected byte[] getCrrtkn()
      Get correlation token
      protected Database getDatabase()
      Get Database we are working on
      protected java.lang.String getDbName()
      Get database name
      private int getExceptionSeverity​(java.sql.SQLException e)
      Translate from Derby exception severity to SVRCOD
      private java.util.Calendar getGMTCalendar()
      Get a Calendar instance with time zone set to GMT.
      protected java.io.InputStream getInputStream()
      Get input stream
      private boolean getLogConnections()
      Get whether connections are logged
      private static ModuleFactory getMonitor()
      Privileged Monitor lookup.
      private java.lang.Object getObjectForWriteFdoca​(java.sql.CallableStatement cs, int index, int drdaType)
      Get the value of an output parameter of the specified type from a CallableStatement, in a form suitable for being writted by writeFdocaVal(int, java.lang.Object, int, int, int, boolean, org.apache.derby.impl.drda.DRDAStatement, boolean).
      private java.lang.Object getObjectForWriteFdoca​(java.sql.ResultSet rs, int index, int drdaType)
      Get a column value of the specified type from a ResultSet, in a form suitable for being writted by writeFdocaVal(int, java.lang.Object, int, int, int, boolean, org.apache.derby.impl.drda.DRDAStatement, boolean).
      protected java.io.OutputStream getOutputStream()
      Get output stream
      private static byte[] getProductIDBytes()
      Get product id as bytes
      private int getRdbAccessErrorCodePoint()  
      protected DDMReader getReader()
      get DDMReader
      protected NetworkServerControlImpl getServer()
      Get server
      protected Session getSession()
      Get session we are working on
      private int getSqlCode​(java.sql.SQLException e)
      Get the SQLCODE to send for an exception or a warning.
      private long getTimeSlice()
      Get time slice value for length of time to work on a session
      protected DDMWriter getWriter()
      get DDMWriter
      private void handleException​(java.lang.Exception e)
      Handle Exceptions - write error protocol if appropriate and close session or thread as appropriate
      (package private) boolean hasSession()  
      private void initialize()
      Initialize class
      private void initializeDatabase​(java.lang.String dbname)
      Create a new database and intialize the DRDAConnThread database.
      private void initializeForSession()
      Initialize for a new session
      private void invalidClient​(java.lang.String prdid)
      Invalid non-derby client tried to connect.
      protected void invalidCodePoint​(int codePoint)
      Invalid codepoint for this command
      private void invalidValue​(int codePoint)
      Invalid value for this code point
      private boolean isAuthenticationException​(java.sql.SQLException sqlException)
      There are multiple reasons for not getting a connection, and all these should throw SQLExceptions with SQL state 08004 according to the SQL standard.
      protected void markCommunicationsFailure​(java.lang.Exception e, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4)
      Indicate a communications failure.
      protected void markCommunicationsFailure​(java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4)
      Indicate a communications failure
      protected void missingCodePoint​(int codePoint)
      Missing code point
      private void padInt​(char[] buf, int offset, int length, int value)
      Insert an integer into a char array and pad it with leading zeros if its string representation is shorter than length characters.
      private int parseACCRDB()
      Parse access RDB Instance variables RDBACCCL - RDB Access Manager Class - required must be SQLAM CRRTKN - Correlation Token - required RDBNAM - Relational database name -required PRDID - Product specific identifier - required TYPDEFNAM - Data Type Definition Name -required TYPDEFOVR - Type definition overrides -required RDBALWUPD - RDB Allow Updates optional PRDDTA - Product Specific Data - optional - ignorable STTDECDEL - Statement Decimal Delimiter - optional STTSTRDEL - Statement String Delimiter - optional TRGDFTRT - Target Default Value Return - optional
      private int parseACCSEC()
      Parse Access Security If the target server supports the SECMEC requested by the application requester then a single value is returned and it is identical to the SECMEC value in the ACCSEC command.
      private java.lang.String parseCcsidMBC​(int length)
      Parse mixed character string
      private java.lang.String parseCcsidSBC​(int length)
      Parse single byte character string
      private DRDAStatement parseCLSQRY()
      Parse CLSQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYINSID - Query Instance Identifier - required - level 7 MONITOR - Monitor events - optional.
      private DRDAStatement parseCNTQRY()
      Parse CNTQRY - Continue Query Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required QRYBLKSZ - Query Block Size - required QRYRELSCR - Query Relative Scrolling Action - optional QRYSCRORN - Query Scroll Orientation - optional - level 7 QRYROWNBR - Query Row Number - optional QRYROWSNS - Query Row Sensitivity - optional - level 7 QRYBLKRST - Query Block Reset - optional - level 7 QRYRTNDTA - Query Returns Data - optional - level 7 QRYROWSET - Query Rowset Size - optional - level 7 QRYRFRTBL - Query Refresh Answer Set Table - optional NBRROW - Number of Fetch or Insert Rows - optional MAXBLKEXT - Maximum number of extra blocks - optional RTNEXTDTA - Return of EXTDTA Option - optional MONITOR - Monitor events - optional.
      private void parseCNTQRYobjects​(DRDAStatement stmt)
      Parse CNTQRY objects Instance Variables OUTOVR - Output Override Descriptor - optional
      private java.sql.Date parseDate​(java.lang.String dateString, java.util.Calendar cal)
      Parse a date string as it is received from the client.
      private boolean parseDRDAConnection()  
      private boolean parseDSCSQLSTT()
      Parse DSCSQLSTT - Describe SQL Statement previously prepared Instance Variables TYPSQLDA - sqlda type expected (output or input) RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required MONITOR - Monitor events - optional.
      private java.lang.String parseEncodedString()
      Parse an encoded data string from the Application Requester
      private void parseEXCSAT()
      Parses EXCSAT (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable
      private void parseEXCSAT2()
      Parses EXCSAT2 (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable
      private long parseEXCSQLIMM()
      Parse EXCSQLIMM - Execute Immediate Statement Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required RDBCMTOK - RDB Commit Allowed - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLSTT - SQL Statement -required
      private boolean parseEXCSQLSET()
      Parse EXCSQLSET - Execute Set SQL Environment Instance Variables RDBNAM - relational database name - optional PKGNAMCT - RDB Package Name, Consistency Token - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - required TYPDEFOVR - TYPDEF Overrides - required SQLSTT - SQL Statement - required (at least one; may be more)
      private void parseEXCSQLSETobjects()
      Parse EXCSQLSET objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement - required (a list of at least one) Objects may follow in one DSS or in several DSS chained together.
      private void parseEXCSQLSTT()
      Parse EXCSQLSTT - Execute non-cursor SQL Statement previously prepared Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required OUTEXP - Output expected NBRROW - Number of rows to be inserted if it's an insert PRCNAM - procedure name if specified by host variable, not needed for Derby QRYBLKSZ - query block size MAXRSLCNT - max resultset count MAXBLKEXT - Max number of extra blocks RSLSETFLG - resultset flag RDBCMTOK - RDB Commit Allowed - optional OUTOVROPT - output override option QRYROWSET - Query Rowset Size - Level 7 MONITOR - Monitor events - optional.
      private boolean parseEXCSQLSTTobjects​(DRDAStatement stmt)
      Parse EXCSQLSTT command objects Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLDTA - optional, variable data, specified if prpared statement has input parameters EXTDTA - optional, externalized FD:OCA data OUTOVR - output override descriptor, not allowed for stored procedure calls If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
      private java.lang.String parseEXECSQLIMMobjects()
      Parse EXCSQLIMM objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides SQLSTT - SQL Statement required If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
      private void parseMGRLVLLS​(int time)
      Parse manager levels Instance variables MGRLVL - repeatable, required CODEPOINT CCSIDMGR - CCSID Manager CMNAPPC - LU 6.2 Conversational Communications Manager CMNSYNCPT - SNA LU 6.2 SyncPoint Conversational Communications Manager CMNTCPIP - TCP/IP Communication Manager DICTIONARY - Dictionary RDB - Relational Database RSYNCMGR - Resynchronization Manager SECMGR - Security Manager SQLAM - SQL Application Manager SUPERVISOR - Supervisor SYNCPTMGR - Sync Point Manager VALUE On the second appearance of this codepoint, it can only add managers
      private void parseMONITOR()
      Parse MONITOR DRDA spec says this is optional.
      private java.lang.String parseNOCMorNOCS()
      Parse nullable character mixed byte or nullable character single byte Format 1 byte - null indicator I4 - mixed character length N bytes - mixed character string 1 byte - null indicator I4 - single character length N bytes - single character length string
      private Pkgnamcsn parseOPNQRY()
      Parse OPNQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYBLKSZ - Query Block Size - required QRYBLKCTL - Query Block Protocol Control - optional MAXBLKEXT - Maximum Number of Extra Blocks - optional - default value 0 OUTOVROPT - Output Override Option QRYROWSET - Query Rowset Size - optional - level 7 MONITOR - Monitor events - optional.
      private void parseOPNQRYobjects​(DRDAStatement stmt)
      Parse OPNQRY objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLDTA- SQL Program Variable Data - optional If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
      private void parseOUTOVR​(DRDAStatement stmt)
      Parse OUTOVR - Output Override Descriptor This specifies the output format for data to be returned as output to a SQL statement or as output from a query.
      private int parseOUTOVROPT()
      Parse OUTOVROPT - this indicates whether output description can be overridden on just the first CNTQRY or on any CNTQRY
      private Pkgnamcsn parsePKGNAMCSN()
      Parse PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number
      private java.lang.String parsePKGNAMCT()  
      private int parsePRPSQLSTT()
      Parse PRPSQLSTT - Prepare SQL Statement Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required RTNSQLDA - Return SQL Descriptor Area - optional MONITOR - Monitor events - optional.
      private java.lang.String parsePRPSQLSTTobjects​(DRDAStatement stmt)
      Parse PRPSQLSTT objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement required SQLATTR - Cursor attributes on prepare - optional - level 7 If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement.
      private int parseQRYBLKSZ()
      Parse QRYBLSZ - this gives the maximum size of the query blocks that can be returned to the requester
      private int parseQRYCLSIMP()
      Parse a QRYCLSIMP - Implicitly close non-scrollable cursor after end of data.
      private int parseQRYCLSRLS()  
      private int parseQRYROWSET​(int minVal)
      Parse QRYROWSET - this is the number of rows to return
      private void parseRDBCMTOK()
      Parse RDBCMTOK - tells the database whether to allow commits or rollbacks to be executed as part of the command Since we don't have a SQL commit or rollback command, we will just ignore this for now
      private java.lang.String parseRDBNAM()
      Parse database name
      private int parseSECCHK()
      Parse security check Instance Variables SECMGRNM - security manager name - optional, ignorable SECMEC - security mechanism - required SECTKN - security token - optional, (required if encryption used) PASSWORD - password - optional, (required if security mechanism uses it) NEWPASSWORD - new password - optional, (required if sec mech. uses it) USRID - user id - optional, (required if sec mec. uses it) RDBNAM - database name - optional (required if databases can have own sec.)
      protected void parseSQLATTR​(DRDAStatement stmt)
      Parse SQLATTR - Cursor attributes on prepare This is an encoded string.
      private void parseSQLDTA​(DRDAStatement stmt)
      Parse SQLDTA - SQL program variable data and handle exception.
      private void parseSQLDTA_work​(DRDAStatement stmt)
      Parse SQLDTA - SQL program variable data Instance Variables FDODSC - FD:OCA data descriptor - required FDODTA - FD:OCA data - optional
      private java.lang.String parseSQLSTTDss()
      Parse SQLSTT Dss
      private java.sql.Time parseTime​(java.lang.String timeString, java.util.Calendar cal)
      Parse a time string as it is received from the client.
      private java.sql.Timestamp parseTimestamp​(java.lang.String timeString, java.util.Calendar cal)
      Parse a timestamp string as it is received from the client.
      private java.lang.String parseTYPDEFNAM()
      Parse TYPDEFNAM
      private void parseTYPDEFOVR​(DRDAStatement st)
      Parse Type Defintion Overrides TYPDEF Overrides specifies the Coded Character SET Identifiers (CCSIDs) that are in a named TYPDEF.
      private boolean parseTYPSQLDA()
      Parse TYPSQLDA - Type of the SQL Descriptor Area
      private java.lang.String parseVCMorVCS()
      Parse variable character mixed byte or variable character single byte Format I2 - VCM Length N bytes - VCM value I2 - VCS Length N bytes - VCS value Only 1 of VCM length or VCS length can be non-zero
      private boolean positionCursor​(DRDAStatement stmt, java.sql.ResultSet rs)
      Position cursor for insensitive scrollable cursors
      protected static void println2Log​(java.lang.String dbname, java.lang.String drdaID, java.lang.String msg)
      Print a line to the DB2j log
      private void processCommands()
      Process DRDA commands we can receive once server attributes have been exchanged.
      private boolean processLeftoverQRYDTA​(DRDAStatement stmt)
      Process remainder data resulting from a split.
      private void rdbnamMismatch​(int codePoint)
      Database name given under code point doesn't match previous database names
      private void rdbNotFound​(java.lang.String rdbnam)
      RDB not found
      private void readAndSetAllExtParams​(DRDAStatement stmt, boolean streamLOB)  
      private void readAndSetExtParam​(int i, DRDAStatement stmt, int drdaType, int extLen, boolean streamLOB)
      Read different types of input parameters and set them in PreparedStatement
      private void readAndSetParams​(int i, DRDAStatement stmt, java.sql.ParameterMetaData pmeta)
      Read different types of input parameters and set them in PreparedStatement
      private boolean readBoolean​(int codepoint)
      Read and check a boolean value
      private long readLobLength​(int extLenIndicator)  
      private java.lang.Object readUDT()
      Read a UDT from the stream
      private void removeFromRequired​(int codePoint)
      Remove codepoint from required list
      private void requiredValueNotFound​(int codePoint)
      Required value not found.
      void run()
      Main routine for thread, loops until the thread is closed Gets a session, does work for the session
      private void sendProtocolException​(DRDAProtocolException de)
      Notice the client about a protocol error.
      private void sendUnexpectedException​(java.lang.Exception e)
      Send unpexpected error to the client
      private void sessionInitialState()
      In initial state for a session, determine whether this is a command session or a DRDA protocol session.
      private static void setAsBinaryStream​(DRDAStatement stmt, int index, EXTDTAReaderInputStream stream, boolean streamLOB)
      Sets the specified binary EXTDTA parameter of the embedded statement.
      private static void setAsCharacterStream​(DRDAStatement stmt, int i, EXTDTAReaderInputStream extdtaStream, boolean streamLOB, java.lang.String encoding)
      Sets the specified character EXTDTA parameter of the embedded statement.
      private void setDatabase​(int codePoint)
      Set the current database
      protected void setLogConnections​(boolean value)
      Set logging of connections
      private void setStmtOrDbByteOrder​(boolean setDatabase, DRDAStatement stmt, java.lang.String typDefNam)
      Set a statement or the database' byte order, depending on the arguments
      protected void setTimeSlice​(long value)
      Set time slice value
      static void showmem()
      Show runtime memory
      private void skipRemainder​(boolean onlySkipSameIds)
      Skip remainder of current DSS and all chained DSS'es
      private void splitQRYDTA​(DRDAStatement stmt, int blksize)
      Split QRYDTA into blksize chunks This routine is called if the QRYDTA data will not fit.
      private int svrcodFromSecchkcd​(int securityCheckCode)
      Calculate SVRCOD value from SECCHKCD
      private void switchToEbcdic()
      Switch the DDMWriter and DDMReader to EBCDIC
      private void switchToUtf8()
      Switch the DDMWriter and DDMReader to UTF8 IF supported
      protected void throwSyntaxrm​(int errcd, int cpArg)
      Syntax error
      private void tooBig​(int codePoint)
      Object too big
      private void tooMany​(int codePoint)
      Seen too many of this code point
      protected void trace​(java.lang.String value)
      Send string to console
      private void traceEXTDTARead​(int drdaType, int index, EXTDTAReaderInputStream stream, boolean streamLOB, java.lang.String encoding)
      Sends a trace string to the console when reading an EXTDTA value (if tracing is enabled).
      private int validateSecMecUSRSSBPWD()
      Validate SECMEC_USRSSBPWD (Strong Password Substitute) can be used as DRDA security mechanism.
      private void valueNotSupported​(int codePoint)
      Don't support this value
      private void verifyInOrderACCSEC_SECCHK​(int codePoint, int reqCodePoint)
      Verify that the code point is in the right order
      private void verifyRequiredObject​(int codePoint, int reqCodePoint)
      Verify that the code point is the required code point
      private int verifyUserIdPassword()
      Verify userId and password Username and password is verified by making a connection to the database
      private void writeABNUOWRM()
      Write ABNUOWRM - query process has terminated in an error condition such as deadlock or lock timeout.
      private void writeACCRDBRM​(int svrcod)
      Write Access to RDB Completed Instance Variables SVRCOD - severity code - 0 info, 4 warning -required PRDID - product specific identifier -required TYPDEFNAM - type definition name -required TYPDEFOVR - type definition overrides - required RDBINTTKN - token which can be used to interrupt DDM commands - optional CRRTKN - correlation token - only returned if we didn't get one from requester SRVDGN - server diagnostic information - optional PKGDFTCST - package default character subtype - optional USRID - User ID at the target system - optional SRVLST - Server List
      private void writeACCSECRD​(int securityCheckCode)
      Write ACCSECRD If the security mechanism is known, we just send it back along with the security token if encryption is going to be used.
      private void writeCMDCHKRM​(int severity)
      Write CMDCHKRM Instance Variables SVRCOD - Severity Code - required
      private void writeENDQRYRM​(int svrCod)
      Write ENDQRYRM - query process has terminated in such a manner that the query or result set is now closed.
      private void writeENDUOWRM​(int opType)
      Write ENDUOWRM Instance Variables SVCOD - severity code - WARNING - required UOWDSP - Unit of Work Disposition - required RDBNAM - Relational Database name - optional SRVDGN - Server Diagnostics information - optional
      private void writeEXCSATRD()
      Write reply to EXCSAT command Instance Variables EXTNAM - External Name (optional) MGRLVLLS - Manager Level List (optional) SRVCLSNM - Server Class Name (optional) - used by JCC SRVNAM - Server Name (optional) SRVRLSLV - Server Product Release Level (optional)
      (package private) void writeEXTDTA​(DRDAStatement stmt)  
      protected void writeFdocaVal​(int index, java.lang.Object val, int drdaType, int precision, int scale, boolean valNull, DRDAStatement stmt, boolean isParam)
      Write Fdoca Value to client
      private boolean writeFDODTA​(DRDAStatement stmt)
      This routine places some data into the current QRYDTA block using FDODTA (Formatted Data Object DaTA rules).
      private void writeMGRLEVELS()
      Write manager levels The target server must not provide information for any target managers unless the source explicitly requests it.
      private void writeNullability​(int drdaType, boolean valNull)
      write nullability if this is a nullable drdatype and FDOCA null value if appropriate
      private void writeNullSQLCARDobject()
      Write a null SQLCARD as an object
      private void writeOPNQFLRM​(java.sql.SQLException e)
      Write a OPNQFLRM - Open Query Failure Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required
      private void writeOPNQRYRM​(boolean isDssObject, DRDAStatement stmt)
      Write OPNQRYRM - Open Query Complete Instance Variables SVRCOD - Severity Code - required QRYPRCTYP - Query Protocol Type - required SQLCSRHLD - Hold Cursor Position - optional QRYATTSCR - Query Attribute for Scrollability - optional - level 7 QRYATTSNS - Query Attribute for Sensitivity - optional - level 7 QRYATTUPD - Query Attribute for Updatability -optional - level 7 QRYINSID - Query Instance Identifier - required - level 7 SRVDGN - Server Diagnostic Information - optional
      private void writePBSD()
      Piggy-back any modified session attributes on the current message.
      private void writePKGNAMCSN()  
      private void writePKGNAMCSN​(byte[] pkgcnstkn)
      Write PKGNAMCSN Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number There are two possible formats, fixed and extended which includes length information for the strings
      private void writeQRYDSC​(DRDAStatement stmt, boolean FDODSConly)
      Write QRYDSC - Query Answer Set Description
      private void writeQRYDTA​(DRDAStatement stmt)
      Write QRYDTA - Query Answer Set Data Contains some or all of the answer set data resulting from a query If the client is not using rowset processing, this routine attempts to pack as much data into the QRYDTA as it can.
      private void writeQRYNOPRM​(int svrCod)
      Write a QRYNOPRM - Query Not Opened Instance Variables SVRCOD - Severity Code - required - 4 Warning 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required
      private void writeQRYPOPRM()
      Write a QRYPOPRM - Query Previously opened Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required
      private void writeRDBfailure​(int codePoint)
      Write RDB Failure Instance Variables SVRCOD - Severity Code - required RDBNAM - Relational Database name - required SRVDGN - Server Diagnostics - optional (not sent for now)
      protected void writeRDBNAM​(java.lang.String rdbnam)
      Write RDBNAM
      private void writeRDBUPDRM()
      Write RDBUPDRM Instance variables SVRCOD - Severity code - Information only - required RDBNAM - Relational database name -required SRVDGN - Server Diagnostic Information -optional
      private void writeRSLSETRM​(DRDAStatement stmt)
      Write RSLSETRM Instance variables SVRCOD - Severity code - Information only - required PKGSNLST - list of PKGNAMCSN -required SRVDGN - Server Diagnostic Information -optional
      private void writeSECCHKRM​(int securityCheckCode)
      Write security check reply Instance variables SVRCOD - serverity code - required SECCHKCD - security check code - required SECTKN - security token - optional, ignorable SVCERRNO - security service error number SRVDGN - Server Diagnostic Information
      private void writeSQLCAERRWARN​(long updateCount, long rowCount)
      Write the ERR and WARN part of the SQLCA
      private void writeSQLCAGRP​(byte[] sqlState, int sqlcode, long updateCount, long rowCount)
      Same as writeSQLCAGRP, but optimized for the case when there is no real exception, i.e. the exception is null, or "End of data" SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0
      private void writeSQLCAGRP​(java.sql.SQLException e, long updateCount, long rowCount)
      Write SQLCAGRP SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0
      private void writeSQLCARD​(java.sql.SQLException e, long updateCount, long rowCount)  
      private void writeSQLCARDs​(java.sql.SQLException e, long updateCount)  
      private void writeSQLCARDs​(java.sql.SQLException e, long updateCount, boolean sendSQLERRRM)  
      private void writeSQLCAXGRP​(long updateCount, long rowCount, java.lang.String sqlerrmc, java.sql.SQLException nextException)
      Write SQLCAXGRP SQLCAXGRP : EARLY FDOCA GROUP SQL Communications Area Exceptions Group Description FORMAT FOR SQLAM <= 6 SQLRDBNME; DRDA TYPE FCS; ENVLID 0x30; Length Override 18 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70 FORMAT FOR SQLAM >= 7 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLRDBNAME; DRDA TYPE VCS; ENVLID 0x32; Length Override 1024 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70
      private void writeSQLCINRD​(DRDAStatement stmt)
      Write SQLCINRD - result set column information
      private void writeSQLDAGRP​(java.sql.ResultSetMetaData rsmeta, java.sql.ParameterMetaData pmeta, int elemNum, boolean rtnOutput)
      Write SQLDAGRP SQLDAGRP : EARLY FDOCA GROUP SQL Data Area Group Description FORMAT FOR SQLAM <= 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 FORMAT FOR SQLAM == 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 SQLUDTGRP; DRDA TYPE N-GDA; ENVLID 0x51; Length Override 0 FORMAT FOR SQLAM >= 7 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLDOPTGRP; DRDA TYPE N-GDA; ENVLID 0xD2; Length Override 0
      private void writeSQLDARD​(DRDAStatement stmt, boolean rtnOutput, java.sql.SQLException e)
      Write SQLDARD SQLDARD : FDOCA EARLY ARRAY SQL Descriptor Area Row Description with SQL Communications Area FORMAT FOR SQLAM <= 6 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDAROW; ROW LID 0x60; ELEMENT TAKEN 0(all); REP FACTOR 0(all) FORMAT FOR SQLAM >= 7 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDHROW; ROW LID 0xE0; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
      private void writeSQLDCGRP​(long rowNum, int sqlCode, java.lang.String sqlState, java.lang.String dbname, java.lang.String sqlerrmc)
      writeSQLDCGRP: SQL Diagnostics Condition Group Description SQLDCCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCSTATE; DRDA TYPE FCS; ENVLID Ox30; Lengeh Override 5 SQLDCREASON; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCLINEN; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCROWN; DRDA TYPE FD; ENVLID 0x0E; Lengeh Override 31 SQLDCER01; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER02; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER03; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER04; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPART; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPPOP; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCMSGID; DRDA TYPE FCS; ENVLID 0x30; Length Override 10 SQLDCMDE; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLDCPMOD; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLDCRDB; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 SQLDCTOKS; DRDA TYPE N-RLO; ENVLID 0xF7; Length Override 0 SQLDCMSG_m; DRDA TYPE NVMC; ENVLID 0x3F; Length Override 32672 SQLDCMSG_S; DRDA TYPE NVCS; ENVLID 0x33; Length Override 32672 SQLDCCOLN_m; DRDA TYPE NVCM ; ENVLID 0x3F; Length Override 255 SQLDCCOLN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCCURN_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCCURN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCPNAM_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCPNAM_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCXGRP; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 1
      private void writeSQLDCROW​(long rowNum, int sqlCode, java.lang.String sqlState, java.lang.String dbname, java.lang.String sqlerrmc)
      writeSQLDCROW: SQL Diagnostics Condition Row - Identity 0xE5 SQLDCGRP; GROUP LID 0xD5; ELEMENT TAKEN 0(all); REP FACTOR 1
      private void writeSQLDHROW​(int holdability)
      Holdability passed in as it can represent the holdability of the statement or a specific result set.
      private void writeSQLDIAGCI​(java.sql.SQLException nextException)
      writeSQLDIAGCI: SQL Diagnostics Condition Information Array - Identity 0xF5 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDCIROW; ROW LID 0xE5; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
      private void writeSQLDIAGCN()  
      private void writeSQLDIAGGRP​(java.sql.SQLException nextException)
      Write SQLDIAGGRP: SQL Diagnostics Group Description - Identity 0xD1 Nullable Group SQLDIAGSTT; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 0 SQLDIAGCN; DRFA TYPE N-RLO; ENVLID 0xF6; Length Override 0 SQLDIAGCI; DRDA TYPE N-RLO; ENVLID 0xF5; Length Override 0
      private void writeSQLDIAGSTT()  
      private void writeSQLDOPTGRP​(java.sql.ResultSetMetaData rsmeta, java.sql.ParameterMetaData pmeta, int jdbcElemNum, boolean rtnOutput)  
      private void writeSQLDTAGRP​(DRDAStatement stmt, java.sql.ResultSetMetaData rsmeta, java.sql.ParameterMetaData pmeta, int colStart, int colEnd, boolean first)
      Write SQLDTAGRP SQLDAGRP : Late FDOCA GROUP SQL Data Value Group Descriptor LENGTH - length of the SQLDTAGRP TRIPLET_TYPE - NGDA for first, CPT for following ID - SQLDTAGRP_LID for first, NULL_LID for following For each column DRDA TYPE LENGTH OVERRIDE For numeric/decimal types PRECISON SCALE otherwise LENGTH or DISPLAY_WIDTH
      private void writeSQLDXGRP​(java.sql.ResultSetMetaData rsmeta, java.sql.ParameterMetaData pmeta, int jdbcElemNum, boolean rtnOutput)  
      private void writeSQLERRRM​(int severity)
      Write SQLERRRM Instance Variables SVRCOD - Severity Code - required
      private void writeSQLNUMGRP​(java.sql.SQLException nextException)
      writeSQLNUMGRP: Writes SQLNUMGRP : FDOCA EARLY GROUP SQL Number of Elements Group Description FORMAT FOR ALL SQLAM LEVELS SQLNUM; DRDA TYPE I2; ENVLID 0x04; Length Override 2
      private void writeSQLNUMROW​(java.sql.SQLException nextException)
      writeSQLNUMROW: Writes SQLNUMROW : FDOCA EARLY ROW SQL Number of Elements Row Description FORMAT FOR SQLAM LEVELS SQLNUMGRP; GROUP LID 0x58; ELEMENT TAKEN 0(all); REP FACTOR 1
      private void writeSQLRSLRD​(DRDAStatement stmt)
      Write SQLRSLRD - result set reply data
      private void writeSQLUDTGRP​(java.sql.ResultSetMetaData rsmeta, java.sql.ParameterMetaData pmeta, int jdbcElemNum, boolean rtnOutput)
      Write SQLUDTGRP (SQL Descriptor User-Defined Type Group Descriptor) This is the format from the DRDA spec, Volume 1, section 5.6.4.10.
      private void writeTYPDEFOVR()  
      private void writeVCMorVCS​(java.lang.String s)
      Write variable character mixed byte or single byte The preference is to write mixed byte if it is defined for the server, since that is our default and we don't allow it to be changed, we always write mixed byte.
      • Methods inherited from class java.lang.Thread

        activeCount, checkAccess, clone, countStackFrames, currentThread, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, onSpinWait, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, suspend, toString, yield
      • Methods inherited from class java.lang.Object

        equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
    • Field Detail

      • correlationID

        private int correlationID
      • sockis

        private java.io.InputStream sockis
      • sockos

        private java.io.OutputStream sockos
      • ACCRDB_REQUIRED

        private static int[] ACCRDB_REQUIRED
      • MAX_REQUIRED_LEN

        private static int MAX_REQUIRED_LEN
      • currentRequiredLength

        private int currentRequiredLength
      • required

        private int[] required
      • timeSlice

        private volatile long timeSlice
        Time slice for this thread.
      • logConnections

        private volatile boolean logConnections
        Whether or not to log connections.
      • sendWarningsOnCNTQRY

        private boolean sendWarningsOnCNTQRY
      • close

        private volatile boolean close
        End this thread.
      • sqlamLevel

        private int sqlamLevel
      • diagnosticLevel

        private byte diagnosticLevel
      • unknownManagers

        private java.util.List<java.lang.Integer> unknownManagers
      • knownManagers

        private java.util.List<java.lang.Integer> knownManagers
      • databaseAccessException

        private java.sql.SQLException databaseAccessException
      • prevPkgnamcsn

        private Pkgnamcsn prevPkgnamcsn
        The value returned by the previous call to parsePKGNAMCSN().
      • rdbnam

        private DRDAString rdbnam
        Current RDB Package Name.
      • rdbcolid

        private DRDAString rdbcolid
        Current RDB Collection Identifier.
      • pkgid

        private DRDAString pkgid
        Current RDB Package Identifier.
      • pkgcnstkn

        private DRDAString pkgcnstkn
        Current RDB Package Consistency Token.
      • pkgsn

        private int pkgsn
        Current RDB Package Section Number.
      • TIMEOUT_STATEMENT

        private static final java.lang.String TIMEOUT_STATEMENT
        See Also:
        Constant Field Values
      • pendingStatementTimeout

        private int pendingStatementTimeout
      • myPublicKey

        private byte[] myPublicKey
      • myTargetSeed

        private byte[] myTargetSeed
      • prdIdBytes

        private static byte[] prdIdBytes
      • eod00000

        private static final byte[] eod00000
      • eod02000

        private static final byte[] eod02000
      • nullSQLState

        private static final byte[] nullSQLState
      • errD5_D6

        private static final byte[] errD5_D6
      • warn0_warnA

        private static final byte[] warn0_warnA
      • AUTHENTICATION_PROVIDER_BUILTIN_CLASS

        private static final java.lang.String AUTHENTICATION_PROVIDER_BUILTIN_CLASS
        See Also:
        Constant Field Values
      • AUTHENTICATION_PROVIDER_NONE_CLASS

        private static final java.lang.String AUTHENTICATION_PROVIDER_NONE_CLASS
        See Also:
        Constant Field Values
      • deferredReset

        private boolean deferredReset
        Tells if the reset / connect request is a deferred request. This information is used to work around a bug (DERBY-3596) in a compatible manner, which also avoids any changes in the client driver.

        The bug manifests itself when a connection pool data source is used and logical connections are obtained from the physical connection associated with the data source. Each new logical connection causes a new physical connection on the server, including a new transaction. These connections and transactions are not closed / cleaned up.

      • gmtCalendar

        private java.util.Calendar gmtCalendar
        A cached Calendar instance using the GMT time zone.
      • SQLERRMC_TOKEN_DELIMITER

        private static java.lang.String SQLERRMC_TOKEN_DELIMITER
        SQLERRMC_TOKEN_DELIMITER separates message argument tokens
      • SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER

        private static java.lang.String SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER
        SQLERRMC_PREFORMATTED_MESSAGE_DELIMITER, When full message text is sent for severe errors. This value separates the messages.
    • Constructor Detail

      • DRDAConnThread

        DRDAConnThread​(Session session,
                       NetworkServerControlImpl server,
                       long timeSlice,
                       boolean logConnections)
        Create a new Thread for processing session requests
        Parameters:
        session - Session requesting processing
        server - Server starting thread
        timeSlice - timeSlice for thread
        logConnections -
    • Method Detail

      • run

        public void run()
        Main routine for thread, loops until the thread is closed Gets a session, does work for the session
        Specified by:
        run in interface java.lang.Runnable
        Overrides:
        run in class java.lang.Thread
      • getInputStream

        protected java.io.InputStream getInputStream()
        Get input stream
        Returns:
        input stream
      • getOutputStream

        protected java.io.OutputStream getOutputStream()
        Get output stream
        Returns:
        output stream
      • getProductIDBytes

        private static byte[] getProductIDBytes()
        Get product id as bytes
      • getReader

        protected DDMReader getReader()
        get DDMReader
        Returns:
        DDMReader for this thread
      • getWriter

        protected DDMWriter getWriter()
        get DDMWriter
        Returns:
        DDMWriter for this thread
      • getCorrelationID

        protected int getCorrelationID()
        Get correlation id
        Returns:
        correlation id
      • getSession

        protected Session getSession()
        Get session we are working on
        Returns:
        session
      • getDatabase

        protected Database getDatabase()
        Get Database we are working on
        Returns:
        database
      • getCrrtkn

        protected byte[] getCrrtkn()
        Get correlation token
        Returns:
        crrtkn
      • getDbName

        protected java.lang.String getDbName()
        Get database name
        Returns:
        database name
      • close

        protected void close()
        Close DRDA connection thread
      • setLogConnections

        protected void setLogConnections​(boolean value)
        Set logging of connections
        Parameters:
        value - value to set for logging connections
      • setTimeSlice

        protected void setTimeSlice​(long value)
        Set time slice value
        Parameters:
        value - new value for time slice
      • markCommunicationsFailure

        protected void markCommunicationsFailure​(java.lang.String arg1,
                                                 java.lang.String arg2,
                                                 java.lang.String arg3,
                                                 java.lang.String arg4)
                                          throws DRDAProtocolException
        Indicate a communications failure
        Parameters:
        arg1 - - info about the communications failure
        arg2 - - info about the communications failure
        arg3 - - info about the communications failure
        arg4 - - info about the communications failure
        Throws:
        DRDAProtocolException - disconnect exception always thrown
      • markCommunicationsFailure

        protected void markCommunicationsFailure​(java.lang.Exception e,
                                                 java.lang.String arg1,
                                                 java.lang.String arg2,
                                                 java.lang.String arg3,
                                                 java.lang.String arg4)
                                          throws DRDAProtocolException
        Indicate a communications failure. Log to derby.log
        Parameters:
        e - - Source exception that was thrown
        arg1 - - info about the communications failure
        arg2 - - info about the communications failure
        arg3 - - info about the communications failure
        arg4 - - info about the communications failure
        Throws:
        DRDAProtocolException - disconnect exception always thrown
      • agentError

        protected void agentError​(java.lang.String msg)
                           throws DRDAProtocolException
        Agent error - something very bad happened
        Parameters:
        msg - Message describing error
        Throws:
        DRDAProtocolException - newAgentError always thrown
      • println2Log

        protected static void println2Log​(java.lang.String dbname,
                                          java.lang.String drdaID,
                                          java.lang.String msg)
        Print a line to the DB2j log
        Parameters:
        dbname - database name
        drdaID - DRDA identifier
        msg - message
      • initialize

        private void initialize()
        Initialize class
      • initializeForSession

        private void initializeForSession()
        Initialize for a new session
      • sessionInitialState

        private void sessionInitialState()
                                  throws java.lang.Exception
        In initial state for a session, determine whether this is a command session or a DRDA protocol session. A command session is for changing the configuration of the Net server, e.g., turning tracing on If it is a command session, process the command and close the session. If it is a DRDA session, exchange server attributes and change session state.
        Throws:
        java.lang.Exception
      • cleanUpAndCloseResultSet

        private void cleanUpAndCloseResultSet​(DRDAStatement stmt,
                                              java.sql.SQLException sqle,
                                              int writerMark)
                                       throws DRDAProtocolException
        Cleans up and closes a result set if an exception is thrown when collecting QRYDTA in response to OPNQRY or CNTQRY.
        Parameters:
        stmt - the DRDA statement to clean up
        sqle - the exception that was thrown
        writerMark - start index for the first DSS to clear from the output buffer
        Throws:
        DRDAProtocolException - if a DRDA protocol error is detected
      • errorInChain

        private void errorInChain​(java.sql.SQLException e)
                           throws DRDAProtocolException
        If there's a severe error in the DDM chain, and if the header indicates "terminate chain on error", we stop processing further commands in the chain nor do we send any reply for them. In accordance to this, a SQLERRRM message indicating the severe error must have been sent! (otherwise application requestor, such as JCC, would not terminate the receiving of chain replies.) Each DRDA command is processed independently. DRDA defines no interdependencies across chained commands. A command is processed the same when received within a set of chained commands or received separately. The chaining was originally defined as a way to save network costs.
        Parameters:
        e - the SQLException raised
        Throws:
        DRDAProtocolException
      • switchToUtf8

        private void switchToUtf8()
        Switch the DDMWriter and DDMReader to UTF8 IF supported
      • switchToEbcdic

        private void switchToEbcdic()
        Switch the DDMWriter and DDMReader to EBCDIC
      • writeRDBfailure

        private void writeRDBfailure​(int codePoint)
                              throws DRDAProtocolException
        Write RDB Failure Instance Variables SVRCOD - Severity Code - required RDBNAM - Relational Database name - required SRVDGN - Server Diagnostics - optional (not sent for now)
        Parameters:
        codePoint - codepoint of failure
        Throws:
        DRDAProtocolException
      • getRdbAccessErrorCodePoint

        private int getRdbAccessErrorCodePoint()
      • isAuthenticationException

        private boolean isAuthenticationException​(java.sql.SQLException sqlException)
        There are multiple reasons for not getting a connection, and all these should throw SQLExceptions with SQL state 08004 according to the SQL standard. Since only one of these SQL states indicate that an authentication error has occurred, it is not enough to check that the SQL state is 08004 and conclude that authentication caused the exception to be thrown. This method tries to get a StandardException from the SQLException and use getMessageId on that object to check for authentication error instead of the SQL state we get from SQLExceptions#getSQLState. getMessageId returns the entire id as defined in SQLState (e.g. 08004.C.1), while getSQLState only return the 5 first characters (i.e. 08004 instead of 08004.C.1) If the SQLException isn't linked to a StandardException, the assumption that SQL State 08004 is caused by an authentication failure is followed even though this is not correct. This was the pre DERBY-3060 way of solving the issue.
        Parameters:
        sqlException - The exception that is checked to see if this is really caused by an authentication failure
        Returns:
        true if sqlException is (or has to be assumed to be) caused by an authentication failure, false otherwise.
        See Also:
        SQLState
      • verifyUserIdPassword

        private int verifyUserIdPassword()
                                  throws DRDAProtocolException
        Verify userId and password Username and password is verified by making a connection to the database
        Returns:
        security check code, 0 is O.K.
        Throws:
        DRDAProtocolException
      • getConnFromDatabaseName

        private int getConnFromDatabaseName()
                                     throws DRDAProtocolException
        Get connection from a database name Username and password is verified by making a connection to the database
        Returns:
        security check code, 0 is O.K.
        Throws:
        DRDAProtocolException
      • parseEXCSAT

        private void parseEXCSAT()
                          throws DRDAProtocolException
        Parses EXCSAT (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable
        Throws:
        DRDAProtocolException
      • parseEXCSAT2

        private void parseEXCSAT2()
                           throws DRDAProtocolException
        Parses EXCSAT2 (Exchange Server Attributes) Instance variables EXTNAM(External Name) - optional MGRLVLLS(Manager Levels) - optional SPVNAM(Supervisor Name) - optional SRVCLSNM(Server Class Name) - optional SRVNAM(Server Name) - optional, ignorable SRVRLSLV(Server Product Release Level) - optional, ignorable
        Throws:
        DRDAProtocolException - This parses a second occurrence of an EXCSAT command The target must ignore the values for extnam, srvclsnm, srvnam and srvrlslv. I am also going to ignore spvnam since it should be null anyway. Only new managers can be added.
      • parseMGRLVLLS

        private void parseMGRLVLLS​(int time)
                            throws DRDAProtocolException
        Parse manager levels Instance variables MGRLVL - repeatable, required CODEPOINT CCSIDMGR - CCSID Manager CMNAPPC - LU 6.2 Conversational Communications Manager CMNSYNCPT - SNA LU 6.2 SyncPoint Conversational Communications Manager CMNTCPIP - TCP/IP Communication Manager DICTIONARY - Dictionary RDB - Relational Database RSYNCMGR - Resynchronization Manager SECMGR - Security Manager SQLAM - SQL Application Manager SUPERVISOR - Supervisor SYNCPTMGR - Sync Point Manager VALUE On the second appearance of this codepoint, it can only add managers
        Parameters:
        time - 1 for first time this is seen, 2 for subsequent ones
        Throws:
        DRDAProtocolException
      • writeEXCSATRD

        private void writeEXCSATRD()
                            throws DRDAProtocolException
        Write reply to EXCSAT command Instance Variables EXTNAM - External Name (optional) MGRLVLLS - Manager Level List (optional) SRVCLSNM - Server Class Name (optional) - used by JCC SRVNAM - Server Name (optional) SRVRLSLV - Server Product Release Level (optional)
        Throws:
        DRDAProtocolException
      • writeMGRLEVELS

        private void writeMGRLEVELS()
                             throws DRDAProtocolException
        Write manager levels The target server must not provide information for any target managers unless the source explicitly requests it. For each manager class, if the target server's support level is greater than or equal to the source server's level, then the source server's level is returned for that class if the target server can operate at the source's level; otherwise a level 0 is returned. If the target server's support level is less than the source server's level, the target server's level is returned for that class. If the target server does not recognize the code point of a manager class or does not support that class, it returns a level of 0. The target server then waits for the next command or for the source server to terminate communications. When the source server receives EXCSATRD, it must compare each of the entries in the mgrlvlls parameter it received to the corresponding entries in the mgrlvlls parameter it sent. If any level mismatches, the source server must decide whether it can use or adjust to the lower level of target support for that manager class. There are no architectural criteria for making this decision. The source server can terminate communications or continue at the target servers level of support. It can also attempt to use whatever commands its user requests while receiving error reply messages for real functional mismatches. The manager levels the source server specifies or the target server returns must be compatible with the manager-level dependencies of the specified manangers. Incompatible manager levels cannot be specified. Instance variables MGRLVL - repeatable, required CODEPOINT CCSIDMGR - CCSID Manager CMNAPPC - LU 6.2 Conversational Communications Manager CMNSYNCPT - SNA LU 6.2 SyncPoint Conversational Communications Manager CMNTCPIP - TCP/IP Communication Manager DICTIONARY - Dictionary RDB - Relational Database RSYNCMGR - Resynchronization Manager SECMGR - Security Manager SQLAM - SQL Application Manager SUPERVISOR - Supervisor SYNCPTMGR - Sync Point Manager XAMGR - XA manager VALUE
        Throws:
        DRDAProtocolException
      • parseACCSEC

        private int parseACCSEC()
                         throws DRDAProtocolException
        Parse Access Security If the target server supports the SECMEC requested by the application requester then a single value is returned and it is identical to the SECMEC value in the ACCSEC command. If the target server does not support the SECMEC requested, then one or more values are returned and the application requester must choose one of these values for the security mechanism. We currently support - user id and password (default for JCC) - encrypted user id and password - strong password substitute (USRSSBPWD w/ Derby network client only) Instance variables SECMGRNM - security manager name - optional SECMEC - security mechanism - required RDBNAM - relational database name - optional SECTKN - security token - optional, (required if sec mech. needs it)
        Returns:
        security check code - 0 if everything O.K.
        Throws:
        DRDAProtocolException
      • parseOPNQRY

        private Pkgnamcsn parseOPNQRY()
                               throws DRDAProtocolException,
                                      java.sql.SQLException
        Parse OPNQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYBLKSZ - Query Block Size - required QRYBLKCTL - Query Block Protocol Control - optional MAXBLKEXT - Maximum Number of Extra Blocks - optional - default value 0 OUTOVROPT - Output Override Option QRYROWSET - Query Rowset Size - optional - level 7 MONITOR - Monitor events - optional.
        Returns:
        RDB Package Name, Consistency Token, and Section Number
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseOPNQRYobjects

        private void parseOPNQRYobjects​(DRDAStatement stmt)
                                 throws DRDAProtocolException,
                                        java.sql.SQLException
        Parse OPNQRY objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLDTA- SQL Program Variable Data - optional If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseOUTOVROPT

        private int parseOUTOVROPT()
                            throws DRDAProtocolException
        Parse OUTOVROPT - this indicates whether output description can be overridden on just the first CNTQRY or on any CNTQRY
        Returns:
        output override option
        Throws:
        DRDAProtocolException
      • parseQRYBLKSZ

        private int parseQRYBLKSZ()
                           throws DRDAProtocolException
        Parse QRYBLSZ - this gives the maximum size of the query blocks that can be returned to the requester
        Returns:
        query block size
        Throws:
        DRDAProtocolException
      • parseQRYROWSET

        private int parseQRYROWSET​(int minVal)
                            throws DRDAProtocolException
        Parse QRYROWSET - this is the number of rows to return
        Parameters:
        minVal - - minimum value
        Returns:
        query row set size
        Throws:
        DRDAProtocolException
      • parseQRYCLSIMP

        private int parseQRYCLSIMP()
                            throws DRDAProtocolException
        Parse a QRYCLSIMP - Implicitly close non-scrollable cursor after end of data.
        Returns:
        true to close on end of data
        Throws:
        DRDAProtocolException
      • writeQRYPOPRM

        private void writeQRYPOPRM()
                            throws DRDAProtocolException
        Write a QRYPOPRM - Query Previously opened Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required
        Throws:
        DRDAProtocolException
      • writeQRYNOPRM

        private void writeQRYNOPRM​(int svrCod)
                            throws DRDAProtocolException
        Write a QRYNOPRM - Query Not Opened Instance Variables SVRCOD - Severity Code - required - 4 Warning 8 ERROR RDBNAM - Relational Database Name - required PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required
        Parameters:
        svrCod - Severity Code
        Throws:
        DRDAProtocolException
      • writeOPNQFLRM

        private void writeOPNQFLRM​(java.sql.SQLException e)
                            throws DRDAProtocolException
        Write a OPNQFLRM - Open Query Failure Instance Variables SVRCOD - Severity Code - required - 8 ERROR RDBNAM - Relational Database Name - required
        Parameters:
        e - Exception describing failure
        Throws:
        DRDAProtocolException
      • writePKGNAMCSN

        private void writePKGNAMCSN​(byte[] pkgcnstkn)
                             throws DRDAProtocolException
        Write PKGNAMCSN Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number There are two possible formats, fixed and extended which includes length information for the strings
        Throws:
        DRDAProtocolException
      • parseCNTQRY

        private DRDAStatement parseCNTQRY()
                                   throws DRDAProtocolException,
                                          java.sql.SQLException
        Parse CNTQRY - Continue Query Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required QRYBLKSZ - Query Block Size - required QRYRELSCR - Query Relative Scrolling Action - optional QRYSCRORN - Query Scroll Orientation - optional - level 7 QRYROWNBR - Query Row Number - optional QRYROWSNS - Query Row Sensitivity - optional - level 7 QRYBLKRST - Query Block Reset - optional - level 7 QRYRTNDTA - Query Returns Data - optional - level 7 QRYROWSET - Query Rowset Size - optional - level 7 QRYRFRTBL - Query Refresh Answer Set Table - optional NBRROW - Number of Fetch or Insert Rows - optional MAXBLKEXT - Maximum number of extra blocks - optional RTNEXTDTA - Return of EXTDTA Option - optional MONITOR - Monitor events - optional.
        Returns:
        DRDAStatement we are continuing
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • skipRemainder

        private void skipRemainder​(boolean onlySkipSameIds)
                            throws DRDAProtocolException
        Skip remainder of current DSS and all chained DSS'es
        Parameters:
        onlySkipSameIds - True if we _only_ want to skip DSS'es that are chained with the SAME id as the current DSS. False means skip ALL chained DSSes, whether they're chained with same or different ids.
        Throws:
        DRDAProtocolException
      • parseCNTQRYobjects

        private void parseCNTQRYobjects​(DRDAStatement stmt)
                                 throws DRDAProtocolException,
                                        java.sql.SQLException
        Parse CNTQRY objects Instance Variables OUTOVR - Output Override Descriptor - optional
        Parameters:
        stmt - DRDA statement we are working on
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseOUTOVR

        private void parseOUTOVR​(DRDAStatement stmt)
                          throws DRDAProtocolException,
                                 java.sql.SQLException
        Parse OUTOVR - Output Override Descriptor This specifies the output format for data to be returned as output to a SQL statement or as output from a query.
        Parameters:
        stmt - DRDA statement this applies to
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writePBSD

        private void writePBSD()
                        throws java.sql.SQLException,
                               DRDAProtocolException
        Piggy-back any modified session attributes on the current message. Writes a PBSD conataining one or both of PBSD_ISO and PBSD_SCHEMA. PBSD_ISO is followed by the jdbc isolation level as an unsigned byte. PBSD_SCHEMA is followed by the name of the current schema as an UTF-8 String.
        Throws:
        java.sql.SQLException
        DRDAProtocolException
      • writeOPNQRYRM

        private void writeOPNQRYRM​(boolean isDssObject,
                                   DRDAStatement stmt)
                            throws DRDAProtocolException,
                                   java.sql.SQLException
        Write OPNQRYRM - Open Query Complete Instance Variables SVRCOD - Severity Code - required QRYPRCTYP - Query Protocol Type - required SQLCSRHLD - Hold Cursor Position - optional QRYATTSCR - Query Attribute for Scrollability - optional - level 7 QRYATTSNS - Query Attribute for Sensitivity - optional - level 7 QRYATTUPD - Query Attribute for Updatability -optional - level 7 QRYINSID - Query Instance Identifier - required - level 7 SRVDGN - Server Diagnostic Information - optional
        Parameters:
        isDssObject - - return as a DSS object (part of a reply)
        stmt - - DRDA statement we are processing
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeENDQRYRM

        private void writeENDQRYRM​(int svrCod)
                            throws DRDAProtocolException
        Write ENDQRYRM - query process has terminated in such a manner that the query or result set is now closed. It cannot be resumed with the CNTQRY command or closed with the CLSQRY command
        Parameters:
        svrCod - Severity code - WARNING or ERROR
        Throws:
        DRDAProtocolException
      • writeABNUOWRM

        private void writeABNUOWRM()
                            throws DRDAProtocolException
        Write ABNUOWRM - query process has terminated in an error condition such as deadlock or lock timeout. Severity code is always error * @exception DRDAProtocolException
        Throws:
        DRDAProtocolException
      • writeACCSECRD

        private void writeACCSECRD​(int securityCheckCode)
                            throws DRDAProtocolException
        Write ACCSECRD If the security mechanism is known, we just send it back along with the security token if encryption is going to be used. If the security mechanism is not known, we send a list of the ones we know. Instance Variables SECMEC - security mechanism - required SECTKN - security token - optional (required if security mechanism uses encryption) SECCHKCD - security check code - error occurred in processing ACCSEC
        Parameters:
        securityCheckCode -
        Throws:
        DRDAProtocolException
      • parseSECCHK

        private int parseSECCHK()
                         throws DRDAProtocolException
        Parse security check Instance Variables SECMGRNM - security manager name - optional, ignorable SECMEC - security mechanism - required SECTKN - security token - optional, (required if encryption used) PASSWORD - password - optional, (required if security mechanism uses it) NEWPASSWORD - new password - optional, (required if sec mech. uses it) USRID - user id - optional, (required if sec mec. uses it) RDBNAM - database name - optional (required if databases can have own sec.)
        Returns:
        security check code
        Throws:
        DRDAProtocolException
      • writeSECCHKRM

        private void writeSECCHKRM​(int securityCheckCode)
                            throws DRDAProtocolException
        Write security check reply Instance variables SVRCOD - serverity code - required SECCHKCD - security check code - required SECTKN - security token - optional, ignorable SVCERRNO - security service error number SRVDGN - Server Diagnostic Information
        Throws:
        DRDAProtocolException
      • svrcodFromSecchkcd

        private int svrcodFromSecchkcd​(int securityCheckCode)
        Calculate SVRCOD value from SECCHKCD
        Parameters:
        securityCheckCode -
        Returns:
        SVRCOD value
      • parseACCRDB

        private int parseACCRDB()
                         throws DRDAProtocolException
        Parse access RDB Instance variables RDBACCCL - RDB Access Manager Class - required must be SQLAM CRRTKN - Correlation Token - required RDBNAM - Relational database name -required PRDID - Product specific identifier - required TYPDEFNAM - Data Type Definition Name -required TYPDEFOVR - Type definition overrides -required RDBALWUPD - RDB Allow Updates optional PRDDTA - Product Specific Data - optional - ignorable STTDECDEL - Statement Decimal Delimiter - optional STTSTRDEL - Statement String Delimiter - optional TRGDFTRT - Target Default Value Return - optional
        Returns:
        severity code
        Throws:
        DRDAProtocolException
      • setStmtOrDbByteOrder

        private void setStmtOrDbByteOrder​(boolean setDatabase,
                                          DRDAStatement stmt,
                                          java.lang.String typDefNam)
        Set a statement or the database' byte order, depending on the arguments
        Parameters:
        setDatabase - if true, set database' byte order, otherwise set statement's
        stmt - DRDAStatement, used when setDatabase is false
        typDefNam - TYPDEFNAM value
      • writeACCRDBRM

        private void writeACCRDBRM​(int svrcod)
                            throws DRDAProtocolException
        Write Access to RDB Completed Instance Variables SVRCOD - severity code - 0 info, 4 warning -required PRDID - product specific identifier -required TYPDEFNAM - type definition name -required TYPDEFOVR - type definition overrides - required RDBINTTKN - token which can be used to interrupt DDM commands - optional CRRTKN - correlation token - only returned if we didn't get one from requester SRVDGN - server diagnostic information - optional PKGDFTCST - package default character subtype - optional USRID - User ID at the target system - optional SRVLST - Server List
        Throws:
        DRDAProtocolException
      • parseTYPDEFOVR

        private void parseTYPDEFOVR​(DRDAStatement st)
                             throws DRDAProtocolException
        Parse Type Defintion Overrides TYPDEF Overrides specifies the Coded Character SET Identifiers (CCSIDs) that are in a named TYPDEF. Instance Variables CCSIDSBC - CCSID for Single-Byte - optional CCSIDDBC - CCSID for Double-Byte - optional CCSIDMBC - CCSID for Mixed-byte characters -optional
        Parameters:
        st - Statement this TYPDEFOVR applies to
        Throws:
        DRDAProtocolException
      • parsePRPSQLSTT

        private int parsePRPSQLSTT()
                            throws DRDAProtocolException,
                                   java.sql.SQLException
        Parse PRPSQLSTT - Prepare SQL Statement Instance Variables RDBNAM - Relational Database Name - optional PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number - required RTNSQLDA - Return SQL Descriptor Area - optional MONITOR - Monitor events - optional.
        Returns:
        return 0 - don't return sqlda, 1 - return input sqlda, 2 - return output sqlda
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parsePRPSQLSTTobjects

        private java.lang.String parsePRPSQLSTTobjects​(DRDAStatement stmt)
                                                throws DRDAProtocolException,
                                                       java.sql.SQLException
        Parse PRPSQLSTT objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement required SQLATTR - Cursor attributes on prepare - optional - level 7 If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.
        Returns:
        SQL statement
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseSQLATTR

        protected void parseSQLATTR​(DRDAStatement stmt)
                             throws DRDAProtocolException
        Parse SQLATTR - Cursor attributes on prepare This is an encoded string. Can have combination of following, eg INSENSITIVE SCROLL WITH HOLD Possible strings are SENSITIVE DYNAMIC SCROLL [FOR UPDATE] SENSITIVE STATIC SCROLL [FOR UPDATE] INSENSITIVE SCROLL FOR UPDATE WITH HOLD
        Parameters:
        stmt - DRDAStatement
        Throws:
        DRDAProtocolException
      • parseDSCSQLSTT

        private boolean parseDSCSQLSTT()
                                throws DRDAProtocolException,
                                       java.sql.SQLException
        Parse DSCSQLSTT - Describe SQL Statement previously prepared Instance Variables TYPSQLDA - sqlda type expected (output or input) RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required MONITOR - Monitor events - optional.
        Returns:
        expect "output sqlda" or not
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseEXCSQLSTT

        private void parseEXCSQLSTT()
                             throws DRDAProtocolException,
                                    java.sql.SQLException
        Parse EXCSQLSTT - Execute non-cursor SQL Statement previously prepared Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required OUTEXP - Output expected NBRROW - Number of rows to be inserted if it's an insert PRCNAM - procedure name if specified by host variable, not needed for Derby QRYBLKSZ - query block size MAXRSLCNT - max resultset count MAXBLKEXT - Max number of extra blocks RSLSETFLG - resultset flag RDBCMTOK - RDB Commit Allowed - optional OUTOVROPT - output override option QRYROWSET - Query Rowset Size - Level 7 MONITOR - Monitor events - optional.
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseRDBCMTOK

        private void parseRDBCMTOK()
                            throws DRDAProtocolException
        Parse RDBCMTOK - tells the database whether to allow commits or rollbacks to be executed as part of the command Since we don't have a SQL commit or rollback command, we will just ignore this for now
        Throws:
        DRDAProtocolException
      • parseEXCSQLSTTobjects

        private boolean parseEXCSQLSTTobjects​(DRDAStatement stmt)
                                       throws DRDAProtocolException,
                                              java.sql.SQLException
        Parse EXCSQLSTT command objects Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLDTA - optional, variable data, specified if prpared statement has input parameters EXTDTA - optional, externalized FD:OCA data OUTOVR - output override descriptor, not allowed for stored procedure calls If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.
        Parameters:
        stmt - the DRDAStatement to execute
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeRSLSETRM

        private void writeRSLSETRM​(DRDAStatement stmt)
                            throws DRDAProtocolException,
                                   java.sql.SQLException
        Write RSLSETRM Instance variables SVRCOD - Severity code - Information only - required PKGSNLST - list of PKGNAMCSN -required SRVDGN - Server Diagnostic Information -optional
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseSQLDTA_work

        private void parseSQLDTA_work​(DRDAStatement stmt)
                               throws DRDAProtocolException,
                                      java.sql.SQLException
        Parse SQLDTA - SQL program variable data Instance Variables FDODSC - FD:OCA data descriptor - required FDODTA - FD:OCA data - optional
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • getByteOrder

        private int getByteOrder()
      • getGMTCalendar

        private java.util.Calendar getGMTCalendar()
        Get a Calendar instance with time zone set to GMT. The instance is cached for reuse by this thread. This calendar can be used to consistently read and write date and time values using the same calendar. Since the local default calendar may not be able to represent all times (for instance because the time would fall into a non-existing hour of the day when switching to daylight saving time, see DERBY-4582), we use the GMT time zone which doesn't observe daylight saving time.
        Returns:
        a calendar in the GMT time zone
      • readAndSetParams

        private void readAndSetParams​(int i,
                                      DRDAStatement stmt,
                                      java.sql.ParameterMetaData pmeta)
                               throws DRDAProtocolException,
                                      java.sql.SQLException
        Read different types of input parameters and set them in PreparedStatement
        Parameters:
        i - index of the parameter
        stmt - drda statement
        pmeta - parameter meta data
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseDate

        private java.sql.Date parseDate​(java.lang.String dateString,
                                        java.util.Calendar cal)
        Parse a date string as it is received from the client.
        Parameters:
        dateString - the date string to parse
        cal - the calendar in which the date is parsed
        Returns:
        a Date object representing the date in the specified calendar
        Throws:
        java.lang.IllegalArgumentException - if the date is not correctly formatted
        See Also:
        DateTime.dateToDateBytes(byte[], int, org.apache.derby.client.am.DateTimeValue)
      • parseTime

        private java.sql.Time parseTime​(java.lang.String timeString,
                                        java.util.Calendar cal)
        Parse a time string as it is received from the client.
        Parameters:
        timeString - the time string to parse
        cal - the calendar in which the time is parsed
        Returns:
        a Date object representing the time in the specified calendar
        Throws:
        java.lang.IllegalArgumentException - if the time is not correctly formatted
        See Also:
        DateTime.timeToTimeBytes(byte[], int, org.apache.derby.client.am.DateTimeValue)
      • parseTimestamp

        private java.sql.Timestamp parseTimestamp​(java.lang.String timeString,
                                                  java.util.Calendar cal)
        Parse a timestamp string as it is received from the client.
        Parameters:
        timeString - the time string to parse
        cal - the calendar in which the timestamp is parsed
        Returns:
        a Date object representing the timestamp in the specified calendar
        Throws:
        java.lang.IllegalArgumentException - if the timestamp is not correctly formatted
        See Also:
        DateTime.timestampToTimestampBytes(byte[], int, org.apache.derby.client.am.DateTimeValue, boolean)
      • readAndSetExtParam

        private void readAndSetExtParam​(int i,
                                        DRDAStatement stmt,
                                        int drdaType,
                                        int extLen,
                                        boolean streamLOB)
                                 throws DRDAProtocolException,
                                        java.sql.SQLException
        Read different types of input parameters and set them in PreparedStatement
        Parameters:
        i - zero-based index of the parameter
        stmt - associated ps
        drdaType - drda type of the parameter
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseEXCSQLIMM

        private long parseEXCSQLIMM()
                             throws DRDAProtocolException,
                                    java.sql.SQLException
        Parse EXCSQLIMM - Execute Immediate Statement Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required RDBCMTOK - RDB Commit Allowed - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - optional TYPDEFOVR - TYPDEF Overrides -optional SQLSTT - SQL Statement -required
        Returns:
        update count
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseEXCSQLSET

        private boolean parseEXCSQLSET()
                                throws DRDAProtocolException,
                                       java.sql.SQLException
        Parse EXCSQLSET - Execute Set SQL Environment Instance Variables RDBNAM - relational database name - optional PKGNAMCT - RDB Package Name, Consistency Token - optional MONITOR - Monitor Events - optional Command Objects TYPDEFNAM - Data Type Definition Name - required TYPDEFOVR - TYPDEF Overrides - required SQLSTT - SQL Statement - required (at least one; may be more)
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseEXECSQLIMMobjects

        private java.lang.String parseEXECSQLIMMobjects()
                                                 throws DRDAProtocolException,
                                                        java.sql.SQLException
        Parse EXCSQLIMM objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides SQLSTT - SQL Statement required If TYPDEFNAM and TYPDEFOVR are supplied, they apply to the objects sent with the statement. Once the statement is over, the default values sent in the ACCRDB are once again in effect. If no values are supplied, the values sent in the ACCRDB are used. Objects may follow in one DSS or in several DSS chained together.
        Returns:
        SQL Statement
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • parseEXCSQLSETobjects

        private void parseEXCSQLSETobjects()
                                    throws DRDAProtocolException,
                                           java.sql.SQLException
        Parse EXCSQLSET objects Objects TYPDEFNAM - Data type definition name - optional TYPDEFOVR - Type defintion overrides - optional SQLSTT - SQL Statement - required (a list of at least one) Objects may follow in one DSS or in several DSS chained together.
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • canIgnoreStmt

        private boolean canIgnoreStmt​(java.lang.String stmt)
      • writeRDBUPDRM

        private void writeRDBUPDRM()
                            throws DRDAProtocolException
        Write RDBUPDRM Instance variables SVRCOD - Severity code - Information only - required RDBNAM - Relational database name -required SRVDGN - Server Diagnostic Information -optional
        Throws:
        DRDAProtocolException
      • parsePKGNAMCSN

        private Pkgnamcsn parsePKGNAMCSN()
                                  throws DRDAProtocolException
        Parse PKGNAMCSN - RDB Package Name, Consistency Token, and Section Number Instance Variables NAMESYMDR - database name - not validated RDBCOLID - RDB Collection Identifier PKGID - RDB Package Identifier PKGCNSTKN - RDB Package Consistency Token PKGSN - RDB Package Section Number
        Returns:
        Pkgnamcsn value
        Throws:
        DRDAProtocolException
      • parseVCMorVCS

        private java.lang.String parseVCMorVCS()
                                        throws DRDAProtocolException
        Parse variable character mixed byte or variable character single byte Format I2 - VCM Length N bytes - VCM value I2 - VCS Length N bytes - VCS value Only 1 of VCM length or VCS length can be non-zero
        Returns:
        string value
        Throws:
        DRDAProtocolException
      • parseNOCMorNOCS

        private java.lang.String parseNOCMorNOCS()
                                          throws DRDAProtocolException
        Parse nullable character mixed byte or nullable character single byte Format 1 byte - null indicator I4 - mixed character length N bytes - mixed character string 1 byte - null indicator I4 - single character length N bytes - single character length string
        Returns:
        string value
        Throws:
        DRDAProtocolException
      • parseCLSQRY

        private DRDAStatement parseCLSQRY()
                                   throws DRDAProtocolException,
                                          java.sql.SQLException
        Parse CLSQRY Instance Variables RDBNAM - relational database name - optional PKGNAMCSN - RDB Package Name, Consistency Token and Section Number - required QRYINSID - Query Instance Identifier - required - level 7 MONITOR - Monitor events - optional.
        Returns:
        DRDAstatement being closed
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • getSqlCode

        private int getSqlCode​(java.sql.SQLException e)

        Get the SQLCODE to send for an exception or a warning.

        The client expects a negative SQLCODE for exceptions and a positive SQLCODE for warnings. SQLCODE 0 means there is no error or warning condition. SQLCODE is also used to encode the severity of the condition (as returned by SQLException.getErrorCode()).

        For warnings, the SQLCODE is 10000, which is identical to ExceptionSeverity.WARNING_SEVERITY.

        For exceptions, the SQLCODE is set to -severity-1, which allows all non-negative severity values to be encoded. (Derby only uses non-negative severity values in the first place.)

        Parameters:
        e - the exception or warning to get the SQLCODE for
        Returns:
        the value to send as SQLCODE
      • writeSQLERRRM

        private void writeSQLERRRM​(int severity)
                            throws DRDAProtocolException
        Write SQLERRRM Instance Variables SVRCOD - Severity Code - required
        Parameters:
        severity - severity of error
        Throws:
        DRDAProtocolException
      • writeCMDCHKRM

        private void writeCMDCHKRM​(int severity)
                            throws DRDAProtocolException
        Write CMDCHKRM Instance Variables SVRCOD - Severity Code - required
        Parameters:
        severity - severity of error
        Throws:
        DRDAProtocolException
      • getExceptionSeverity

        private int getExceptionSeverity​(java.sql.SQLException e)
        Translate from Derby exception severity to SVRCOD
        Parameters:
        e - SQLException
      • writeSQLCAGRP

        private void writeSQLCAGRP​(java.sql.SQLException e,
                                   long updateCount,
                                   long rowCount)
                            throws DRDAProtocolException
        Write SQLCAGRP SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0
        Parameters:
        e - SQLException encountered
        Throws:
        DRDAProtocolException
      • writeSQLCAGRP

        private void writeSQLCAGRP​(byte[] sqlState,
                                   int sqlcode,
                                   long updateCount,
                                   long rowCount)
                            throws DRDAProtocolException
        Same as writeSQLCAGRP, but optimized for the case when there is no real exception, i.e. the exception is null, or "End of data" SQLCAGRP : FDOCA EARLY GROUP SQL Communcations Area Group Description FORMAT FOR SQLAM <= 6 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 FORMAT FOR SQLAM >= 7 SQLCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLSTATE; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLERRPROC; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLCAXGRP; DRDA TYPE N-GDA; ENVLID 0x52; Length Override 0 SQLDIAGGRP; DRDA TYPE N-GDA; ENVLID 0x56; Length Override 0
        Parameters:
        sqlState - SQLState (already converted to UTF8)
        sqlcode - sqlcode
        updateCount -
        rowCount -
        Throws:
        DRDAProtocolException
      • buildSqlerrmc

        private java.lang.String buildSqlerrmc​(java.sql.SQLException se)
        Create error message or message argements to return to client. The SQLERRMC will normally be passed back to the server in a call to the SYSIBM.SQLCAMESSAGE but for severe exceptions the stored procedure call cannot be made. So for Severe messages we will just send the message text. This method will also truncate the value according the client capacity. CCC can only handle 70 characters. Server sends the sqlerrmc using UTF8 encoding to the client. To get the message, client sends back information to the server calling SYSIBM.SQLCAMESSAGE (see Sqlca.getMessage). Several parameters are sent to this procedure including the locale, the sqlerrmc that the client received from the server. On server side, the procedure SQLCAMESSAGE in SystemProcedures then calls the MessageService.getLocalizedMessage to retrieve the localized error message. In MessageService.getLocalizedMessage the sqlerrmc that is passed in, is parsed to retrieve the message id. The value it uses to parse the MessageId is char value of 20, otherwise it uses the entire sqlerrmc as the message id. This messageId is then used to retrieve the localized message if present, to the client.
        Parameters:
        se - SQLException to build SQLERRMC
        Returns:
        String which is either the message arguments to be passed to SYSIBM.SQLCAMESSAGE or just message text for severe errors.
      • buildPreformattedSqlerrmc

        private java.lang.String buildPreformattedSqlerrmc​(java.sql.SQLException se)
        Build preformatted SQLException text for severe exceptions or SQLExceptions that are not Derby exceptions. Just send the message text localized to the server locale.
        Parameters:
        se - SQLException for which to build SQLERRMC
        Returns:
        preformated message text with messages separted by SQLERRMC_PREFORMATED_MESSAGE_DELIMITER
      • buildTokenizedSqlerrmc

        private java.lang.String buildTokenizedSqlerrmc​(java.sql.SQLException se)
        Build Tokenized SQLERRMC to just send the tokenized arguments to the client. for a Derby SQLException or an SQLException thrown by user code. Message argument tokens are separated by SQLERRMC_TOKEN_DELIMITER Multiple messages are separated by SystemProcedures.SQLERRMC_MESSAGE_DELIMITER ...
        Parameters:
        se - SQLException to print
      • buildDataTruncationSqlerrmc

        private java.lang.String buildDataTruncationSqlerrmc​(java.sql.DataTruncation dt)
        Build the SQLERRMC for a java.sql.DataTruncation warning. Serialize all the fields of the DataTruncation instance in the order in which they appear in the parameter list of the constructor.
        Parameters:
        dt - the DataTruncation instance to serialize
        Returns:
        the SQLERRMC string with all fields of the warning
      • writeSQLCAXGRP

        private void writeSQLCAXGRP​(long updateCount,
                                    long rowCount,
                                    java.lang.String sqlerrmc,
                                    java.sql.SQLException nextException)
                             throws DRDAProtocolException
        Write SQLCAXGRP SQLCAXGRP : EARLY FDOCA GROUP SQL Communications Area Exceptions Group Description FORMAT FOR SQLAM <= 6 SQLRDBNME; DRDA TYPE FCS; ENVLID 0x30; Length Override 18 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70 FORMAT FOR SQLAM >= 7 SQLERRD1; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD2; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD3; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD4; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD5; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLERRD6; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLWARN0; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN1; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN2; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN3; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN4; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN5; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN6; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN7; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN8; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARN9; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLWARNA; DRDA TYPE FCS; ENVLID 0x30; Length Override 1 SQLRDBNAME; DRDA TYPE VCS; ENVLID 0x32; Length Override 1024 SQLERRMSG_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 70 SQLERRMSG_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 70
        Parameters:
        nextException - SQLException encountered
        sqlerrmc - sqlcode
        Throws:
        DRDAProtocolException
      • writeSQLCAERRWARN

        private void writeSQLCAERRWARN​(long updateCount,
                                       long rowCount)
        Write the ERR and WARN part of the SQLCA
        Parameters:
        updateCount -
        rowCount -
      • writeSQLDIAGGRP

        private void writeSQLDIAGGRP​(java.sql.SQLException nextException)
                              throws DRDAProtocolException
        Write SQLDIAGGRP: SQL Diagnostics Group Description - Identity 0xD1 Nullable Group SQLDIAGSTT; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 0 SQLDIAGCN; DRFA TYPE N-RLO; ENVLID 0xF6; Length Override 0 SQLDIAGCI; DRDA TYPE N-RLO; ENVLID 0xF5; Length Override 0
        Throws:
        DRDAProtocolException
      • writeSQLDIAGCI

        private void writeSQLDIAGCI​(java.sql.SQLException nextException)
                             throws DRDAProtocolException
        writeSQLDIAGCI: SQL Diagnostics Condition Information Array - Identity 0xF5 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDCIROW; ROW LID 0xE5; ELEMENT TAKEN 0(all); REP FACTOR 0(all)
        Throws:
        DRDAProtocolException
      • writeSQLNUMROW

        private void writeSQLNUMROW​(java.sql.SQLException nextException)
                             throws DRDAProtocolException
        writeSQLNUMROW: Writes SQLNUMROW : FDOCA EARLY ROW SQL Number of Elements Row Description FORMAT FOR SQLAM LEVELS SQLNUMGRP; GROUP LID 0x58; ELEMENT TAKEN 0(all); REP FACTOR 1
        Throws:
        DRDAProtocolException
      • writeSQLNUMGRP

        private void writeSQLNUMGRP​(java.sql.SQLException nextException)
                             throws DRDAProtocolException
        writeSQLNUMGRP: Writes SQLNUMGRP : FDOCA EARLY GROUP SQL Number of Elements Group Description FORMAT FOR ALL SQLAM LEVELS SQLNUM; DRDA TYPE I2; ENVLID 0x04; Length Override 2
        Throws:
        DRDAProtocolException
      • writeSQLDCROW

        private void writeSQLDCROW​(long rowNum,
                                   int sqlCode,
                                   java.lang.String sqlState,
                                   java.lang.String dbname,
                                   java.lang.String sqlerrmc)
                            throws DRDAProtocolException
        writeSQLDCROW: SQL Diagnostics Condition Row - Identity 0xE5 SQLDCGRP; GROUP LID 0xD5; ELEMENT TAKEN 0(all); REP FACTOR 1
        Throws:
        DRDAProtocolException
      • writeSQLDCGRP

        private void writeSQLDCGRP​(long rowNum,
                                   int sqlCode,
                                   java.lang.String sqlState,
                                   java.lang.String dbname,
                                   java.lang.String sqlerrmc)
                            throws DRDAProtocolException
        writeSQLDCGRP: SQL Diagnostics Condition Group Description SQLDCCODE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCSTATE; DRDA TYPE FCS; ENVLID Ox30; Lengeh Override 5 SQLDCREASON; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCLINEN; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCROWN; DRDA TYPE FD; ENVLID 0x0E; Lengeh Override 31 SQLDCER01; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER02; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER03; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCER04; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPART; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCPPOP; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLDCMSGID; DRDA TYPE FCS; ENVLID 0x30; Length Override 10 SQLDCMDE; DRDA TYPE FCS; ENVLID 0x30; Length Override 8 SQLDCPMOD; DRDA TYPE FCS; ENVLID 0x30; Length Override 5 SQLDCRDB; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 SQLDCTOKS; DRDA TYPE N-RLO; ENVLID 0xF7; Length Override 0 SQLDCMSG_m; DRDA TYPE NVMC; ENVLID 0x3F; Length Override 32672 SQLDCMSG_S; DRDA TYPE NVCS; ENVLID 0x33; Length Override 32672 SQLDCCOLN_m; DRDA TYPE NVCM ; ENVLID 0x3F; Length Override 255 SQLDCCOLN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCCURN_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCCURN_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCPNAM_m; DRDA TYPE NVCM; ENVLID 0x3F; Length Override 255 SQLDCPNAM_s; DRDA TYPE NVCS; ENVLID 0x33; Length Override 255 SQLDCXGRP; DRDA TYPE N-GDA; ENVLID 0xD3; Length Override 1
        Throws:
        DRDAProtocolException
      • writeSQLDARD

        private void writeSQLDARD​(DRDAStatement stmt,
                                  boolean rtnOutput,
                                  java.sql.SQLException e)
                           throws DRDAProtocolException,
                                  java.sql.SQLException
        Write SQLDARD SQLDARD : FDOCA EARLY ARRAY SQL Descriptor Area Row Description with SQL Communications Area FORMAT FOR SQLAM <= 6 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDAROW; ROW LID 0x60; ELEMENT TAKEN 0(all); REP FACTOR 0(all) FORMAT FOR SQLAM >= 7 SQLCARD; ROW LID 0x64; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLDHROW; ROW LID 0xE0; ELEMENT TAKEN 0(all); REP FACTOR 1 SQLNUMROW; ROW LID 0x68; ELEMENT TAKEN 0(all); REP FACTOR 1
        Parameters:
        stmt - prepared statement
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeQRYDSC

        private void writeQRYDSC​(DRDAStatement stmt,
                                 boolean FDODSConly)
                          throws DRDAProtocolException,
                                 java.sql.SQLException
        Write QRYDSC - Query Answer Set Description
        Parameters:
        stmt - DRDAStatement we are working on
        FDODSConly - simply the FDODSC, without the wrap Instance Variables SQLDTAGRP - required Only 84 columns can be sent in a single QRYDSC. If there are more columns they must be sent in subsequent QRYDSC. If the QRYDSC will not fit into the current block, as many columns as can fit are sent and then the remaining are sent in the following blocks.
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeSQLDTAGRP

        private void writeSQLDTAGRP​(DRDAStatement stmt,
                                    java.sql.ResultSetMetaData rsmeta,
                                    java.sql.ParameterMetaData pmeta,
                                    int colStart,
                                    int colEnd,
                                    boolean first)
                             throws DRDAProtocolException,
                                    java.sql.SQLException
        Write SQLDTAGRP SQLDAGRP : Late FDOCA GROUP SQL Data Value Group Descriptor LENGTH - length of the SQLDTAGRP TRIPLET_TYPE - NGDA for first, CPT for following ID - SQLDTAGRP_LID for first, NULL_LID for following For each column DRDA TYPE LENGTH OVERRIDE For numeric/decimal types PRECISON SCALE otherwise LENGTH or DISPLAY_WIDTH
        Parameters:
        stmt - drda statement
        rsmeta - resultset meta data
        pmeta - parameter meta data for CallableStatement
        colStart - starting column for group to send
        colEnd - end column to send
        first - is this the first group
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeSQLDHROW

        private void writeSQLDHROW​(int holdability)
                            throws DRDAProtocolException,
                                   java.sql.SQLException
        Holdability passed in as it can represent the holdability of the statement or a specific result set.
        Parameters:
        holdability - HOLD_CURSORS_OVER_COMMIT or CLOSE_CURSORS_AT_COMMIT
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeQRYDTA

        private void writeQRYDTA​(DRDAStatement stmt)
                          throws DRDAProtocolException,
                                 java.sql.SQLException
        Write QRYDTA - Query Answer Set Data Contains some or all of the answer set data resulting from a query If the client is not using rowset processing, this routine attempts to pack as much data into the QRYDTA as it can. This may result in splitting the last row across the block, in which case when the client calls CNTQRY we will return the remainder of the row. Splitting a QRYDTA block is expensive, for several reasons: - extra logic must be run, on both client and server side - more network round-trips are involved - the QRYDTA block which contains the continuation of the split row is generally wasteful, since it contains the remainder of the split row but no additional rows. Since splitting is expensive, the server makes some attempt to avoid it. Currently, the server's algorithm for this is to compute the length of the current row, and to stop trying to pack more rows into this buffer if another row of that length would not fit. However, since rows can vary substantially in length, this algorithm is often ineffective at preventing splits. For example, if a short row near the end of the buffer is then followed by a long row, that long row will be split. It is possible to improve this algorithm substantially: - instead of just using the length of the previous row as a guide for whether to attempt packing another row in, use some sort of overall average row size computed over multiple rows (e.g., all the rows we've placed into this QRYDTA block, or all the rows we've process for this result set) - when we discover that the next row will not fit, rather than splitting the row across QRYDTA blocks, if it is relatively small, we could just hold the entire row in a buffer to place it entirely into the next QRYDTA block, or reset the result set cursor back one row to "unread" this row. - when splitting a row across QRYDTA blocks, we tend to copy data around multiple times. Careful coding could remove some of these copies. However, it is important not to over-complicate this code: it is better to be correct than to be efficient, and there have been several bugs in the split logic already. Instance Variables Byte string
        Parameters:
        stmt - DRDA statement we are processing
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeFDODTA

        private boolean writeFDODTA​(DRDAStatement stmt)
                             throws DRDAProtocolException,
                                    java.sql.SQLException
        This routine places some data into the current QRYDTA block using FDODTA (Formatted Data Object DaTA rules). There are 3 basic types of processing flow for this routine: - In normal non-rowset, non-scrollable cursor flow, this routine places a single row into the QRYDTA block and returns TRUE, indicating that the caller can call us back to place another row into the result set if he wishes. (The caller may need to send Externalized Data, which would be a reason for him NOT to place any more rows into the QRYDTA). - In ROWSET processing, this routine places an entire ROWSET of rows into the QRYDTA block and returns FALSE, indicating that the QRYDTA block is full and should now be sent. - In callable statement processing, this routine places the results from the output parameters of the called procedure into the QRYDTA block. This code path is really dramatically different from the other two paths and shares only a very small amount of common code in this routine. In all cases, it is possible that the data we wish to return may not fit into the QRYDTA block, in which case we call splitQRYDTA to split the data and remember the remainder data in the result set. Splitting the data is relatively rare in the normal cursor case, because our caller (writeQRYDTA) uses a coarse estimation technique to avoid calling us if he thinks a split is likely. The overall structure of this routine is implemented as two loops: - the outer "do ... while ... " loop processes a ROWSET, one row at a time. For non-ROWSET cursors, and for callable statements, this loop executes only once. - the inner "for ... i < numCols ..." loop processes each column in the current row, or each output parmeter in the procedure. Most column data is written directly inline in the QRYDTA block. Some data, however, is written as Externalized Data. This is commonly used for Large Objects. In that case, an Externalized Data Pointer is written into the QRYDTA block, and the actual data flows in separate EXTDTA blocks which are returned after this QRYDTA block.
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • splitQRYDTA

        private void splitQRYDTA​(DRDAStatement stmt,
                                 int blksize)
                          throws java.sql.SQLException,
                                 DRDAProtocolException
        Split QRYDTA into blksize chunks This routine is called if the QRYDTA data will not fit. It writes as much data as it can, then stores the remainder in the result set. At some later point, when the client returns with a CNTQRY, we will call processLeftoverQRYDTA to handle that data. The interaction between DRDAConnThread and DDMWriter is rather complicated here. This routine gets called because DRDAConnThread realizes that it has constructed a QRYDTA message which is too large. At that point, we need to reclaim the "extra" data and hold on to it. To aid us in that processing, DDMWriter provides the routines getDSSLength, copyDSSDataToEnd, and truncateDSS. For some additional detail on this complex sub-protocol, the interested reader should study bug DERBY-491 and 492 at: http://issues.apache.org/jira/browse/DERBY-491 and http://issues.apache.org/jira/browse/DERBY-492
        Parameters:
        stmt - DRDA statment
        blksize - size of query block
        Throws:
        java.sql.SQLException
        DRDAProtocolException
      • processLeftoverQRYDTA

        private boolean processLeftoverQRYDTA​(DRDAStatement stmt)
                                       throws java.sql.SQLException,
                                              DRDAProtocolException
        Process remainder data resulting from a split. This routine is called at the start of building each QRYDTA block. Normally, it observes that there is no remainder data from the previous QRYDTA block, and returns FALSE, indicating that there was nothing to do. However, if it discovers that the previous QRYDTA block was split, then it retrieves the remainder data from the result set, writes as much of it as will fit into the QRYDTA block (hopefully all of it will fit, but the row may be very long), and returns TRUE, indicating that this QRYDTA block has been filled with remainder data and should now be sent immediately.
        Throws:
        java.sql.SQLException
        DRDAProtocolException
      • doneData

        private void doneData​(DRDAStatement stmt,
                              java.sql.ResultSet rs)
                       throws DRDAProtocolException,
                              java.sql.SQLException
        Done data Send SQLCARD for the end of the data
        Parameters:
        stmt - DRDA statement
        rs - Result set
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • positionCursor

        private boolean positionCursor​(DRDAStatement stmt,
                                       java.sql.ResultSet rs)
                                throws java.sql.SQLException,
                                       DRDAProtocolException
        Position cursor for insensitive scrollable cursors
        Parameters:
        stmt - DRDA statement
        rs - Result set
        Throws:
        java.sql.SQLException
        DRDAProtocolException
      • writeSQLDAGRP

        private void writeSQLDAGRP​(java.sql.ResultSetMetaData rsmeta,
                                   java.sql.ParameterMetaData pmeta,
                                   int elemNum,
                                   boolean rtnOutput)
                            throws DRDAProtocolException,
                                   java.sql.SQLException
        Write SQLDAGRP SQLDAGRP : EARLY FDOCA GROUP SQL Data Area Group Description FORMAT FOR SQLAM <= 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I4; ENVLID 0x02; Length Override 4 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 FORMAT FOR SQLAM == 6 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLLABEL_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 30 SQLLABEL_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 30 SQLCOMMENTS_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 254 SQLCOMMENTS_m; DRDA TYPE VCS; ENVLID 0x32; Length Override 254 SQLUDTGRP; DRDA TYPE N-GDA; ENVLID 0x51; Length Override 0 FORMAT FOR SQLAM >= 7 SQLPRECISION; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLSCALE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLLENGTH; DRDA TYPE I8; ENVLID 0x16; Length Override 8 SQLTYPE; DRDA TYPE I2; ENVLID 0x04; Length Override 2 SQLCCSID; DRDA TYPE FB; ENVLID 0x26; Length Override 2 SQLDOPTGRP; DRDA TYPE N-GDA; ENVLID 0xD2; Length Override 0
        Parameters:
        rsmeta - resultset meta data
        pmeta - parameter meta data
        elemNum - column number we are returning (in case of result set), or, parameter number (in case of parameter)
        rtnOutput - whether this is for a result set
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeVCMorVCS

        private void writeVCMorVCS​(java.lang.String s)
                            throws DRDAProtocolException
        Write variable character mixed byte or single byte The preference is to write mixed byte if it is defined for the server, since that is our default and we don't allow it to be changed, we always write mixed byte.
        Parameters:
        s - string to write
        Throws:
        DRDAProtocolException
      • writeSQLUDTGRP

        private void writeSQLUDTGRP​(java.sql.ResultSetMetaData rsmeta,
                                    java.sql.ParameterMetaData pmeta,
                                    int jdbcElemNum,
                                    boolean rtnOutput)
                             throws DRDAProtocolException,
                                    java.sql.SQLException
        Write SQLUDTGRP (SQL Descriptor User-Defined Type Group Descriptor) This is the format from the DRDA spec, Volume 1, section 5.6.4.10. However, this format is not rich enough to carry the information needed by JDBC. This format does not have a subtype code for JAVA_OBJECT and this format does not convey the Java class name needed by ResultSetMetaData.getColumnClassName(). SQLUDXTYPE; DRDA TYPE I4; ENVLID 0x02; Length Override 4 Constants which map to java.sql.Types constants DISTINCT, STRUCT, and REF. But DRDA does not define a constant which maps to java.sql.Types.JAVA_OBJECT. SQLUDTRDB; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Database name. SQLUDTSCHEMA_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 255 SQLUDTSCHEMA_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Schema name. One of the above. SQLUDTNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 255 SQLUDTNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Unqualified UDT name. One of the above. Instead, we use the following format and only for communication between Derby servers and Derby clients which are both at version 10.6 or higher. For all other client/server combinations, we send null. SQLUDTNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override 255 SQLUDTNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override 255 Fully qualified UDT name. One of the above. SQLUDTCLASSNAME_m; DRDA TYPE VCM; ENVLID 0x3E; Length Override FdocaConstants.LONGVARCHAR_MAX_LEN SQLUDTCLASSNAME_s; DRDA TYPE VCS; ENVLID 0x32; Length Override FdocaConstants.LONGVARCHAR_MAX_LEN Name of the Java class bound to the UDT. One of the above.
        Parameters:
        rsmeta - resultset meta data
        pmeta - parameter meta data
        jdbcElemNum - column number we are returning (in case of result set), or, parameter number (in case of parameter)
        rtnOutput - whether this is for a result set
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeSQLDOPTGRP

        private void writeSQLDOPTGRP​(java.sql.ResultSetMetaData rsmeta,
                                     java.sql.ParameterMetaData pmeta,
                                     int jdbcElemNum,
                                     boolean rtnOutput)
                              throws DRDAProtocolException,
                                     java.sql.SQLException
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeSQLDXGRP

        private void writeSQLDXGRP​(java.sql.ResultSetMetaData rsmeta,
                                   java.sql.ParameterMetaData pmeta,
                                   int jdbcElemNum,
                                   boolean rtnOutput)
                            throws DRDAProtocolException,
                                   java.sql.SQLException
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • writeFdocaVal

        protected void writeFdocaVal​(int index,
                                     java.lang.Object val,
                                     int drdaType,
                                     int precision,
                                     int scale,
                                     boolean valNull,
                                     DRDAStatement stmt,
                                     boolean isParam)
                              throws DRDAProtocolException,
                                     java.sql.SQLException
        Write Fdoca Value to client
        Parameters:
        index - Index of column being returned
        val - Value to write to client
        drdaType - FD:OCA DRDA Type from FdocaConstants
        precision - Precision
        stmt - Statement being processed
        isParam - True when writing a value for a procedure parameter
        Throws:
        DRDAProtocolException
        java.sql.SQLException
        See Also:
        FdocaConstants
      • writeNullability

        private void writeNullability​(int drdaType,
                                      boolean valNull)
        write nullability if this is a nullable drdatype and FDOCA null value if appropriate
        Parameters:
        drdaType - FDOCA type
        valNull - true if this is a null value. False otherwise
      • padInt

        private void padInt​(char[] buf,
                            int offset,
                            int length,
                            int value)
        Insert an integer into a char array and pad it with leading zeros if its string representation is shorter than length characters.
        Parameters:
        buf - the char array
        offset - where in the array to start inserting the value
        length - the desired length of the inserted string
        value - the integer value to insert
      • copyToRequired

        private void copyToRequired​(int[] req)
        Copy a list of required code points to template for checking
        Parameters:
        req - list of required codepoints
      • removeFromRequired

        private void removeFromRequired​(int codePoint)
        Remove codepoint from required list
        Parameters:
        codePoint - - code point to be removed
      • checkRequired

        private void checkRequired​(int codePoint)
                            throws DRDAProtocolException
        Check whether we have seen all the required code points
        Parameters:
        codePoint - code point for which list of code points is required
        Throws:
        DRDAProtocolException
      • invalidClient

        private void invalidClient​(java.lang.String prdid)
                            throws DRDAProtocolException
        Invalid non-derby client tried to connect. thrown a required Value not found error and log a message to derby.log
        Parameters:
        prdid - product id that does not match DNC
        Throws:
        DRDAProtocolException
      • requiredValueNotFound

        private void requiredValueNotFound​(int codePoint)
                                    throws DRDAProtocolException
        Required value not found.
        Parameters:
        codePoint - code point with invalid value
        Throws:
        DRDAProtocolException
      • badObjectLength

        private void badObjectLength​(int codePoint)
                              throws DRDAProtocolException
        Object length not allowed
        Parameters:
        codePoint - code point with bad object length
        Throws:
        DRDAProtocolException
      • codePointNotSupported

        protected void codePointNotSupported​(int codePoint)
                                      throws DRDAProtocolException
        Don't support this code point
        Parameters:
        codePoint - code point value
        Throws:
        DRDAProtocolException
      • verifyRequiredObject

        private void verifyRequiredObject​(int codePoint,
                                          int reqCodePoint)
                                   throws DRDAProtocolException
        Verify that the code point is the required code point
        Parameters:
        codePoint - code point we have
        reqCodePoint - code point required at this time
        Throws:
        DRDAProtocolException
      • verifyInOrderACCSEC_SECCHK

        private void verifyInOrderACCSEC_SECCHK​(int codePoint,
                                                int reqCodePoint)
                                         throws DRDAProtocolException
        Verify that the code point is in the right order
        Parameters:
        codePoint - code point we have
        reqCodePoint - code point required at this time
        Throws:
        DRDAProtocolException
      • rdbnamMismatch

        private void rdbnamMismatch​(int codePoint)
                             throws DRDAProtocolException
        Database name given under code point doesn't match previous database names
        Parameters:
        codePoint - codepoint where the mismatch occurred
        Throws:
        DRDAProtocolException
      • closeSession

        private void closeSession()
        Close the current session
      • handleException

        private void handleException​(java.lang.Exception e)
        Handle Exceptions - write error protocol if appropriate and close session or thread as appropriate
      • sendProtocolException

        private void sendProtocolException​(DRDAProtocolException de)
        Notice the client about a protocol error.
        Parameters:
        de - DRDAProtocolException to be sent
      • sendUnexpectedException

        private void sendUnexpectedException​(java.lang.Exception e)
        Send unpexpected error to the client
        Parameters:
        e - Exception to be sent
      • closed

        private boolean closed()
        Test if DRDA connection thread is closed
        Returns:
        true if close; false otherwise
      • getLogConnections

        private boolean getLogConnections()
        Get whether connections are logged
        Returns:
        true if connections are being logged; false otherwise
      • getTimeSlice

        private long getTimeSlice()
        Get time slice value for length of time to work on a session
        Returns:
        time slice
      • trace

        protected void trace​(java.lang.String value)
        Send string to console
        Parameters:
        value - - value to print on console
      • traceEXTDTARead

        private void traceEXTDTARead​(int drdaType,
                                     int index,
                                     EXTDTAReaderInputStream stream,
                                     boolean streamLOB,
                                     java.lang.String encoding)
        Sends a trace string to the console when reading an EXTDTA value (if tracing is enabled).
        Parameters:
        drdaType - the DRDA type of the EXTDTA value
        index - the one-based parameter index
        stream - the stream being read
        streamLOB - whether or not the value is being streamed as the last parameter value in the DRDA protocol flow
        encoding - the encoding of the data, if any
      • showmem

        public static void showmem()
        Show runtime memory
      • convertToHexString

        private java.lang.String convertToHexString​(byte[] buf)
        convert byte array to a Hex string
        Parameters:
        buf - buffer to convert
        Returns:
        hex string representation of byte array
      • checkValidTypDefNam

        private void checkValidTypDefNam​(java.lang.String typdefnam)
                                  throws DRDAProtocolException
        check that the given typdefnam is acceptable
        Parameters:
        typdefnam -
        Throws:
        DRDAProtocolException
      • checkLength

        private void checkLength​(int codepoint,
                                 int reqlen)
                          throws DRDAProtocolException
        Check that the length is equal to the required length for this codepoint
        Parameters:
        codepoint - codepoint we are checking
        reqlen - required length
        Throws:
        DRDAProtocolException
      • readBoolean

        private boolean readBoolean​(int codepoint)
                             throws DRDAProtocolException
        Read and check a boolean value
        Parameters:
        codepoint - codePoint to be used in error reporting
        Returns:
        true or false depending on boolean value read
        Throws:
        DRDAProtocolException
      • initializeDatabase

        private void initializeDatabase​(java.lang.String dbname)
        Create a new database and intialize the DRDAConnThread database.
        Parameters:
        dbname - database name to initialize. If dbnam is non null, add database to the current session
      • writeENDUOWRM

        private void writeENDUOWRM​(int opType)
        Write ENDUOWRM Instance Variables SVCOD - severity code - WARNING - required UOWDSP - Unit of Work Disposition - required RDBNAM - Relational Database name - optional SRVDGN - Server Diagnostics information - optional
        Parameters:
        opType - - operation type 1 - commit, 2 -rollback
      • checkWarning

        private void checkWarning​(java.sql.Connection conn,
                                  java.sql.Statement stmt,
                                  java.sql.ResultSet rs,
                                  long updateCount,
                                  boolean alwaysSend,
                                  boolean sendWarn)
                           throws DRDAProtocolException,
                                  java.sql.SQLException
        Check SQLWarning and write SQLCARD as needed.
        Parameters:
        conn - connection to check
        stmt - statement to check
        rs - result set to check
        updateCount - update count to include in SQLCARD
        alwaysSend - whether always send SQLCARD regardless of the existance of warnings
        sendWarn - whether to send any warnings or not.
        Throws:
        DRDAProtocolException
        java.sql.SQLException
      • hasSession

        boolean hasSession()
      • getBytesRead

        long getBytesRead()
      • getBytesWritten

        long getBytesWritten()
      • buildRuntimeInfo

        protected java.lang.String buildRuntimeInfo​(java.lang.String indent,
                                                    LocalizedResource localLangUtil)
      • validateSecMecUSRSSBPWD

        private int validateSecMecUSRSSBPWD()
                                     throws DRDAProtocolException
        Validate SECMEC_USRSSBPWD (Strong Password Substitute) can be used as DRDA security mechanism. Here we check that the target server can support SECMEC_USRSSBPWD security mechanism based on the environment, application requester's identity (PRDID) and connection URL. IMPORTANT NOTE: -------------- SECMEC_USRSSBPWD is ONLY supported by the target server if: - current authentication provider is Derby BUILTIN or NONE. (database / system level) (Phase I) - database-level password must have been encrypted with the SHA-1 based authentication scheme - Application requester is 'DNC' (Derby Network Client) (Phase I)
        Returns:
        security check code - 0 if everything O.K.
        Throws:
        DRDAProtocolException
      • closeStream

        private static void closeStream​(java.io.InputStream stream)
                                 throws java.sql.SQLException
        Close a stream.
        Parameters:
        stream - the stream to close (possibly null)
        Throws:
        java.sql.SQLException - wrapped around an IOException if closing the stream failed
      • convertAsByteArrayInputStream

        private static java.io.InputStream convertAsByteArrayInputStream​(EXTDTAReaderInputStream stream)
                                                                  throws java.io.IOException
        Throws:
        java.io.IOException
      • setAsCharacterStream

        private static void setAsCharacterStream​(DRDAStatement stmt,
                                                 int i,
                                                 EXTDTAReaderInputStream extdtaStream,
                                                 boolean streamLOB,
                                                 java.lang.String encoding)
                                          throws java.io.IOException,
                                                 java.sql.SQLException
        Sets the specified character EXTDTA parameter of the embedded statement.
        Parameters:
        stmt - the DRDA statement to use
        i - the one-based index of the parameter
        extdtaStream - the EXTDTA stream to read data from
        streamLOB - whether or not the stream content is streamed as the last value in the DRDA protocol flow
        encoding - the encoding of the EXTDTA stream
        Throws:
        java.io.IOException - if reading from the stream fails
        java.sql.SQLException - if setting the stream fails
      • setAsBinaryStream

        private static void setAsBinaryStream​(DRDAStatement stmt,
                                              int index,
                                              EXTDTAReaderInputStream stream,
                                              boolean streamLOB)
                                       throws java.io.IOException,
                                              java.sql.SQLException
        Sets the specified binary EXTDTA parameter of the embedded statement.
        Parameters:
        stmt - the DRDA statement to use
        index - the one-based index of the parameter
        stream - the EXTDTA stream to read data from
        streamLOB - whether or not the stream content is streamed as the last value in the DRDA protocol flow
        Throws:
        java.io.IOException - if reading from the stream fails
        java.sql.SQLException - if setting the stream fails
      • getMonitor

        private static ModuleFactory getMonitor()
        Privileged Monitor lookup. Must be private so that user code can't call this entry point.
      • findService

        private static java.lang.Object findService​(java.lang.String factoryInterface,
                                                    java.lang.String serviceName)
        Privileged service lookup. Must be private so that user code can't call this entry point.