Ejemplo n.º 1
0
        }         // getTargets

        /*
        ** Name: getHost
        **
        ** Description:
        **	Extracts and returns the name of the host from the target
        **	string:
        **
        **	    <host>[:<port>]
        **
        ** Input:
        **	target
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	String	    Host name.
        **
        ** History:
        **	 7-Jun-99 (gordy)
        **	    Created.
        **	19-Oct-06 (lunbr01)  Sir 116548
        **	    Allow for IPv6 addresses enclosed in square brackets '[]'.
        */

        /// <summary>
        /// Extracts and returns the name of the host from the target.
        /// </summary>
        /// <param name="target"></param>
        /// <returns>Name of the host from the target.</returns>
        private String getHost(String target)
        {
            int index;
            int start = 0;

            if (target.StartsWith("["))
            {
                start = 1;
                index = target.IndexOf(']');
                if (index < 0)
                {
                    if (trace.enabled(1))
                    {
                        trace.write(title + ": right bracket ']' missing at end of IPv6 @ in '" + target + "'");
                    }
                    throw SqlEx.get(ERR_GC4000_BAD_URL);
                }
            }
            else
            {
                index = target.IndexOf(':');
            }

            return(index < 0 ?
                   target :
                   target.Substring(start, index - start));
        }          // getHost
Ejemplo n.º 2
0
        }         // readData

        /*
        ** Name: readInfo
        **
        ** Description:
        **	Read an INFO message.  The INFO message parameters are read
        **	and processed.  Currently, the only INFO parameter supported
        **	is Trace Text which is simply written to the trace file.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	21-Apr-06 (gordy)
        **	    Created.
        **	 3-Jul-06 (gordy)
        **	    Support dedicated DBMS trace log.
        */

        protected internal virtual void readInfo()
        {
            while (msg.moreData())
            {
                short param_id  = msg.readShort();
                short param_len = msg.readShort();

                switch (param_id)
                {
                case MSG_IP_TRACE:
                {
                    if (trace.enabled() || conn.dbms_log.enabled())
                    {
                        String txt = msg.readString(param_len);
                        trace.log("DBMS TRACE: " + txt);
                        conn.dbms_log.write(txt);
                    }
                    else
                    {
                        msg.skip(param_len);
                    }
                    break;
                }

                default:
                    if (trace.enabled(1))
                    {
                        trace.write(tr_id + ": Invalid info param ID " + param_id);
                    }
                    throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                }
            }

            return;
        }         // readInfo
Ejemplo n.º 3
0
        }          // setSegSize

        /*
        ** Name: begin
        **
        ** Description:
        **	Begin a new Ingres NL data segment in the output buffer.
        **	reserves space for the Ingres TCP-IP header.  Flushes
        **	current buffer if insufficient space for next segment.
        **
        ** Input:
        **	size	Minimum amount of space required for next segment.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	 9-Jun-99 (gordy)
        **	    Created.
        */

        /// <summary>
        /// Begin a new Ingres NL data segment in the output buffer.
        /// reserves space for the Ingres TCP-IP header.  Flushes
        /// current buffer if insufficient space for next segment.
        /// </summary>
        /// <param name="size">Minimum amount of space required for
        /// next segment.</param>
        protected internal virtual void  begin(int size)
        {
            lock (this)
            {
                if (closed || outputStream == null)
                {
                    throw SqlEx.get(ERR_GC4004_CONNECTION_CLOSED);
                }

                setSegSize();                 // Update the current segment length (if any).
                seg_beg = buf_len;            // New segment starts at end of current data.

                /*
                ** Flush current segments if insufficient space
                ** for next segment.  Note that flushBuffer()
                ** handles the case of no current segments.
                */
                if ((buf_len + size + 2) > buf_max)
                {
                    flushBuffer(false);
                }

                /*
                ** Reserve space for the Ingres TCP-IP header.
                */
                data_beg = data_ptr = seg_beg + 2;
                data_end = buf_max;

                return;
            }
        }          // begin
Ejemplo n.º 4
0
        }          // write

        /*
        ** Name: write (byteArray) at a position
        **
        ** Description:
        **	Append a byte array to the output buffer.  This
        **	routine does not split arrays across buffers, the
        **	current buffer is flushed and the array must fit
        **	in the new buffer, or an exception is thrown.
        **
        ** Input:
        **	byteArray	    Byte array.
        **	offset          Position of data in array.
        **	length          Length of data in array.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	16-Jun-99 (gordy)
        **	    Created.
        */

        /// <summary>
        /// Append a byte array to the output buffer.  This
        /// routine does not split arrays across buffers, the
        /// current buffer is flushed and the array must fit
        /// in the new buffer, or an exception is thrown.
        /// </summary>
        /// <param name="byteArray">Byte array.</param>
        /// <param name="offset">Position of data in array to read from.</param>
        /// <param name="length">Length of data in array.</param>
        public virtual void  write(byte[] byteArray, int offset, int length)
        {
            if (!need(length))
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": array length " + length + " too long");
                }
                close();
                throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
            }

            if (trace.enabled(5))
            {
                trace.write(title + ": appending " + length);
            }
            try
            {
                Array.Copy(byteArray, offset, buffer, data_ptr, length);
            }
            catch (System.Exception ex)
            {
                // Should not happen!
                throw SqlEx.get(title + ": array copy exception.  " +
                                ex.Message, "HY000", 0);
            }

            data_ptr += length;
            return;
        }          // write
Ejemplo n.º 5
0
        }          // need

        /*
        ** Name: check
        **
        ** Description:
        **	Validate a buffer write request.
        **
        ** Input:
        **	position:	Position in buffer.
        **	length:		Length of data.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void.
        **
        ** History:
        **	28-Jan-00 (gordy)
        **	    Created to replace redundant code and provide tracing.
        */

        /// <summary>
        /// Validate a buffer write request.
        /// </summary>
        /// <param name="position">Position in buffer.</param>
        /// <param name="size">Length of data.</param>
        private void  check(int position, int size)
        {
            if (position < data_beg || (position + size) > data_end)
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": position out-of-bounds");
                }
                close();
                throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
            }
            else if (trace.enabled(5))
            {
                if (position != data_ptr)
                {
                    trace.write(title + ": writing " + size + " @ " + position);
                }
                else
                {
                    trace.write(title + ": appending " + size);
                }
            }

            return;
        }  // check
Ejemplo n.º 6
0
        }          // flush

        /*
        ** Name: next
        **
        ** Description:
        **	Read next segment from input stream.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	 9-Jun-99 (gordy)
        **	    Created.
        **	28-Jan-00 (gordy)
        **	    Added TL segment tracing.*/

        /// <summary>
        /// Read next segment from input stream.
        /// </summary>
        protected internal virtual void  next()
        {
            lock (this)
            {
                int size;

                if (closed || inputStream == null)
                {
                    throw SqlEx.get(ERR_GC4004_CONNECTION_CLOSED);
                }

                if (seg_beg < seg_end)
                {
                    seg_beg = seg_end;
                }
                if (seg_beg >= buf_len)
                {
                    clearBuffer();
                }

                fillBuffer(2);                 // Make sure length is available
                size = getSegSize();
                if (trace.enabled(5))
                {
                    trace.write(title + ": read segment " + size);
                }

                fillBuffer(size);                 // Make sure entire segment is available
                seg_end  = seg_beg + size;
                data_beg = data_ptr = seg_beg + 2;
                data_end = seg_end;

                return;
            }
        }          // next
Ejemplo n.º 7
0
 columnMap(int index)
 {
     if (index < 0 || index >= count)
     {
         throw SqlEx.get(ERR_GC4011_INDEX_RANGE);
     }
     return(index);
 }         // columnMap
Ejemplo n.º 8
0
        }         // readDesc

        /*
        ** Name: readData
        **
        ** Description:
        **	Read a data message.  The default action is to throw an exception.
        **	A sub-class should override this method if a data message is a
        **	valid request result.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	boolean	    Interrupt reading results.
        **
        ** History:
        **	 8-Sep-99 (gordy)
        **	    Created.
        **	29-Sep-99 (gordy)
        **	    Changed return type to permit BLOB segments to
        **	    interrupt the normal processing of messages.
        */

        protected internal virtual bool readData()
        {
            if (trace.enabled(1))
            {
                trace.write(tr_id + ": unexpected result data.");
            }
            throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
        }         // readData
Ejemplo n.º 9
0
        }         // readResults

        /*
        ** Name: readDesc
        **
        ** Description:
        **	Read a data descriptor message.  The default action is to
        **	throw an exception.  A sub-class should override this method
        **	if a data descriptor message is a valid request result.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	AdvanRSMD    Result set data descriptor.
        **
        ** History:
        **	 8-Sep-99 (gordy)
        **	    Created.
        */

        protected internal virtual AdvanRSMD readDesc()
        {
            if (trace.enabled(1))
            {
                trace.write(tr_id + ": unexpected result set");
            }
            throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
        }         // readDesc
Ejemplo n.º 10
0
        public virtual void  LockConnection(bool nesting_allowed)
        {
            lock (lock_obj)
            {
                System.Threading.Thread currentThread =
                    System.Threading.Thread.CurrentThread;

                while (lock_active)                  // if already locked by someone
                {
                    // if recursively locked by the same thread,
                    // make sure it was intentional as in the case
                    // of the DTCEnlistment's TxResourceAsyncThread.
                    if (lock_thread_id ==
                        currentThread.ManagedThreadId)
                    {
                        if (lock_nesting_allowed)
                        {
                            lock_nest_count++;
                            return;
                        }

                        if (trace.enabled(1))                          // unintentional nested locking!
                        {
                            trace.write(title + ".lock(): nested locking!!, current " +
                                        lock_thread_id.ToString());
                        }
                        throw SqlEx.get(ERR_GC4005_SEQUENCING);
                    }

                    try
                    {
                        System.Threading.Monitor.Wait(lock_obj);
                        // wait for a Pulse from another
                        // thread's UnlockConnection
                    }
                    catch (System.Exception /* ignore */)
                    {
                    }
                }

                // we have the lock!
                lock_thread_id =
                    currentThread.ManagedThreadId;
                lock_active          = true;
                lock_nesting_allowed = nesting_allowed;
                lock_nest_count      = 1;

                if (trace.enabled(5))
                {
                    trace.write(title + ".lock(): locked by " +
                                lock_thread_id.ToString());
                }
            }              // end lock(lock_obj)

            return;
        }
Ejemplo n.º 11
0
        // skip

        /*
        ** Name: need
        **
        ** Description:
        **	Determines if sufficient data is available to read an
        **	object of a particular size.  Atomic objects may not be
        **	split across buffers.  Non-atomic objects may be split
        **	and may need to be read piece by piece.
        **
        ** Input:
        **	size	    Amount of data required.
        **	atomic	    True if data may not be split.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	16-Jun-99 (gordy)
        **	    Created.
        **	10-Sep-99 (gordy)
        **	    Moved check for TL disconnect request to receive().
        **	22-Sep-99 (gordy)
        **	    Added atomic indicating to permit handling of split arrays.
        **	25-Jan-00 (gordy)
        **	    Added tracing.*/

        /// <summary>
        /// Determines if sufficient data is available to read an
        /// object of a particular size.  Atomic objects may not be
        /// split across buffers.  Non-atomic objects may be split
        /// and may need to be read piece by piece.
        /// </summary>
        /// <param name="size">Amount of data required.</param>
        /// <param name="atomic">True if data may not be split.</param>
        private void  need(int size, bool atomic)
        {
            int available;

            while ((available = avail()) < size)
            {
                short tl_id;

                if (available > 0)
                {
                    if (!atomic)
                    {
                        break;
                    }
                    else
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(title + ": atomic value split (" +
                                        available + "," + size + ")");
                        }
                        close();
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }
                }

                if ((tl_id = receive()) != DAM_TL_DT)
                {
                    if (trace.enabled(1))
                    {
                        trace.write(title + ": invalid TL packet ID 0x" +
                                    System.Convert.ToString(tl_id, 16));
                    }
                    close();
                    throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                }
            }

            if (trace.enabled(5))
            {
                if (available < size)
                {
                    trace.write(title + ": reading " + available + " (" + size + " requested)");
                }
                else
                {
                    trace.write(title + ": reading " + size);
                }
            }

            return;
        }  // need
Ejemplo n.º 12
0
        RsltByref
        (
            DrvConn conn,
            AdvanCall stmt,
            AdvanRSMD rsmd,
            long stmt_id,
            bool do_preLoad
        ) : base(conn, stmt, rsmd, stmt_id, 1, false)

            /*
            ** BYREF parameters produce a single result row.
            ** Even if row may be pre-loaded, we don't want
            ** the super-class to do the loading.
            */
        {
            rs_max_rows = 1;
            tr_id       = "Byref[" + inst_id + "]";

            /*
            ** Pre-load the row if available, otherwise disable pre-
            ** fetching to better handle the single expected row
            ** (pre-loading requires pre-fetch to be enabled).
            */
            if (do_preLoad)
            {
                preLoad();
            }
            else
            {
                disablePreFetch();
            }

            /*
            ** Load the single expected row and close the
            ** server statement to unlock the connection.
            */
            try
            {
                if (!next())
                {
                    throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                }
            }
            catch (SqlEx) { throw; }
            finally
            {
                try { closeCursor(); }
                catch (SqlEx) {}
            }
            return;
        } // RsltByref
Ejemplo n.º 13
0
        }         // setProcResult

        /*
        ** Name DataTruncation
        **
        ** Description:
        **	Constructs an IngresError for a data truncation warning.
        **
        ** Input:
        **	colName     column name that was truncated.
        **	colOrdinal	ordinal number of column.
        **	parm        if true, it's a parameter, else a result column.
        **	reading     if ture, truncated on read, else truncated on write
        **
        ** Output:
        **	Build an error
        **	   "Data truncation on read/write of parameter/result column." +
        **	   "<column name> at ordinal nn"
        **
        ** Returns:
        **	IngresError.
        **
        ** History:
        **	29-Aug-02 (thoda04)
        **	    Created.
        */

        internal Exception DataTruncation(
            string colName,
            int colOrdinal,
            bool parm,
            bool reading)
        {
            return(SqlEx.get(
                       "Data truncation on " +
                       (reading ? "read of " : "write of ") +
                       (parm ? "parameter " : "result column ") +
                       (colName == null ? "" : colName.ToString()) +
                       " at ordinal " + colOrdinal + ".",
                       "01004", 0)); // SQLState and native code
        }                            // DataTruncation
Ejemplo n.º 14
0
        }          // begin

        /*
        ** Name: flush
        **
        ** Description:
        **	Send output buffer to server.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	 9-Jun-99 (gordy)
        **	    Created.
        **	29-Sep-99 (gordy)
        **	    Moved socket flush to flushBuffer().*/

        /// <summary>
        /// Send output buffer to server.
        /// </summary>
        protected internal virtual void  flush()
        {
            lock (this)
            {
                if (closed || outputStream == null)
                {
                    throw SqlEx.get(ERR_GC4004_CONNECTION_CLOSED);
                }

                setSegSize();                 // Update current segment length.
                flushBuffer(true);
                return;
            }
        }          // flush
Ejemplo n.º 15
0
        }         // readBytes

        /*
        ** Name: readString
        **
        ** Description:
        **	Read a string from the input stream.  The string is treated
        **	as an atomic value and the entire requested length must be
        **	available.  The input bytes are converted to Unicode using
        **	the character encoding provided.  Strings which are split
        **	must be read as byte arrays.
        **
        ** Input:
        **	length      Number of bytes in input string.
        **	char_set	Character encoding for conversion.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	String	    String value from input stream.
        **
        ** History:
        **	16-Jun-99 (gordy)
        **	    Created.
        **	22-Sep-99 (gordy)
        **	    Added character set/encoding.*/

        /// <summary>
        /// Read a string from the input stream.  The string is treated
        /// as an atomic value and the entire requested length must be
        /// available.  The input bytes are converted to Unicode using
        /// the character encoding provided.  Strings which are split
        /// must be read as byte arrays.
        /// </summary>
        /// <param name="length">Number of bytes in input string.</param>
        /// <param name="char_set">Character encoding for conversion.</param>
        /// <returns>String value from input stream.</returns>
        public virtual String readString(int length, CharSet char_set)
        {
            String str;

            need(length, true);

            try { str = char_set.getString(buffer, data_ptr, length); }
            catch (Exception ex)
            {
                throw SqlEx.get(ERR_GC401E_CHAR_ENCODE, ex);                   // Should not happen!
            }

            data_ptr += length;
            return(str);
        }          // readString
Ejemplo n.º 16
0
        }                            // DataTruncation

        /*
        ** Name DataTruncation
        **
        ** Description:
        **	Constructs an IngresError for a data truncation warning.
        **
        ** Input:
        **	colOrdinal	ordinal number of column.
        **	parm        if true, it's a parameter, else a result column.
        **	reading     if ture, truncated on read, else truncated on write
        **
        ** Output:
        **	Build an error
        **	   "Data truncation on read/write of parameter/result column." +
        **	   "at ordinal nn"
        **
        ** Returns:
        **	IngresError.
        **
        ** History:
        **	29-Aug-02 (thoda04)
        **	    Created.
        */

        internal Exception DataTruncation(
            int colOrdinal,
            bool parm,
            bool reading,
            int dataSize,
            int transferSize)
        {
            return(SqlEx.get(
                       "Data truncation on " +
                       (reading ? "read of " : "write of ") +
                       (parm ? "parameter " : "result column ") +
                       "at ordinal " + colOrdinal +
                       ".  Original size of data = " + dataSize +
                       ".  Size after truncation = " + transferSize + ".",
                       "01004", 0)); // SQLState and native code
        }                            // DataTruncation
Ejemplo n.º 17
0
        check(int index, bool expand)
        {
            lock (this)
            {
                if (index < 0 || (index >= param_cnt && !expand))
                {
                    throw SqlEx.get(ERR_GC4011_INDEX_RANGE);
                }

                /*
                ** Expand parameter array if necessary.
                */
                if (index >= parameters.Length)
                {
                    int new_max;

                    for (
                        new_max = parameters.Length + ARRAY_INC;
                        index >= new_max;
                        new_max += ARRAY_INC
                        )
                    {
                        ;
                    }

                    Param[] new_array = new Param[new_max];
                    Array.Copy(parameters, 0, new_array, 0,
                               parameters.Length);
                    parameters = new_array;
                }

                /*
                ** Adjust parameter counter if index references a new parameter.
                ** Allocate new parameter objects (if needed) for parameters in
                ** the range not yet initialized.
                */
                for ( ; param_cnt <= index; param_cnt++)
                {
                    if (parameters[param_cnt] == null)
                    {
                        parameters[param_cnt] = new Param();
                    }
                }

                return;
            }
        }         // check
Ejemplo n.º 18
0
        /*
        ** Name: encode
        **
        ** Description:
        **	Encode a string using a key.  The key and string are translated
        **	to the Server character set prior to encoding.  An optional key
        **	mask, CompatCI.CRYPT_SIZE in length, will be combined with the
        **	key if provided.
        **
        ** Input:
        **	key         Encryption key.
        **	mask	    Key mask, may be NULL.
        **	data	    Data to be encrypted
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	byte []	    Encrypted data.
        **
        ** History:
        **	22-Sep-99 (gordy)
        **	    Created.
        **	 6-Sep-02 (gordy)
        **	    Character encoding now encapsulated in CharSet class.
        **	 6-jul-04 (gordy; ported by thoda04)
        **	    Added key mask.
        */

        public virtual byte[] encode(String key, byte[] mask, String data)
        {
            byte[] buff;

            try
            {
                // encode password using obfuscated encode name method
                buff = encode(getCharSet().getBytes(key), mask,
                              getCharSet().getBytes(data));
            }
            catch (Exception ex)
            {
                throw SqlEx.get(ERR_GC401E_CHAR_ENCODE, ex);                    // Should not happen!
            }

            return(buff);
        }
Ejemplo n.º 19
0
        }         // close

        /*
        ** Name: cancel
        **
        ** Description:
        **	Issues an interrupt to the Data Access Server which
        **	will attempt to cancel any active query.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void.
        **
        ** History:
        **	 4-Nov-99 (gordy)
        **	    Created.
        **	26-Dec-02 (gordy)
        **	    Allocate cncl buffer on first request.
        */

        public virtual void  cancel()
        {
            lock (this)
            {
                /*
                ** Allocate cancel buffer on first request.
                */
                if (cncl == null)
                {
                    try
                    {
                        // wrap the socket's NetworkStream in our OutputStream
                        OutputStream outputStream = new OutputStream(socket.GetStream());
                        cncl = new OutBuff(outputStream, ConnID, 16);
                        cncl.TL_ProtocolLevel = this.TL_ProtocolLevel;
                    }
                    catch (Exception ex)
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(title + ": error creating cancel buffer: " +
                                        ex.Message);
                        }
                        disconnect();
                        throw SqlEx.get(ERR_GC4001_CONNECT_ERR, ex);
                    }
                }

                try
                {
                    if (trace.enabled(2))
                    {
                        trace.write(title + ": interrupt network connection");
                    }
                    cncl.begin(DAM_TL_INT, 0);
                    cncl.flush();
                }
                catch (SqlEx ex)
                {
                    disconnect();
                    throw ex;
                }

                return;
            }
        }         // cancel
Ejemplo n.º 20
0
        }          // clearBuffer

        /*
        ** Name: flushBuffer
        **
        ** Description:
        **	Write buffer to output stream and clear output buffer.
        **	The output stream is not actually flushed, since this
        **	routine may be called between a pair of buffers.
        **
        ** Input:
        **	force	Force socket to flush buffers?
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	 9-Jun-99 (gordy)
        **	    Created.
        **	29-Sep-99 (gordy)
        **	    Moved socket flush (optional) to this routine so
        **	    it can be requested from local methods without the
        **	    overhead of calling flush().*/

        /// <summary>
        /// Write buffer to output stream and clear output buffer.  The
        /// output stream is not actually flushed, since this routine
        /// may be called between a pair of buffers.
        /// </summary>
        /// <param name="force">True to force socket to flush buffers</param>
        private void  flushBuffer(bool force)
        {
            if (buf_len <= 0)
            {
                return;
            }

            if (trace.enabled(4))
            {
                trace.write(title + ": sending " + buf_len + " bytes.");
                trace.hexdump(buffer, 0, buf_len);
            }

            try
            {
                outputStream.write(buffer, 0, buf_len);
            }
            catch (Exception ex)
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": write error: " + ex.Message);
                }
                clearBuffer();
                close();
                throw SqlEx.get(ERR_GC4003_CONNECT_FAIL, ex);
            }

            clearBuffer();

            if (force)
            {
                try { outputStream.flush(); }
                catch (System.Exception ex)
                {
                    if (trace.enabled(1))
                    {
                        trace.write(title + ": flush error: " + ex.Message);
                    }
                    close();
                    throw SqlEx.get(ERR_GC4003_CONNECT_FAIL, ex);
                }
            }
            return;
        }          // flushBuffer
Ejemplo n.º 21
0
        }          // InBuff

        /*
        ** Name: receive
        **
        ** Description:
        **	Read the next message.  Any data remaining in the current
        **	message is discarded.  A server abort (TL disconnect request)
        **	is processed here and results in an exception being raised.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	short	    TL Message type.
        **
        ** History:
        **	16-Jun-99 (gordy)
        **	    Created.
        **	10-Sep-99 (gordy)
        **	    Check for TL disconnect request.
        **	28-Jan-00 (gordy)
        **	    Added TL msg ID tracing.
        **	20-Dec-02 (gordy)
        **	    Header ID now protocol level dependent.  Moved TL DR
        **	    processing to MSG classes where it is more appropriatte.
        */

        /// <summary>
        /// Read the next message.  Any data remaining in the current
        /// message is discarded.
        /// </summary>
        /// <returns>TL Message type.</returns>
        public virtual short receive()
        {
            int   hdr_id;
            short msg_id;

            /*
            ** Get the next segment in the input buffer.
            ** If buffer is empty, receive next buffer.
            */
            base.next();

            /*
            ** Read and validate packet header: ID and type.
            */
            hdr_id = readInt();

            if (
                (proto_lvl <= DAM_TL_PROTO_1 && hdr_id != DAM_TL_ID_1) ||
                (proto_lvl >= DAM_TL_PROTO_2 && hdr_id != DAM_TL_ID_2)
                )
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": invalid TL header ID");
                }
                close();
                throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
            }

            /*
            ** Determine type of message.  A disconnect request is only
            ** issued by the server when aborting the connection.  Handle
            ** this exceptional case directly.
            */
            msg_id = readShort();
            if (trace.enabled(3))
            {
                trace.write(title + ": recv TL packet " +
                            IdMap.map(msg_id, tlMap) + " length " + avail());
            }

            return(msg_id);
        }          // receive
Ejemplo n.º 22
0
        /*
        ** Name: MsgConn
        **
        ** Description:
        **	Class constructor.  Opens a socket connection to target
        **	host and initializes the I/O buffers.  Sends the DAM-ML
        **	connection parameters and returns the response.
        **
        **	The DAM-ML connection parameters are formatted as an
        **	array of bytes.  The byte array reference is provided as
        **	the first entry in a multi-dimensional array parameter,
        **	msg_cp.  The input array reference is sent to the
        **	server and the response is placed in a new byte array
        **	whose reference is returned in place of the input
        **	reference, msg_cp.
        **
        ** Input:
        **	targetList	Hostname/port target list.
        **	msg_cp      Message layer parameter info.
        **
        ** Output:
        **	msg_cp      DAM-ML connection parameter response.
        **
        ** History:
        **	 7-Jun-99 (gordy)
        **	    Created.
        **	10-Sep-99 (gordy)
        **	    Parameterized the initial TL connection data.
        **	17-Nov-99 (gordy)
        **	    Extracted I/O functionality to DbConnIo, DbConnOut, DbConnIn.
        **	 1-Mar-07 (gordy, ported by thoda04)
        **	    Dropped char_set parameter, don't default CharSet.
        **	 3-Nov-08 (gordy, ported by thoda04)
        **	    Separated connection logic from super-class constructors
        **	    to facilitate multiple server targets.
        **	 5-May-09 (gordy, ported by thoda04)
        **	    Multiple host/port target list is parsed into host/port pairs.
        */

        /// <summary>
        /// Class constructor.  Opens a socket connection to target
        /// host and initializes the I/O buffers.  Sends the DAM-ML
        /// connection parameters and returns the response.
        /// The DAM-ML connection parameters are formatted as an
        /// array of bytes.  The byte array reference is provided as
        /// the first entry in a multi-dimensional array parameter,
        /// msg_cp.  The input array reference is sent to the
        /// server and the response is placed in a new byte array
        /// whose reference is returned in place of the input
        /// reference, msg_cp.
        /// </summary>
        /// <param name="targetListString">Hostname/port target list.</param>
        /// <param name="msg_cp">Message layer parameter info.</param>
        public MsgConn(String targetListString, ref byte[] msg_cp)
        {
            title = "Msg[" + ConnID + "]";

            TargetList targets;
            SqlEx      lastEx = null;

            try
            {
                targets = getTargets(targetListString);
            }
            catch (SqlEx)
            {
                throw;
            }
            catch (Exception ex)
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": URL parsing error - " + ex.Message);
                }
                throw SqlEx.get(ERR_GC4000_BAD_URL, ex);
            }

            targets.RandomizeOrder();

            foreach (Target target in targets)
            {
                try
                {
                    connect(target.Host, target.Port);
                    sendCR(msg_cp);
                    msg_cp = recvCC();
                    return;                                     // Connection established
                }
                catch (SqlEx ex)
                {
                    lastEx = ex;
                }
            }              // end for loop thru targets

            throw (lastEx != null) ? lastEx : SqlEx.get(ERR_GC4000_BAD_URL);
        }         // MsgConn
Ejemplo n.º 23
0
        write(IByteArray bytes, int offset, int length)
        {
            if (!need(length))
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": ByteArray length " + length + " too long");
                }
                close();
                throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
            }

            if (trace.enabled(4))
            {
                trace.write(title + ": appending " + length);
            }
            length    = bytes.get(offset, length, buffer, data_ptr);
            data_ptr += length;
            return(length);
        }         // write
Ejemplo n.º 24
0
        }          // getHost

        /*
        ** Name: getPort
        **
        ** Description:
        **	Extracts and returns the port number from the target string:
        **
        **	    <host>:<port>{,<port>}
        **
        **	The port may be specified as a numeric string or in standard
        **	Ingres installation ID format such as II0.
        **
        ** Input:
        **	target	Host/port list target string.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	String []	Port ID list.
        **
        ** History:
        **	 7-Jun-99 (gordy)
        **	    Created.
        **	 1-Oct-02 (gordy)
        **	    Extracted symbolic port translation to separate method.
        **	19-Oct-06 (lunbr01)  Sir 116548
        **	    Allow for IPv6 addresses enclosed in square brackets '[]'.
        **	 3-Nov-08 (gordy, ported by thoda04)
        **	    List of port ID's now supported and returned as individual
        **	    entries in an array.  Ports are no longer translated into
        **	    numeric values.
        */

        private String[] getPort(String target, String defaultPorts)
        {
            int index = 0;

            /*
            ** Skip past IPv6 host address if present.
            */
            if (target.StartsWith("["))
            {
                if ((index = target.IndexOf(']')) < 0)
                {
                    if (trace.enabled(1))
                    {
                        trace.write(title + ": right bracket ']' missing " +
                                    "in IPv6 address '" + target + "'");
                    }
                    throw SqlEx.get(ERR_GC4000_BAD_URL);
                }
            }

            index = target.IndexOf(':', index);

            if (index < 0 || target.Length <= (index + 1))
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ":port number missing '" + target + "'");
                }
                if (defaultPorts == null || defaultPorts.Length == 0)
                {
                    return new String[] { "II7" }
                }
                ;                                                       // default
                else
                {
                    return(parseList(defaultPorts, ','));
                }
            }

            return(parseList(target, ',', index + 1, 0));
        }          // getPort
Ejemplo n.º 25
0
        }         // write

        /*
        ** Name: write (inputStream)
        **
        ** Description:
        **	Append input stream to the output buffer.  This
        **	routine does not split buffers, the input stream
        **	is read until the buffer is filled or the stream
        **	is exhausted.  The number of bytes read from the
        **	input stream is returned.  It is the callers
        **	responsibility to assure that there is space
        **	available in the output buffer.
        **
        ** Input:
        **	inputStream	InputStream
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	short	Number of bytes written.
        **
        ** History:
        **	29-Sep-99 (gordy)
        **	    Created.
        */

        /// <summary>
        /// Append input stream to the output buffer.  This
        /// routine does not split buffers, the input stream
        /// is read until the buffer is filled or the stream
        /// is exhausted.  The number of bytes read from the
        /// input stream is returned.  It is the callers
        /// responsibility to assure that there is space
        /// available in the output buffer.
        /// </summary>
        /// <param name="inputStream"></param>
        /// <returns></returns>
        public virtual short write(InputStream inputStream)
        {
            int length = avail();

            try
            {
                length = inputStream.read(buffer, data_ptr, length);
            }
            catch (System.Exception ex)
            {
                throw SqlEx.get(ERR_GC4007_BLOB_IO, ex);
            }

            if (length < 0)
            {
                length = 0;
            }
            data_ptr += length;
            if (trace.enabled(5))
            {
                trace.write(title + ": appending " + length);
            }
            return((short)length);
        }          // write
Ejemplo n.º 26
0
        }          // flushBuffer

        /*
        ** Name: fillBuffer
        **
        ** Description:
        **	Read buffer from input stream if requested amount of data
        **	is not currently available ((seg_beg + size) > buf_len).
        **
        ** Input:
        **	size	Amount of data required.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	void
        **
        ** History:
        **	 9-Jun-99 (gordy)
        **	    Created.
        **	17-nov-04 (thoda04) Bug 113485
        **	    Trap closed connection (EOF returned) on Read of server data.
        */

        /// <summary>
        /// Read buffer from input stream if requested amount of data
        /// is not currently available ((seg_beg + size) > buf_len).
        /// </summary>
        /// <param name="size">Amount of data required.</param>
        private void  fillBuffer(int size)
        {
            /*
            ** Check to see if data is currently available.
            */
            if ((seg_beg + size) <= buf_len)
            {
                return;
            }

            /*
            ** The buffer size should have been negotiated
            ** at connection time and any segment should
            ** fit in the buffer.
            */
            if (size > buf_max)
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": buffer overflow (" + size + "," + buf_max + ")");
                }
                close();
                throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
            }

            /*
            ** Maximize space available for new data.
            */
            if (seg_beg > 0)
            {
                int offset;

                for (offset = 0; (seg_beg + offset) < buf_len; offset++)
                {
                    buffer[offset] = buffer[seg_beg + offset];
                }

                buf_len -= seg_beg;
                seg_end -= seg_beg;
                seg_beg  = 0;
            }

            while (buf_len < size)
            {
                int length;

                if (trace.enabled(5))
                {
                    trace.write(title + ": reading " + (buf_max - buf_len) + " bytes (" + size + " requested, " + buf_len + " buffered)");
                }

                try
                {
                    length = inputStream.Read(buffer, buf_len, buf_max - buf_len);
                }
                catch (Exception ex)
                {
                    if (trace.enabled(1))
                    {
                        trace.write(title + ": read error: " + ex.Message);
                    }
                    close();
                    throw SqlEx.get(ERR_GC4003_CONNECT_FAIL, ex);
                }

                if (length < 1)                  // if EOF due to server closing the connection
                {
                    if (trace.enabled(1))
                    {
                        trace.write(title + ": connection closed by server");
                    }
                    close();
                    throw SqlEx.get(ERR_GC4003_CONNECT_FAIL);
                }

                if (trace.enabled(4))
                {
                    trace.write(title + ": received " + length + " bytes.");
                    trace.hexdump(buffer, buf_len, length);
                }

                buf_len += length;
            }

            return;
        }         // fillBuffer
Ejemplo n.º 27
0
        }         // setCharSet

        /*
        ** Name: translatePortID
        **
        ** Description:
        **	Translates a symbolic or numeric port ID to a port number.
        **	A negative value is returned if an error occurs.
        **
        ** Input:
        **	port	Port ID.
        **
        ** Ouptut:
        **	None.
        **
        ** Returns:
        **	int	Port number.
        **
        ** History:
        **	 1-Oct-02 (gordy)
        **	    Extracted from getPort().
        **	 3-Nov-08 (gordy, ported by thoda04)
        **	    Throws exception if symbolic port ID cannot be translated
        **	    into numeric value.
        **	 3-Nov-08 (gordy, ported by thoda04)
        **	    Support extended subports.
        */

        private int  translatePortID(String port)
        {
            int  portnum;
            int  subport = 0;
            char c0, c1;

            /*
            ** Check for Ingres Installation ID format: [a-zA-Z][a-zA-Z0-9]{n}
            ** where n is [0-9] | 0[0-9] | 1[0-5]
            */
            switch (port.Length)
            {
            case 4:
                /*
                ** Check most significant digit of subport.
                */
                c0 = port[2];
                if (!Char.IsDigit(c0))                  // symbolic like II15 ?
                {
                    break;                              /* Not a symbolic port ID */
                }

                /*
                ** Save most significant digit so that it may be
                ** combined with least significant digit below.
                */
                subport = Int32.Parse(c0.ToString()) * 10;

                goto case 3;                          // Fall through to process least significant digit...

            case 3:
                /*
                ** Check least significant digit of subport
                ** (Optional most significant digit may be
                ** present and was processed above).
                */
                c0 = port[port.Length - 1];             // look at last digit
                if (!Char.IsDigit(c0))                  // symbolic like II15 or II7?
                {
                    break;                              /* Not a symbolic port ID */
                }

                /*
                ** Combine least significant digit with optional
                ** most significant digit processed in prior case
                ** and check for valid range.
                */
                subport += Int32.Parse(c0.ToString());
                if (subport > 15)
                {
                    break;                            /* Not a symbolic port ID */
                }
                goto case 2;                          // Fall through to process instance ID...

            case 2:
                /*
                ** Check for valid instance ID.
                */
                c0 = port[0];
                c1 = port[1];
                if (!(Char.IsLetter(c0) &&                             // symbolic like II ?
                      Char.IsLetterOrDigit(c1)))
                {
                    break;                              /* Not a symbolic port ID */
                }

                /*
                ** Map symbolic port ID to numeric port.
                ** Subport was generated in prior cases
                ** or defaulted to 0.
                */
                c0 = Char.ToUpper(c0);
                c1 = Char.ToUpper(c1);

                portnum = (((subport > 0x07) ? 0x02 : 0x01) << 14)
                          | ((c0 & 0x1f) << 9)
                          | ((c1 & 0x3f) << 3)
                          | (subport & 0x07);

                if (trace.enabled(5))
                {
                    trace.write(title + ": " + port + " => " + portnum);
                }

                return(portnum);
            }

            try { portnum = Int32.Parse(port); }
            catch (Exception)
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": invalid port ID '" + port + "'");
                }
                throw SqlEx.get(ERR_GC4000_BAD_URL);
            }

            return(portnum);
        }         // translatePortID
Ejemplo n.º 28
0
        connect(String host, String portID)
        {
            int i;

            System.Net.IPAddress[] ipAddresses;

            System.Net.IPEndPoint ipEndPoint = null;
            socket        = null;
            ipAddresses   = null;
            ipAddress     = null;
            socketIsLocal = false;

            try
            {
                if (trace.enabled(2))
                {
                    trace.write(title + ": opening network connection '" +
                                host + "', '" + portID + "'");
                }

                if (host == null ||
                    host.Length == 0 ||                       // if local machine
                    host.ToLowerInvariant() == "(local)")
                {
                    ipAddresses   = System.Net.Dns.GetHostAddresses(System.Net.Dns.GetHostName());
                    socketIsLocal = true;
                }
                else
                {
                    ipAddresses = System.Net.Dns.GetHostAddresses(host);
                }

                int port = translatePortID(portID);

                for (i = 0; i < ipAddresses.Length; i++)                  // loop addresses
                {
                    ipAddress = ipAddresses[i];

                    if (trace.enabled(3))
                    {
                        string address = ipAddress.ToString() + "  ";
                        address += ipAddress.AddressFamily.ToString();
                        if (ipAddress.AddressFamily ==
                            System.Net.Sockets.AddressFamily.InterNetwork)
                        {
                            address += "(IPv4)";
                        }
                        else if (ipAddress.AddressFamily ==
                                 System.Net.Sockets.AddressFamily.InterNetworkV6)
                        {
                            address += "(IPv6),";
                            address += "ScopeId=" + ipAddress.ScopeId.ToString();
                        }
                        trace.write(title + ": host address " + address +
                                    "; port=" + port);
                    }

                    ipEndPoint = new System.Net.IPEndPoint(ipAddress, port);
                    socket     = new MsgSocket(ipAddress.AddressFamily);
                    try
                    {
                        socket.Connect(ipEndPoint);
                        if (trace.enabled(3))
                        {
                            trace.write(title + ": connected to host address and port");
                        }
                        return;                          // success!
                    }
                    catch (Exception ex)
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(title + ": connection failed to address[" + i + "]=" + ipAddress + " - " + ex.Message);
                        }
                        if (i == (ipAddresses.Length - 1))
                        {
                            throw;                               // continue throw of last exception up chain
                        }
                        // else try next address on list.
                    }
                }                  // end for loop through ipHostInfo.AddressList

                if (i == ipAddresses.Length)
                {                  // should not have reached this point but we will bullet-proof
                    trace.write(title + ": connection error - all addresses failed");
                    throw SqlEx.get(ERR_GC4001_CONNECT_ERR);
                }
            }              // end try block
            catch (System.Net.Sockets.SocketException ex)
            {
                if (trace.enabled(1))
                {
                    trace.write(title +
                                ": error connecting to host - (SocketException) " +
                                ex.Message);
                }
                SqlEx pex = (SqlEx)
                            SqlEx.get(ERR_GC4001_CONNECT_ERR, ex);
                // "Unable to establish connection due to communications error."
                if (ipAddresses == null)                  // is it the GetHostAddresses( )
                {
                    pex = SqlEx.get(pex, SqlEx.get(
                                        "SocketException thrown " +
                                        "by System.Net.Dns.GetHostAddresses(" +
                                        (host == null?"<null>":("\"" + host + "\"")) + ") " +
                                        "in resolving the hostname",
                                        "08001", ex.ErrorCode));
                }
                else                  // must be TcpClient( ) call
                {
                    pex = SqlEx.get(pex, SqlEx.get(
                                        "SocketException thrown " +
                                        "by System.Net.Sockets.TcpClient( ) " +
                                        "while connecting to host " +
                                        (host == null ? "<null>" : ("\"" + host + "\".")),
                                        "08001", ex.ErrorCode));
                }

                socket    = null;
                ipAddress = null;

                throw pex;
            }
            catch (System.Exception ex)
            {
                if (trace.enabled(1))
                {
                    trace.write(title + ": error connecting to host - " + ex.Message);
                }

                socket    = null;
                ipAddress = null;

                throw SqlEx.get(ERR_GC4001_CONNECT_ERR, ex);
            }
        }          // connect
Ejemplo n.º 29
0
        }          // readError

        /*
        ** Name: readResult
        **
        ** Description:
        **	Read a RESULT message.  The RESULT message parameters are read
        **	and saved in instance fields.
        **
        **	Returning a value of TRUE will interrupt the processing of
        **	server messages by readResults() and cause an immediate return.
        **
        ** Input:
        **	None.
        **
        ** Output:
        **	None.
        **
        ** Returns:
        **	boolean	True for interrupt, False to continue.
        **
        ** History:
        **	31-Oct-02 (gordy)
        **	    Extracted from readResults().
        **	21-Feb-03 (gordy)
        **	    Added table and object keys.
        **	20-Aug-03 (gordy)
        **	    Consolidated result flags into single parameter.
        **	 6-Oct-03 (gordy)
        **	    Renamed and changed return type to reflect ability
        **	    for intermediate RESULT messages to be processed.
        */

        protected internal virtual bool readResult()
        {
            while (msg.moreData())
            {
                short param_id  = msg.readShort();
                short param_len = msg.readShort();

                switch (param_id)
                {
                case MSG_RP_ROWCOUNT:
                    switch (param_len)
                    {
                    case 1:  rslt_val_rowcnt = msg.readByte(); break;

                    case 2:  rslt_val_rowcnt = msg.readShort(); break;

                    case 4:  rslt_val_rowcnt = msg.readInt(); break;

                    default:
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id +
                                        ": Invalid rowcount len " + param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }
                    rslt_rowcount = true;
                    break;

                case MSG_RP_XACT_END:
                    if (param_len > 0)
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id + ": Invalid XACT param len " + param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    rslt_flags |= MSG_RF_XACT_END;
                    conn.endXact();
                    break;

                case MSG_RP_STMT_ID:
                    if (param_len != 8)
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id + ": Invalid STMT_ID len " + param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    rslt_val_stmt =
                        (((long)msg.readInt()) << 32) |
                        (((long)msg.readInt()) &
                         (int)(-(0x100000000 - 0xffffffff)));
                    break;

                case MSG_RP_FETCH_LIMIT:
                    switch (param_len)
                    {
                    case 1:  rslt_val_fetch = msg.readByte();  break;

                    case 2:  rslt_val_fetch = msg.readShort(); break;

                    case 4:  rslt_val_fetch = msg.readInt();   break;

                    default:
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id +
                                        ": Invalid fetchlimit len " +
                                        param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }
                    rslt_prefetch = true;
                    break;

                case MSG_RP_EOD:
                    if (param_len != 0)
                    {
                        trace.write(tr_id + ": Invalid EOD len " +
                                    param_len);
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }
                    rslt_flags |= MSG_RF_EOD;
                    break;

                case MSG_RP_PROC_RESULT:
                    switch (param_len)
                    {
                    case 1: setProcResult((int)msg.readByte());  break;

                    case 2: setProcResult((int)msg.readShort()); break;

                    case 4: setProcResult(msg.readInt());   break;

                    default:
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id + ": Invalid proc result len" + param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }
                    break;


                case MSG_RP_READ_ONLY:
                    if (param_len != 0)
                    {
                        trace.write(tr_id + ": Invalid READ_ONLY len " + param_len);
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }
                    rslt_flags |= MSG_RF_READ_ONLY;
                    break;

                case MSG_RP_TBLKEY:
                    if (param_len != MSG_RPV_TBLKEY_LEN)
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id +
                                        ": Invalid table key length: " +
                                        param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    if (rslt_val_tblkey == null)
                    {
                        rslt_val_tblkey = new byte[param_len];
                    }
                    msg.readBytes(rslt_val_tblkey, 0, param_len);
                    rslt_tblkey = true;
                    break;

                case MSG_RP_OBJKEY:
                    if (param_len != MSG_RPV_OBJKEY_LEN)
                    {
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id + ": Invalid object key length: " +
                                        param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    if (rslt_val_objkey == null)
                    {
                        rslt_val_objkey = new byte[param_len];
                    }
                    msg.readBytes(rslt_val_objkey, 0, param_len);
                    rslt_objkey = true;
                    break;

                case MSG_RP_FLAGS:
                {
                    int flags;

                    switch (param_len)
                    {
                    case 1: flags = msg.readByte();   break;

                    case 2: flags = msg.readShort();  break;

                    case 4: flags = msg.readInt();    break;

                    default:
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id +
                                        ": Invalid result flags length: " +
                                        param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    rslt_flags |= flags;
                    if ((flags & MSG_RF_XACT_END) != 0)
                    {
                        conn.endXact();
                    }
                    break;
                }

                case MSG_RP_ROW_STATUS:
                    switch (param_len)
                    {
                    case 1: rslt_val_rowstat = msg.readByte(); break;

                    case 2: rslt_val_rowstat = msg.readShort(); break;

                    case 4: rslt_val_rowstat = msg.readInt(); break;

                    default:
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id +
                                        ": Invalid row status length: " +
                                        param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    rslt_items |= RSLT_ROW_STAT;
                    break;

                case MSG_RP_ROW_POS:
                    switch (param_len)
                    {
                    case 1: rslt_val_rowpos = msg.readByte(); break;

                    case 2: rslt_val_rowpos = msg.readShort(); break;

                    case 4: rslt_val_rowpos = msg.readInt(); break;

                    default:
                        if (trace.enabled(1))
                        {
                            trace.write(tr_id +
                                        ": Invalid row position length: " +
                                        param_len);
                        }
                        throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                    }

                    rslt_items |= RSLT_ROW_POS;
                    break;

                default:
                    if (trace.enabled(1))
                    {
                        trace.write(tr_id +
                                    ": Invalid result param ID " + param_id);
                    }
                    throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
                }          // end switch
            }              // end while

            return(false);
        }          // readResult
Ejemplo n.º 30
0
        getColumnClassName(int column)
        {
            String name;

            System.Type oc = typeof(System.Object);

            if (trace.enabled())
            {
                trace.log(title + ".getColumnClassName( " + column + " )");
            }

            switch (desc[(column = columnMap(column))].sql_type)
            {
            case ProviderType.Boolean:
                oc = typeof(System.Boolean); break;

            case ProviderType.TinyInt:
            case ProviderType.SmallInt:
            case ProviderType.Integer:
                oc = typeof(System.Int32); break;

            case ProviderType.BigInt:
                oc = typeof(System.Int64); break;

            case ProviderType.Single:
                oc = typeof(System.Single); break;

            case ProviderType.Double:
                oc = typeof(System.Double); break;

            case ProviderType.Numeric:
            case ProviderType.Decimal:
                oc = typeof(System.Decimal); break;

            case ProviderType.Char:
            case ProviderType.VarChar:
            case ProviderType.LongVarChar:
                oc = typeof(String); break;


            case ProviderType.Binary:
            case ProviderType.VarBinary:
            case ProviderType.LongVarBinary:
                oc = typeof(System.Byte); break;


            case ProviderType.Date:
            case ProviderType.Time:
            case ProviderType.DateTime:
                oc = typeof(System.DateTime); break;

            default:
                if (trace.enabled(1))
                {
                    trace.write(title + ": invalid SQL type " + desc[column].sql_type);
                }
                throw SqlEx.get(ERR_GC4002_PROTOCOL_ERR);
            }

            name = oc.FullName;
            if (trace.enabled())
            {
                trace.log(title + ".getColumnClassName: " + name);
            }
            return(name);
        }         // getColumnClassName