| /********************************************************************** |
| // @@@ START COPYRIGHT @@@ |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| // @@@ END COPYRIGHT @@@ |
| **********************************************************************/ |
| /* -*-C++-*- |
| ***************************************************************************** |
| * |
| * File: UdrExeIpc.cpp |
| * Description: IPC streams and message objects shared by the SQL/MX |
| * executor and the UDR server |
| * |
| * Created: 08/20/2000 |
| * Language: C++ |
| * |
| ***************************************************************************** |
| */ |
| |
| #include <iostream> |
| |
| #include "ComTransInfo.h" |
| #include "IpcMessageObj.h" |
| #include "ComplexObject.h" |
| #include "CliMsgObj.h" |
| #include "UdrExeIpc.h" |
| #include "sql_buffer.h" |
| #include "ExCextdecs.h" |
| #include "ComRtUtils.h" |
| |
| |
| //---------------------------------------------------------------------- |
| // UDR debugging code. See comments in UdrExeIpc.h. |
| //---------------------------------------------------------------------- |
| #ifdef UDR_DEBUG |
| #include <stdarg.h> |
| void UdrPrintf(FILE *f, const char *formatString, ...) |
| { |
| if (f) |
| { |
| va_list args; |
| va_start(args, formatString); |
| fprintf(f, "[UDR] "); |
| vfprintf(f, formatString, args); |
| fprintf(f, "\n"); |
| fflush(f); |
| } |
| } |
| #endif |
| |
| const char *GetUdrIpcTypeString(UdrIpcObjectType t) |
| { |
| switch (t) |
| { |
| case UDR_MSG_LOAD: return "UDR_MSG_LOAD"; |
| case UDR_MSG_LOAD_REPLY: return "UDR_MSG_LOAD_REPLY"; |
| case UDR_MSG_UNLOAD: return "UDR_MSG_UNLOAD"; |
| case UDR_MSG_UNLOAD_REPLY: return "UDR_MSG_UNLOAD_REPLY"; |
| case UDR_MSG_DATA_HEADER: return "UDR_MSG_DATA_HEADER"; |
| case UDR_MSG_DATA_REQUEST: return "UDR_MSG_DATA_REQUEST"; |
| case UDR_MSG_DATA_REPLY: return "UDR_MSG_DATA_REPLY"; |
| case UDR_MSG_CONTINUE_REQUEST: return "UDR_MSG_CONTINUE_REQUEST"; |
| case UDR_MSG_ERROR_REPLY: return "UDR_MSG_ERROR_REPLY"; |
| case UDR_MSG_SESSION: return "UDR_MSG_SESSION"; |
| case UDR_MSG_SESSION_REPLY: return "UDR_MSG_SESSION_REPLY"; |
| case UDR_MSG_ENTER_TX: return "UDR_MSG_ENTER_TX"; |
| case UDR_MSG_ENTER_TX_REPLY: return "UDR_MSG_ENTER_TX_REPLY"; |
| case UDR_MSG_EXIT_TX: return "UDR_MSG_EXIT_TX"; |
| case UDR_MSG_EXIT_TX_REPLY: return "UDR_MSG_EXIT_TX_REPLY"; |
| case UDR_MSG_RS_LOAD: return "UDR_MSG_RS_LOAD"; |
| case UDR_MSG_RS_LOAD_REPLY: return "UDR_MSG_RS_LOAD_REPLY"; |
| case UDR_MSG_RS_DATA_HEADER: return "UDR_MSG_RS_DATA_HEADER"; |
| case UDR_MSG_RS_CONTINUE: return "UDR_MSG_RS_CONTINUE"; |
| case UDR_MSG_RS_CLOSE: return "UDR_MSG_RS_CLOSE"; |
| case UDR_MSG_RS_CLOSE_REPLY: return "UDR_MSG_RS_CLOSE_REPLY"; |
| case UDR_MSG_RS_UNLOAD: return "UDR_MSG_RS_UNLOAD"; |
| case UDR_MSG_RS_UNLOAD_REPLY: return "UDR_MSG_RS_UNLOAD_REPLY"; |
| case UDR_MSG_RS_INFO: return "UDR_MSG_RS_INFO"; |
| case UDR_MSG_SUSPEND_TX: return "UDR_MSG_SUSPEND_TX"; |
| case UDR_MSG_SUSPEND_TX_REPLY: return "UDR_MSG_SUSPEND_TX_REPLY"; |
| case UDR_STREAM_CLIENT_CONTROL: return "UDR_STREAM_CLIENT_CONTROL"; |
| case UDR_STREAM_SERVER_CONTROL: return "UDR_STREAM_SERVER_CONTROL"; |
| case UDR_STREAM_CLIENT_DATA: return "UDR_STREAM_CLIENT_DATA"; |
| case UDR_STREAM_SERVER_DATA: return "UDR_STREAM_SERVER_DATA"; |
| case UDR_STREAM_SERVER_REPLY: return "UDR_STREAM_SERVER_REPLY"; |
| case UDR_IPC_INVALID: return "UDR_IPC_INVALID"; |
| default: return ComRtGetUnknownString((Int32) t); |
| } |
| } |
| |
| // |
| // Helper function to determine number of bytes that a string |
| // will occupy in a packed IpcMessageObj. |
| // |
| inline static IpcMessageObjSize packedStringLength(const char *s) |
| { |
| // |
| // The string will be preceded by a 4-byte length field and will |
| // include the null-terminator |
| // |
| IpcMessageObjSize result; |
| result = sizeof(Lng32); |
| if (s) |
| { |
| result += str_len(s) + 1; |
| } |
| return result; |
| } |
| |
| // ----------------------------------------------------------------------- |
| // class UdrParameterInfo |
| // ----------------------------------------------------------------------- |
| UdrParameterInfo::UdrParameterInfo(ComUInt32 position, |
| ComUInt32 flags, |
| ComSInt16 fsType, |
| ComSInt16 ansiType, |
| ComUInt16 paramNameLen, |
| const char *paramName, |
| ComUInt16 prec, |
| ComUInt16 scale, |
| ComUInt16 encodingCharSet, |
| ComUInt16 collation, |
| ComUInt32 dataLength, |
| ComSInt16 nullIndicatorLength, |
| ComSInt32 nullIndicatorOffset, |
| ComUInt32 dataOffset, |
| ComSInt32 vcLenIndOffset, |
| ComSInt16 vcIndicatorLength) |
| |
| : position_(position), |
| flags_(flags), |
| fsType_(fsType), |
| ansiType_(ansiType), |
| paramNameLen_((short) paramNameLen), |
| prec_(prec), |
| scale_(scale), |
| encodingCharSet_(encodingCharSet), |
| collation_(collation), |
| dataLength_(dataLength), |
| nullIndicatorLength_(nullIndicatorLength), |
| nullIndicatorOffset_(nullIndicatorOffset), |
| dataOffset_(dataOffset), |
| vcLenIndOffset_(vcLenIndOffset), |
| vcIndicatorLength_(vcIndicatorLength) |
| { |
| UdrExeAssert(paramNameLen <= 128, "Param name length cannot exceed 128"); |
| if (paramNameLen > 0) |
| str_cpy_all(paramName_, paramName, paramNameLen); |
| paramName_[paramNameLen_] = 0; |
| } |
| |
| IpcMessageObjSize UdrParameterInfo::packedLength() const |
| { |
| IpcMessageObjSize result = 0; |
| result += sizeof(position_); |
| result += sizeof(flags_); |
| result += sizeof(fsType_); |
| result += sizeof(ansiType_); |
| result += sizeof(paramNameLen_); |
| result += paramNameLen_; |
| result += sizeof(prec_); |
| result += sizeof(scale_); |
| result += sizeof(encodingCharSet_); |
| result += sizeof(collation_); |
| result += sizeof(dataLength_); |
| result += sizeof(nullIndicatorLength_); |
| result += sizeof(nullIndicatorOffset_); |
| result += sizeof(dataOffset_); |
| result += sizeof(vcLenIndOffset_); |
| result += sizeof(vcIndicatorLength_); |
| return result; |
| } |
| |
| IpcMessageObjSize UdrParameterInfo::pack(IpcMessageBufferPtr &buffer) const |
| { |
| IpcMessageObjSize result = 0; |
| result += packIntoBuffer(buffer, position_); |
| result += packIntoBuffer(buffer, flags_); |
| result += packIntoBuffer(buffer, fsType_); |
| result += packIntoBuffer(buffer, ansiType_); |
| result += packIntoBuffer(buffer, paramNameLen_); |
| if (paramNameLen_ > 0) |
| result += packStrIntoBuffer(buffer, (char *) (¶mName_[0]), |
| paramNameLen_); |
| result += packIntoBuffer(buffer, prec_); |
| result += packIntoBuffer(buffer, scale_); |
| result += packIntoBuffer(buffer, encodingCharSet_); |
| result += packIntoBuffer(buffer, collation_); |
| result += packIntoBuffer(buffer, dataLength_); |
| result += packIntoBuffer(buffer, nullIndicatorLength_); |
| result += packIntoBuffer(buffer, nullIndicatorOffset_); |
| result += packIntoBuffer(buffer, dataOffset_); |
| result += packIntoBuffer(buffer, vcLenIndOffset_); |
| result += packIntoBuffer(buffer, vcIndicatorLength_); |
| return result; |
| } |
| |
| void UdrParameterInfo::unpack(IpcConstMessageBufferPtr &buffer) |
| { |
| unpackBuffer(buffer, position_); |
| unpackBuffer(buffer, flags_); |
| unpackBuffer(buffer, fsType_); |
| unpackBuffer(buffer, ansiType_); |
| unpackBuffer(buffer, paramNameLen_); |
| if (paramNameLen_ > 0) |
| unpackStrFromBuffer(buffer, paramName_, paramNameLen_); |
| paramName_[paramNameLen_] = 0; |
| unpackBuffer(buffer, prec_); |
| unpackBuffer(buffer, scale_); |
| unpackBuffer(buffer, encodingCharSet_); |
| unpackBuffer(buffer, collation_); |
| unpackBuffer(buffer, dataLength_); |
| unpackBuffer(buffer, nullIndicatorLength_); |
| unpackBuffer(buffer, nullIndicatorOffset_); |
| unpackBuffer(buffer, dataOffset_); |
| unpackBuffer(buffer, vcLenIndOffset_); |
| unpackBuffer(buffer, vcIndicatorLength_); |
| } |
| |
| UdrParameterInfo& UdrParameterInfo::operator=(const UdrParameterInfo &other) |
| { |
| //-------------------------------------- |
| // Nothing to do when copying yourself |
| //-------------------------------------- |
| if (this == &other) |
| { |
| return *this; |
| } |
| |
| position_ = other.position_; |
| flags_ = other.flags_; |
| fsType_ = other.fsType_; |
| ansiType_ = other.ansiType_; |
| paramNameLen_ = other.paramNameLen_; |
| str_cpy_all(paramName_, other.paramName_, paramNameLen_ + 1); |
| prec_ = other.prec_; |
| scale_ = other.scale_; |
| encodingCharSet_ = other.encodingCharSet_; |
| collation_ = other.collation_; |
| dataLength_ = other.dataLength_; |
| nullIndicatorLength_ = other.nullIndicatorLength_; |
| nullIndicatorOffset_ = other.nullIndicatorOffset_; |
| dataOffset_ = other.dataOffset_; |
| vcLenIndOffset_ = other.vcLenIndOffset_; |
| vcIndicatorLength_ = other.vcIndicatorLength_; |
| |
| return *this; |
| |
| } //UdrParameterInfo::operator= |
| |
| |
| void UdrParameterInfo::display(FILE *f, Lng32 indent, |
| UdrParameterInfo *pi) const |
| { |
| char ind[100]; |
| Lng32 indIdx = 0; |
| if (indent > 99) |
| { |
| indent = 99; |
| } |
| for (indIdx = 0; indIdx < indent; indIdx++) |
| { |
| ind[indIdx] = ' '; |
| } |
| ind[indIdx] = '\0'; |
| |
| fprintf(f, "\n"); |
| fprintf(f, "%sContents of UdrParameterInfo:\n", ind); |
| fprintf(f, "%s-----------------------------\n", ind ); |
| |
| fprintf(f, "%sPosition : %d\n", ind , |
| (Lng32) pi->getPosition()); |
| fprintf(f, "%sFS Data Type : %d\n", ind , |
| (Lng32) pi->getFSType()); |
| fprintf(f, "%sANSI Data Type : %d\n", ind , |
| (Lng32) pi->getAnsiType()); |
| fprintf(f, "%sPrecision : %d\n", ind , |
| (Lng32) pi->getPrec()); |
| fprintf(f, "%sScale : %d\n", ind , |
| (Lng32) pi->getScale()); |
| fprintf(f, "%sencodingCharSet : %d\n", ind , |
| (Lng32) pi->getEncodingCharSet()); |
| fprintf(f, "%scollation : %d\n", ind , |
| (Lng32) pi->getCollation()); |
| |
| if (pi->isInOut()) |
| { |
| fprintf(f, "%sMode : INOUT\n", ind ); |
| } |
| else if (pi->isIn()) |
| { |
| fprintf(f, "%sMode : IN\n", ind ); |
| } |
| else if (pi->isOut()) |
| { |
| fprintf(f, "%sMode : OUT\n", ind ); |
| } |
| else |
| { |
| fprintf(f, "%sMode : INVALID\n", ind ); |
| } |
| |
| if (pi->isLmObjType()) |
| fprintf(f, "%sObject Mapping : TRUE\n", ind ); |
| else |
| fprintf(f, "%sObject Mapping : FALSE\n", ind ); |
| |
| if (pi->isNullable()) |
| fprintf(f, "%sNull Flag : TRUE\n", ind ); |
| else |
| fprintf(f, "%sNull Flag : FALSE\n", ind ); |
| |
| fprintf(f, "%sNull Indicator Length : %d\n", |
| ind , (Lng32) pi->getNullIndicatorLength()); |
| |
| fprintf(f, "%sNull Indicator Offset : %d\n", |
| ind , (Lng32) pi->getNullIndicatorOffset()); |
| |
| fprintf(f, "%sVC Len Indicator Offset : %d\n", |
| ind , (Lng32) pi->getVCLenIndOffset()); |
| |
| fprintf(f, "%sVC Indicator Length : %d\n", |
| ind , (Lng32) pi->getVCIndicatorLength()); |
| |
| fprintf(f, "%sData Offset : %d\n", |
| ind , (Lng32) pi->getDataOffset()); |
| |
| fprintf(f, "%sData Length : %d\n", |
| ind , (Lng32) pi->getDataLength()); |
| |
| fprintf(f, "%sPosition : %d\n\n", |
| ind , (Lng32) pi->getPosition()); |
| |
| fflush(f); |
| |
| } // UdrParameterInfo::display |
| |
| UdrTableInputInfo::UdrTableInputInfo( |
| ComUInt16 tabIndex, |
| ComUInt16 tableNameLen, |
| const char *tableName, |
| ComUInt16 numColumns, |
| ComUInt32 outputRowLen |
| ) |
| :tabIndex_(tabIndex), |
| tableNameLen_(tableNameLen), |
| numColumns_(numColumns), |
| outputRowLen_(outputRowLen), |
| inTableColumnDescs_(NULL) |
| { |
| if (tableNameLen >0) |
| { |
| str_cpy_all(tableName_,tableName,tableNameLen); |
| tableName_[tableNameLen_] = 0; |
| } |
| |
| } |
| const UdrParameterInfo &UdrTableInputInfo::getInTableColumnDesc(ComUInt32 i) const |
| { |
| UdrExeAssert(inTableColumnDescs_ && numColumns_ > i, |
| "An invalid index was passed to UdrLoadMsg::getInTableCoumndesc()"); |
| return inTableColumnDescs_[i]; |
| } |
| |
| void UdrTableInputInfo::setInTableColumnDesc(ComUInt32 i, const UdrParameterInfo &info, NAMemory *heap) |
| { |
| UdrExeAssert(numColumns_ > i, |
| "An invalid index was passed to UdrLoadMsg::setInTableColumnDesc()"); |
| |
| if(inTableColumnDescs_== NULL) |
| { |
| // allocate memory for the column desc info for this table desc entry |
| const ComUInt32 colsize= numColumns_ *sizeof(UdrParameterInfo); |
| inTableColumnDescs_ = (UdrParameterInfo *)(colsize ? |
| heap->allocateMemory(colsize) : NULL); |
| } |
| inTableColumnDescs_[i] = info; |
| } |
| |
| UdrTableInputInfo& UdrTableInputInfo::operator=(const UdrTableInputInfo &other) |
| { |
| tabIndex_ = other.tabIndex_; |
| tableNameLen_ = other.tableNameLen_; |
| str_cpy_all(tableName_,other.tableName_,tableNameLen_+1); |
| |
| numColumns_ = other.numColumns_; |
| outputRowLen_ = other.outputRowLen_; |
| inTableColumnDescs_ = other.inTableColumnDescs_; |
| return *this; |
| |
| } |
| IpcMessageObjSize UdrTableInputInfo::packedLength() const |
| { |
| IpcMessageObjSize result = 0; |
| result += sizeof(tabIndex_); |
| result += sizeof(tableNameLen_); |
| result += tableNameLen_; |
| result += sizeof(numColumns_); |
| result +=sizeof(outputRowLen_); |
| UInt32 i = 0; |
| for (i = 0; i < numColumns_; i++) |
| { |
| UdrParameterInfo &cinfo = inTableColumnDescs_[i]; |
| result += cinfo.packedLength(); |
| } |
| return result; |
| } |
| |
| IpcMessageObjSize UdrTableInputInfo::pack(IpcMessageBufferPtr &buffer) const |
| { |
| IpcMessageObjSize result = 0; |
| result += packIntoBuffer(buffer,tabIndex_); |
| result += packIntoBuffer(buffer,tableNameLen_); |
| if (tableNameLen_ >0) |
| result += packStrIntoBuffer(buffer,(char *)(&tableName_[0]), |
| tableNameLen_); |
| |
| result += packIntoBuffer(buffer,numColumns_); |
| result += packIntoBuffer(buffer,outputRowLen_); |
| UInt32 i = 0; |
| |
| for (i=0; i < numColumns_; i++) |
| { |
| const UdrParameterInfo &cinfo = inTableColumnDescs_[i]; |
| result += cinfo.pack(buffer); |
| } |
| return result; |
| } |
| |
| void UdrTableInputInfo::unpack(IpcConstMessageBufferPtr &buffer, NAMemory *heap) |
| { |
| unpackBuffer(buffer,tabIndex_); |
| unpackBuffer(buffer,tableNameLen_); |
| if (tableNameLen_ >0) |
| unpackStrFromBuffer(buffer,tableName_,tableNameLen_); |
| tableName_[tableNameLen_] = 0; |
| unpackBuffer(buffer,numColumns_); |
| unpackBuffer(buffer,outputRowLen_); |
| |
| // allocate memory for the column desc info for this table desc entry |
| const ComUInt32 colsize= numColumns_ *sizeof(UdrParameterInfo); |
| inTableColumnDescs_ = (UdrParameterInfo *)(colsize ? |
| heap->allocateMemory(colsize) : NULL); |
| ComUInt32 i; |
| for (i = 0; i < numColumns_; i++) |
| { |
| UdrParameterInfo &cinfo = inTableColumnDescs_[i]; |
| cinfo.unpack(buffer); |
| } |
| } |
| // ----------------------------------------------------------------------- |
| // class UdrMessageObj |
| // ----------------------------------------------------------------------- |
| UdrMessageObj::UdrMessageObj(UdrIpcObjectType objType, |
| IpcMessageObjVersion objVersion, |
| NAMemory *heap) |
| : IpcMessageObj(objType, objVersion), |
| heap_(heap), |
| handle_(INVALID_UDR_HANDLE) |
| { |
| } |
| |
| void UdrMessageObj::operator delete(void *p) |
| { |
| if (p) |
| { |
| NAMemory *h = ((UdrMessageObj *) p)->getHeap(); |
| if (h) |
| { |
| h->deallocateMemory(p); |
| } |
| else |
| { |
| ::delete ((UdrMessageObj *) p); |
| } |
| } |
| } |
| |
| |
| IpcMessageObjSize UdrMessageObj::packedLength() |
| { |
| return udrBaseClassPackedLength(); |
| } |
| |
| IpcMessageObjSize UdrMessageObj::packObjIntoMessage(IpcMessageBufferPtr buffer) |
| { |
| return packUdrBaseClass(buffer); |
| } |
| |
| void UdrMessageObj::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| unpackUdrBaseClass(buffer); |
| } |
| |
| #ifdef UDR_DEBUG |
| // |
| // Debug-build flags to control when the UDR server will force |
| // corruption in certain reply messages. By forcing corruption in a |
| // reply we can test the IPC integrity checks and error handling in |
| // the executor. |
| // |
| // Note: in the future it may not be a good idea to maintain these |
| // flags as global variables. Right now they are globals only because |
| // that allows us to make fewer getenv() calls in the UDR server. The |
| // fields are being set by udrBaseClassPackedLength() and read by |
| // packUdrBaseClass(). That is OK for now because for a given LOAD or |
| // UNLOAD reply those two methods are always called in a predictable |
| // sequence by the message stream. This assumption about the sequence |
| // of calls may not always be valid. |
| // |
| static NABoolean corruptLoadReply = FALSE; |
| static NABoolean corruptUnloadReply = FALSE; |
| #endif |
| |
| IpcMessageObjSize UdrMessageObj::udrBaseClassPackedLength() |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| IpcMessageObjSize result = 0; |
| result += super::baseClassPackedLength(); |
| |
| #ifdef UDR_DEBUG |
| // We allow the debug-build UDR server to corrupt a LOAD or UNLOAD |
| // reply by not packing the UDR handle. Note that the getenv() tests |
| // check for empty strings as values. These environment variables |
| // ans set and unset dynamically, and apparently in OSS calling |
| // putenv("X=") does not remove the environment variable, instead |
| // the variable gets an empty string as its value. |
| NABoolean packTheHandle = TRUE; |
| IpcMessageType t = getType(); |
| if (t == UDR_MSG_LOAD_REPLY) |
| { |
| char *val = getenv("MXUDR_CORRUPT_LOAD_REPLY"); |
| corruptLoadReply = (val && val[0]); |
| if (corruptLoadReply) |
| { |
| packTheHandle = FALSE; |
| } |
| } |
| else if (t == UDR_MSG_UNLOAD_REPLY) |
| { |
| char *val = getenv("MXUDR_CORRUPT_UNLOAD_REPLY"); |
| corruptUnloadReply = (val && val[0]); |
| if (corruptUnloadReply) |
| { |
| packTheHandle = FALSE; |
| } |
| } |
| if (packTheHandle) |
| { |
| result += sizeof(handle_); |
| } |
| #else |
| result += sizeof(handle_); |
| #endif |
| |
| return result; |
| } |
| |
| IpcMessageObjSize UdrMessageObj::packUdrBaseClass(IpcMessageBufferPtr &buffer) |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| // |
| // Note that we don't pack the heap pointer |
| // |
| IpcMessageObjSize result; |
| result = super::packBaseClassIntoMessage(buffer); |
| |
| #ifdef UDR_DEBUG |
| // We allow the debug-build UDR server to corrupt a LOAD or UNLOAD |
| // reply by not packing the UDR handle. See commentary above in |
| // udrBaseClassPackedLength(). |
| NABoolean packTheHandle = TRUE; |
| IpcMessageType t = getType(); |
| if (t == UDR_MSG_LOAD_REPLY && corruptLoadReply) |
| { |
| packTheHandle = FALSE; |
| } |
| else if (t == UDR_MSG_UNLOAD_REPLY && corruptUnloadReply) |
| { |
| packTheHandle = FALSE; |
| } |
| if (packTheHandle) |
| { |
| result += packIntoBuffer(buffer, handle_); |
| } |
| #else |
| result += packIntoBuffer(buffer, handle_); |
| #endif |
| |
| return result; |
| } |
| |
| void UdrMessageObj::unpackUdrBaseClass(IpcConstMessageBufferPtr &buffer) |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| super::unpackBaseClass(buffer); |
| unpackBuffer(buffer, handle_); |
| } |
| |
| NABoolean UdrMessageObj::checkObj(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr buffer) const |
| { |
| return checkUdrBaseClass(t, v, sameEndianness, size, buffer); |
| } |
| |
| NABoolean UdrMessageObj::checkUdrBaseClass(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr &buf) const |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| const IpcConstMessageBufferPtr lastByte = buf + size - 1; |
| if (!super::checkBaseClass(t, v, sameEndianness, size, buf)) |
| return FALSE; |
| if (!checkBuffer(buf, sizeof(handle_), lastByte)) |
| return FALSE; |
| return TRUE; |
| } |
| |
| IpcMessageRefCount UdrMessageObj::decrRefCount() |
| { |
| IpcMessageRefCount result = 0; |
| |
| if (getRefCount() == 1) |
| { |
| // |
| // IpcMessageObj::decrRefCount() would delete the object by calling |
| // global operator delete since IpcMessageObj doesn't have an |
| // operator delete. However, if we code the "delete this" statement |
| // in the context of this class we will pick up the correct operator |
| // delete. |
| // |
| delete this; |
| result = 0; |
| } |
| else |
| { |
| // |
| // This is the normal case. The object won't be deleted |
| // |
| result = IpcMessageObj::decrRefCount(); |
| } |
| |
| return result; |
| } |
| |
| char *UdrMessageObj::allocateMemory(ComUInt32 nBytes) |
| { |
| char *result = NULL; |
| if (getHeap()) |
| { |
| result = (char *) getHeap()->allocateMemory(nBytes); |
| } |
| else |
| { |
| result = new char[nBytes]; |
| } |
| return result; |
| } |
| |
| void UdrMessageObj::deallocateMemory(char *s) |
| { |
| if (s) |
| { |
| if (getHeap()) |
| { |
| getHeap()->deallocateMemory(s); |
| } |
| else |
| { |
| delete [] s; |
| } |
| } |
| } |
| |
| char *UdrMessageObj::allocateString(const char *s) |
| { |
| char *result = NULL; |
| if (s) |
| { |
| ComUInt32 n = str_len(s) + 1; |
| result = allocateMemory(n); |
| str_cpy_all(result, s, (Lng32)n); |
| } |
| return result; |
| } |
| |
| void UdrMessageObj::deallocateString(char *&s) |
| { |
| deallocateMemory(s); |
| s = NULL; |
| } |
| |
| //---------------------------------------------------------------------- |
| // UdrControlStream |
| //---------------------------------------------------------------------- |
| UdrControlStream::UdrControlStream(IpcEnvironment *env, |
| IpcMessageType msgType, |
| IpcMessageObjVersion version) |
| : IpcMessageStream(env, |
| msgType, |
| version, |
| 0, // 0 implies no fixed buffer size |
| TRUE) // share message objects? |
| { |
| sendCount_ = 0; |
| recvCount_ = 0; |
| } |
| |
| UdrControlStream::~UdrControlStream() |
| { |
| } |
| |
| void UdrControlStream::actOnSend(IpcConnection *connection) |
| { |
| // Base class implementation does nothing |
| } |
| |
| void UdrControlStream::actOnReceive(IpcConnection *connection) |
| { |
| // Base class implementation does nothing |
| } |
| |
| //---------------------------------------------------------------------- |
| // UdrLoadMsg |
| //---------------------------------------------------------------------- |
| UdrLoadMsg::UdrLoadMsg(NAMemory *heap) |
| : UdrControlMsg(UDR_MSG_LOAD, UdrLoadMsgVersionNumber, heap), |
| sqlName_(NULL), routineName_(NULL), routineSignature_(NULL), |
| containerName_(NULL), externalPath_(NULL), librarySqlName_(NULL),transactionAttrs_(0), |
| sqlAccessMode_(0), language_(0), paramStyle_(0), |
| externalSecurity_(0), maxNumResultSets_(0), |
| numParameters_(0), numInValues_(0), numOutValues_(0), |
| inBufferSize_(0), outBufferSize_(0), |
| inputRowSize_(0), outputRowSize_(0), |
| udrFlags_(0), inParamInfo_(NULL), outParamInfo_(NULL), |
| routineOwnerId_(0), |
| parentQid_(NULL), |
| numInputTables_(0), |
| inTables_(NULL), |
| instanceNum_(0), |
| numInstances_(0), |
| numOptionalDataBufs_(0), |
| optionalData_(NULL), |
| optionalDataIsShared_(TRUE), |
| udrSerInvocationInfoLen_(0), |
| udrSerInvocationInfo_(NULL), |
| udrSerPlanInfoLen_(0), |
| udrSerPlanInfo_(NULL), |
| udrJavaDebugPort_(-1), |
| udrJavaDebugTimeout_(0) |
| { |
| } |
| |
| UdrLoadMsg::UdrLoadMsg(NAMemory *heap, |
| const char *sqlName, |
| const char *routineName, |
| const char *routineSignature, |
| const char *containerName, |
| const char *externalPath, |
| const char *librarySqlName, |
| ComRoutineTransactionAttributes transactionAttrs, |
| ComRoutineSQLAccess sqlAccessMode, |
| ComRoutineLanguage language, |
| ComRoutineParamStyle paramStyle, |
| ComRoutineExternalSecurity externalSecurity, |
| ComUInt32 maxNumResultSets, |
| ComUInt32 numParameters, |
| ComUInt32 numInValues, |
| ComUInt32 numOutValues, |
| ComUInt32 inBufferSize, |
| ComUInt32 outBufferSize, |
| ComUInt32 inputRowSize, |
| ComUInt32 outputRowSize, |
| ComUInt32 udrFlags, |
| Int32 routineOwnerId, |
| const char *parentQid, |
| ComUInt32 udrSerInvocationInfoLen, |
| const char *udrSerInvocationInfo, |
| ComUInt32 udrSerPlanInfoLen, |
| const char *udrSerPlanInfo, |
| Int32 javaDebugPort, |
| Int32 javaDebugTimeout, |
| ComUInt32 instanceNum, |
| ComUInt32 numInstances |
| ) |
| : UdrControlMsg(UDR_MSG_LOAD, UdrLoadMsgVersionNumber, heap), |
| sqlName_(NULL), routineName_(NULL), routineSignature_(NULL), |
| containerName_(NULL), externalPath_(NULL), librarySqlName_(NULL),transactionAttrs_(transactionAttrs), |
| sqlAccessMode_(sqlAccessMode), language_(language), paramStyle_(paramStyle), |
| externalSecurity_(externalSecurity), |
| maxNumResultSets_(maxNumResultSets), |
| numParameters_(numParameters), numInValues_(numInValues), |
| numOutValues_(numOutValues), |
| inBufferSize_(inBufferSize), outBufferSize_(outBufferSize), |
| inputRowSize_(inputRowSize), outputRowSize_(outputRowSize), |
| udrFlags_(udrFlags), inParamInfo_(NULL), outParamInfo_(NULL), |
| numInputTables_(0), |
| inTables_(NULL), |
| routineOwnerId_(routineOwnerId), |
| parentQid_(NULL), |
| numOptionalDataBufs_(0), optionalData_(NULL), optionalDataIsShared_(TRUE), |
| udrSerInvocationInfoLen_(udrSerInvocationInfoLen), |
| udrSerInvocationInfo_(udrSerInvocationInfo), |
| udrSerPlanInfoLen_(udrSerPlanInfoLen), |
| udrSerPlanInfo_(udrSerPlanInfo), |
| instanceNum_(instanceNum), |
| numInstances_(numInstances), |
| udrJavaDebugPort_(javaDebugPort), |
| udrJavaDebugTimeout_(javaDebugTimeout) |
| { |
| sqlName_ = allocateString(sqlName); |
| routineName_ = allocateString(routineName); |
| routineSignature_ = allocateString(routineSignature); |
| containerName_ = allocateString(containerName); |
| externalPath_ = allocateString(externalPath); |
| librarySqlName_ = allocateString(librarySqlName); |
| parentQid_ = allocateString(parentQid); |
| allocateParamInfo(); |
| // allocateTableInputInfo(); |
| } |
| |
| // |
| // The following helper functions take care of memory management |
| // for parameter info arrays. They call NAMemory methods to allocate |
| // and deallocate memory. It is safe to call NAMemory::allocate(0), |
| // which returns NULL, and NAMemory::deallocate(NULL), which does |
| // nothing. |
| // |
| void UdrLoadMsg::allocateParamInfo() |
| { |
| deallocateParamInfo(); |
| const ComUInt32 n1 = numInValues_ * sizeof(UdrParameterInfo); |
| const ComUInt32 n2 = numOutValues_ * sizeof(UdrParameterInfo); |
| inParamInfo_ = (UdrParameterInfo *) (n1 ? allocateMemory(n1) : NULL); |
| outParamInfo_ = (UdrParameterInfo *) (n2 ? allocateMemory(n2) : NULL); |
| } |
| void UdrLoadMsg::deallocateParamInfo() |
| { |
| deallocateMemory((char *) inParamInfo_); |
| deallocateMemory((char *) outParamInfo_); |
| inParamInfo_ = NULL; |
| outParamInfo_ = NULL; |
| } |
| |
| void UdrLoadMsg::allocateTableInputInfo() |
| { |
| deallocateTableInputInfo(); |
| // First allocate the array of table descriptors |
| const ComUInt32 t1 = numInputTables_ * sizeof(UdrTableInputInfo); |
| inTables_ = (UdrTableInputInfo *) (t1 ? allocateMemory(t1) : NULL); |
| |
| |
| /* |
| // For each table descriptor allocate memory for the column descriptors |
| short j= 0; |
| for (j = 0; j < numInputTables_; j++) |
| { |
| const ComUInt32 colsize=inTables_[j].getNumColumns() *sizeof(UdrParameterInfo); |
| inTables_[j].inTableColumnDescs_ = (UdrParameterInfo *)(colsize ? |
| allocateMemory(colsize) : NULL); |
| |
| } */ |
| |
| } |
| |
| void UdrLoadMsg::deallocateTableInputInfo() |
| { |
| short j = 0; |
| if (inTables_) |
| { |
| for (j=0; j < numInputTables_;j++) |
| { |
| deallocateMemory((char *)inTables_[j].inTableColumnDescs_); |
| inTables_[j].inTableColumnDescs_ = NULL; |
| } |
| deallocateMemory((char *)inTables_); |
| |
| inTables_ = NULL; |
| } |
| } |
| |
| void UdrLoadMsg::allocateInvocationInfo() |
| { |
| if (udrSerInvocationInfoLen_) |
| udrSerInvocationInfo_ = allocateMemory(udrSerInvocationInfoLen_); |
| if (udrSerPlanInfoLen_) |
| udrSerPlanInfo_ = allocateMemory(udrSerPlanInfoLen_); |
| } |
| |
| void UdrLoadMsg::deallocateInvocationInfo() |
| { |
| if (udrSerInvocationInfoLen_) |
| deallocateMemory((char *) udrSerInvocationInfo_); |
| if (udrSerPlanInfoLen_) |
| deallocateMemory((char *) udrSerPlanInfo_); |
| udrSerInvocationInfoLen_ = 0; |
| udrSerInvocationInfo_ = NULL; |
| udrSerPlanInfoLen_ = 0; |
| udrSerPlanInfo_ = NULL; |
| } |
| |
| UdrParameterInfo *UdrLoadMsg::setInParam(ComUInt32 i, |
| const UdrParameterInfo &info) |
| { |
| UdrExeAssert(inParamInfo_ && numInValues_ > i, |
| "An invalid index was passed to UdrLoadMsg::setInParam()"); |
| UdrParameterInfo *result = NULL; |
| if (inParamInfo_ && numInValues_ > i) |
| { |
| inParamInfo_[i] = info; |
| result = &(inParamInfo_[i]); |
| } |
| return result; |
| } |
| |
| UdrParameterInfo *UdrLoadMsg::setOutParam(ComUInt32 i, |
| const UdrParameterInfo &info) |
| { |
| UdrExeAssert(outParamInfo_ && numOutValues_ > i, |
| "An invalid index was passed to UdrLoadMsg::setOutParam()"); |
| UdrParameterInfo *result = NULL; |
| if (outParamInfo_ && numOutValues_ > i) |
| { |
| outParamInfo_[i] = info; |
| result = &(outParamInfo_[i]); |
| } |
| return result; |
| } |
| |
| const UdrParameterInfo &UdrLoadMsg::getInParam(ComUInt32 i) const |
| { |
| UdrExeAssert(inParamInfo_ && numInValues_ > i, |
| "An invalid index was passed to UdrLoadMsg::getInParam()"); |
| return inParamInfo_[i]; |
| } |
| |
| const UdrParameterInfo &UdrLoadMsg::getOutParam(ComUInt32 i) const |
| { |
| UdrExeAssert(outParamInfo_ && numOutValues_ > i, |
| "An invalid index was passed to UdrLoadMsg::getOutParam()"); |
| return outParamInfo_[i]; |
| } |
| void UdrLoadMsg::setChildTableInput(ComUInt32 i, |
| const UdrTableInputInfo &info) |
| { |
| UdrExeAssert(inTables_ && numInputTables_ > i, |
| "An invalid index was passed to UdrLoadMsg::setInParam()"); |
| UdrTableInputInfo *result = NULL; |
| if (inTables_ && numInputTables_ > i) |
| { |
| inTables_[i] = info; |
| } |
| |
| } |
| void UdrLoadMsg::deallocateOptionalDataBufs() |
| { |
| if (optionalData_) |
| { |
| if (!optionalDataIsShared_) |
| { |
| for (ComUInt32 i = 0; i < numOptionalDataBufs_; i++) |
| deallocateMemory(optionalData_[i]); |
| } |
| deallocateMemory((char *) optionalData_); |
| } |
| |
| numOptionalDataBufs_ = 0; |
| optionalDataIsShared_ = TRUE; |
| optionalData_ = NULL; |
| } |
| |
| void UdrLoadMsg::initOptionalDataBufs(ComUInt32 numBufs, NABoolean isShared) |
| { |
| deallocateOptionalDataBufs(); |
| numOptionalDataBufs_ = numBufs; |
| optionalDataIsShared_ = isShared; |
| optionalData_ = NULL; |
| if (numBufs > 0) |
| optionalData_ = (char **) allocateMemory(numBufs * sizeof(char *)); |
| } |
| |
| ComUInt32 UdrLoadMsg::getNumOptionalDataBufs() |
| { |
| return numOptionalDataBufs_; |
| } |
| |
| void UdrLoadMsg::setOptionalDataBuf(ComUInt32 i, |
| const char *buf, |
| ComUInt32 bufLen) |
| { |
| UdrExeAssert(i < numOptionalDataBufs_, "Index out of range"); |
| const char *buf2 = buf; |
| if (!optionalDataIsShared_) |
| { |
| buf2 = allocateMemory(bufLen); |
| str_cpy_all((char *) buf2, buf, (Lng32) bufLen); |
| } |
| optionalData_[i] = (char *) buf2; |
| } |
| |
| char *UdrLoadMsg::getOptionalDataBuf(ComUInt32 i) |
| { |
| UdrExeAssert(i < numOptionalDataBufs_, "Index out of range"); |
| return optionalData_[i]; |
| } |
| |
| |
| |
| UdrLoadMsg::~UdrLoadMsg() |
| { |
| deallocateString(sqlName_); |
| deallocateString(routineName_); |
| deallocateString(routineSignature_); |
| deallocateString(containerName_); |
| deallocateString(externalPath_); |
| deallocateString(librarySqlName_); |
| deallocateString(parentQid_); |
| deallocateParamInfo(); |
| deallocateOptionalDataBufs(); |
| deallocateTableInputInfo(); |
| } |
| |
| IpcMessageObjSize UdrLoadMsg::packedLength() |
| { |
| IpcMessageObjSize result; |
| result = udrBaseClassPackedLength(); |
| result += packedStringLength(sqlName_); |
| result += packedStringLength(routineName_); |
| result += packedStringLength(routineSignature_); |
| result += packedStringLength(containerName_); |
| result += packedStringLength(externalPath_); |
| result += packedStringLength(librarySqlName_); |
| result += sizeof(transactionAttrs_); |
| result += sizeof(sqlAccessMode_); |
| result += sizeof(language_); |
| result += sizeof(paramStyle_); |
| result += sizeof(externalSecurity_); |
| result += sizeof(maxNumResultSets_); |
| result += sizeof(numParameters_); |
| result += sizeof(numInValues_); |
| result += sizeof(numOutValues_); |
| result += sizeof(inBufferSize_); |
| result += sizeof(outBufferSize_); |
| result += sizeof(inputRowSize_); |
| result += sizeof(outputRowSize_); |
| result += sizeof(udrFlags_); |
| result += sizeof(routineOwnerId_); |
| result += packedStringLength(parentQid_); |
| result += sizeof(udrJavaDebugPort_); |
| result += sizeof(udrJavaDebugTimeout_); |
| result += sizeof(numInputTables_); |
| result += sizeof(numInstances_); |
| result += sizeof(instanceNum_); |
| |
| ComUInt32 i = 0; |
| for (i = 0; i < numInValues_; i++) |
| { |
| const UdrParameterInfo &info = inParamInfo_[i]; |
| const IpcMessageObjSize infoSize = info.packedLength(); |
| result += infoSize; |
| } |
| for (i = 0; i < numOutValues_; i++) |
| { |
| const UdrParameterInfo &info = outParamInfo_[i]; |
| const IpcMessageObjSize infoSize = info.packedLength(); |
| result += infoSize; |
| } |
| |
| for (i=0; i <numInputTables_;i++) |
| { |
| const UdrTableInputInfo &tinfo = inTables_[i]; |
| const IpcMessageObjSize tinfosize = tinfo.packedLength(); |
| result += tinfosize; |
| } |
| |
| result += sizeof(numOptionalDataBufs_); |
| for (i = 0; i < numOptionalDataBufs_; i++) |
| { |
| const char *buf = optionalData_[i]; |
| ComUInt32 dataLen = 0; |
| str_cpy_all((char *) &dataLen, buf, 4); |
| result += (dataLen + 4); |
| } |
| |
| result += sizeof(udrSerInvocationInfoLen_); |
| result += sizeof(udrSerPlanInfoLen_); |
| result += udrSerInvocationInfoLen_; |
| result += udrSerPlanInfoLen_; |
| |
| return result; |
| } |
| |
| IpcMessageObjSize UdrLoadMsg::packObjIntoMessage(IpcMessageBufferPtr buffer) |
| { |
| IpcMessageObjSize result; |
| result = packUdrBaseClass(buffer); |
| result += packCharStarIntoBuffer(buffer, sqlName_); |
| result += packCharStarIntoBuffer(buffer, routineName_); |
| result += packCharStarIntoBuffer(buffer, routineSignature_); |
| result += packCharStarIntoBuffer(buffer, containerName_); |
| result += packCharStarIntoBuffer(buffer, externalPath_); |
| result += packCharStarIntoBuffer(buffer, librarySqlName_); |
| result += packIntoBuffer(buffer, transactionAttrs_); |
| result += packIntoBuffer(buffer, sqlAccessMode_); |
| result += packIntoBuffer(buffer, language_); |
| result += packIntoBuffer(buffer, paramStyle_); |
| result += packIntoBuffer(buffer, externalSecurity_); |
| result += packIntoBuffer(buffer, maxNumResultSets_); |
| result += packIntoBuffer(buffer, numParameters_); |
| result += packIntoBuffer(buffer, numInValues_); |
| result += packIntoBuffer(buffer, numOutValues_); |
| result += packIntoBuffer(buffer, inBufferSize_); |
| result += packIntoBuffer(buffer, outBufferSize_); |
| result += packIntoBuffer(buffer, inputRowSize_); |
| result += packIntoBuffer(buffer, outputRowSize_); |
| result += packIntoBuffer(buffer, udrFlags_); |
| result += packIntoBuffer(buffer, routineOwnerId_); |
| result += packCharStarIntoBuffer(buffer, parentQid_); |
| result += packIntoBuffer(buffer, udrJavaDebugPort_); |
| result += packIntoBuffer(buffer, udrJavaDebugTimeout_); |
| result += packIntoBuffer(buffer, numInstances_); |
| result += packIntoBuffer(buffer, instanceNum_); |
| |
| ComUInt32 i; |
| for (i = 0; i < numInValues_; i++) |
| { |
| const UdrParameterInfo &info = inParamInfo_[i]; |
| result += info.pack(buffer); |
| } |
| for (i = 0; i < numOutValues_; i++) |
| { |
| const UdrParameterInfo &info = outParamInfo_[i]; |
| result += info.pack(buffer); |
| } |
| |
| result +=packIntoBuffer(buffer,numInputTables_); |
| for (i = 0; i < numInputTables_; i++) |
| { |
| const UdrTableInputInfo &tinfo = inTables_[i]; |
| result += tinfo.pack(buffer); |
| } |
| result += packIntoBuffer(buffer, numOptionalDataBufs_); |
| for (i = 0; i < numOptionalDataBufs_; i++) |
| { |
| char *buf = optionalData_[i]; |
| ComUInt32 dataLen = 0; |
| str_cpy_all((char *) &dataLen, buf, 4); |
| result += packStrIntoBuffer(buffer, buf, (dataLen + 4)); |
| } |
| |
| result += packIntoBuffer(buffer, udrSerInvocationInfoLen_); |
| result += packIntoBuffer(buffer, udrSerPlanInfoLen_); |
| if (udrSerInvocationInfoLen_) |
| result += packStrIntoBuffer(buffer, |
| (char *) udrSerInvocationInfo_, |
| udrSerInvocationInfoLen_); |
| if (udrSerPlanInfoLen_) |
| result += packStrIntoBuffer(buffer, |
| (char *) udrSerPlanInfo_, |
| udrSerPlanInfoLen_); |
| |
| return result; |
| } |
| |
| void UdrLoadMsg::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| unpackUdrBaseClass(buffer); |
| unpackBuffer(buffer, sqlName_, getHeap()); |
| unpackBuffer(buffer, routineName_, getHeap()); |
| unpackBuffer(buffer, routineSignature_, getHeap()); |
| unpackBuffer(buffer, containerName_, getHeap()); |
| unpackBuffer(buffer, externalPath_, getHeap()); |
| unpackBuffer(buffer, librarySqlName_, getHeap()); |
| unpackBuffer(buffer, transactionAttrs_); |
| unpackBuffer(buffer, sqlAccessMode_); |
| unpackBuffer(buffer, language_); |
| unpackBuffer(buffer, paramStyle_); |
| unpackBuffer(buffer, externalSecurity_); |
| unpackBuffer(buffer, maxNumResultSets_); |
| unpackBuffer(buffer, numParameters_); |
| unpackBuffer(buffer, numInValues_); |
| unpackBuffer(buffer, numOutValues_); |
| unpackBuffer(buffer, inBufferSize_); |
| unpackBuffer(buffer, outBufferSize_); |
| unpackBuffer(buffer, inputRowSize_); |
| unpackBuffer(buffer, outputRowSize_); |
| unpackBuffer(buffer, udrFlags_); |
| unpackBuffer(buffer, routineOwnerId_); |
| unpackBuffer(buffer, parentQid_, getHeap()); |
| unpackBuffer(buffer, udrJavaDebugPort_); |
| unpackBuffer(buffer, udrJavaDebugTimeout_); |
| unpackBuffer(buffer, numInstances_); |
| unpackBuffer(buffer, instanceNum_); |
| allocateParamInfo(); |
| |
| ComUInt32 i; |
| for (i = 0; i < numInValues_; i++) |
| { |
| UdrParameterInfo &info = inParamInfo_[i]; |
| info.unpack(buffer); |
| } |
| for (i = 0; i < numOutValues_; i++) |
| { |
| UdrParameterInfo &info = outParamInfo_[i]; |
| info.unpack(buffer); |
| } |
| unpackBuffer(buffer, numInputTables_); |
| allocateTableInputInfo(); |
| for (i =0; i < numInputTables_; i++) |
| { |
| UdrTableInputInfo &tinfo = inTables_[i]; |
| tinfo.unpack(buffer, getHeap()); |
| } |
| ComUInt32 numBufs = 0; |
| unpackBuffer(buffer, numBufs); |
| initOptionalDataBufs(numBufs, FALSE); |
| for (i = 0; i < numOptionalDataBufs_; i++) |
| { |
| ComUInt32 dataLen = 0; |
| str_cpy_all((char *) &dataLen, buffer, 4); |
| ComUInt32 totalLen = dataLen + 4; |
| setOptionalDataBuf(i, buffer, totalLen); |
| buffer += totalLen; |
| } |
| |
| deallocateInvocationInfo(); |
| unpackBuffer(buffer, udrSerInvocationInfoLen_); |
| unpackBuffer(buffer, udrSerPlanInfoLen_); |
| allocateInvocationInfo(); |
| if (udrSerInvocationInfoLen_) |
| unpackStrFromBuffer(buffer, |
| (char *) udrSerInvocationInfo_, |
| udrSerInvocationInfoLen_); |
| if (udrSerPlanInfoLen_) |
| unpackStrFromBuffer(buffer, |
| (char *) udrSerPlanInfo_, |
| udrSerPlanInfoLen_); |
| } |
| |
| //---------------------------------------------------------------------- |
| // UdrSessionMsg |
| //---------------------------------------------------------------------- |
| UdrSessionMsg::UdrSessionMsg(NAMemory *heap) |
| : UdrControlMsg(UDR_MSG_SESSION, UdrSessionMsgVersionNumber, heap), |
| attrType_(UDR_SESSION_TYPE_UNKNOWN), |
| flags_(0), |
| strings_(heap) |
| { |
| } |
| |
| UdrSessionMsg::UdrSessionMsg(UdrSessionAttrType attrType, |
| ComUInt32 flags, |
| NAMemory *heap) |
| : UdrControlMsg(UDR_MSG_SESSION, UdrSessionMsgVersionNumber, heap), |
| attrType_(attrType), |
| flags_(flags), |
| strings_(heap) |
| { |
| } |
| |
| UdrSessionMsg::~UdrSessionMsg() |
| { |
| ComUInt32 e = strings_.entries(); |
| for (ULng32 i = 0; i < e; i++) |
| { |
| NADELETEBASIC(strings_[i], getHeap()); |
| } |
| } |
| |
| void UdrSessionMsg::addString(const char *option) |
| { |
| if (option == NULL || option[0] == '\0') |
| { |
| return; |
| } |
| Int32 len = str_len(option); |
| char *copy = new (getHeap()) char[len + 1]; |
| str_cpy_all(copy, option, len + 1); |
| strings_.insert(copy); |
| } |
| |
| IpcMessageObjSize UdrSessionMsg::packedLength() |
| { |
| IpcMessageObjSize result; |
| result = udrBaseClassPackedLength(); |
| |
| result += sizeof(attrType_); |
| result += sizeof(flags_); |
| |
| ComUInt32 e = strings_.entries(); |
| result += sizeof(e); |
| |
| for (ULng32 i = 0; i < e; i++) |
| { |
| result += packedStringLength(strings_[i]); |
| } |
| |
| return result; |
| } |
| |
| IpcMessageObjSize UdrSessionMsg::packObjIntoMessage(IpcMessageBufferPtr buffer) |
| { |
| IpcMessageObjSize result; |
| result = packUdrBaseClass(buffer); |
| result += packIntoBuffer(buffer, attrType_); |
| result += packIntoBuffer(buffer, flags_); |
| |
| ComUInt32 e = strings_.entries(); |
| result += packIntoBuffer(buffer, e); |
| |
| for (ULng32 i = 0; i < e; i++) |
| { |
| result += packCharStarIntoBuffer(buffer, strings_[i]); |
| } |
| |
| return result; |
| } |
| |
| void UdrSessionMsg::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| unpackUdrBaseClass(buffer); |
| |
| unpackBuffer(buffer, attrType_); |
| unpackBuffer(buffer, flags_); |
| |
| ComUInt32 e; |
| unpackBuffer(buffer, e); |
| |
| char *copy; |
| for (ULng32 i = 0; i < e; i++) |
| { |
| // The unpackBuffer() call will deallocate copy from the heap if |
| // copy is non-NULL which is not what we want. So we make sure |
| // copy is set to NULL before calling unpackBuffer(). |
| copy = NULL; |
| unpackBuffer(buffer, copy, getHeap()); |
| strings_.insert(copy); |
| } |
| } |
| |
| #ifdef UDR_DEBUG |
| void UdrSessionMsg::display(FILE *f, const char *prefix) const |
| { |
| fprintf(f, "%s[UdrSessionMsg] type %d, flags 0x%08x\n", |
| prefix, (Lng32) attrType_, (Lng32) flags_); |
| |
| ComUInt32 e = strings_.entries(); |
| for (ULng32 i = 0; i < e; i++) |
| { |
| fprintf(f, "%s '%s'\n", prefix, strings_[i]); |
| } |
| |
| fflush(f); |
| } |
| #endif // UDR_DEBUG |
| |
| //---------------------------------------------------------------------- |
| // UdrDataBuffer |
| //---------------------------------------------------------------------- |
| |
| // |
| // Constructor for either copyless send or allocation on an NAMemory heap. |
| // For copyless send the NAMemory pointer should be NULL. |
| // |
| UdrDataBuffer::UdrDataBuffer(ULng32 sqlBufferLength, |
| InOut mode, NAMemory *heap) |
| : UdrMessageObj(mode == UDR_DATA_IN ? |
| UDR_MSG_DATA_REQUEST : UDR_MSG_DATA_REPLY, |
| UdrDataBufferVersionNumber, |
| heap), |
| sqlBufferLength_(sqlBufferLength), |
| flags_(0) |
| { |
| if (getHeap()) |
| { |
| // |
| // Allocate SqlBuffer on a heap |
| // |
| theBuffer_ = (SqlBuffer *) new (getHeap()) char[sqlBufferLength]; |
| } |
| else |
| { |
| // |
| // The SqlBuffer starts at the next address that is aligned on an |
| // 8-byte boundary |
| // |
| IpcMessageBufferPtr bufferStart = (IpcMessageBufferPtr) this; |
| bufferStart += sizeof(*this); |
| alignBufferForNextObj(bufferStart); |
| theBuffer_ = (SqlBuffer *) (bufferStart); |
| } |
| |
| theBuffer_->driveInit(sqlBufferLength_, FALSE, SqlBuffer::NORMAL_); |
| theBuffer_->bufferInUse(); |
| tableIndex_ = -1; |
| } |
| |
| // |
| // Constructors for copyless receive |
| // |
| UdrDataBuffer::UdrDataBuffer(IpcBufferedMsgStream *msgStream, |
| NABoolean driveUnPack) |
| : UdrMessageObj(msgStream) |
| { |
| copylessUnpack(FALSE, 0, driveUnPack); |
| } |
| |
| |
| UdrDataBuffer::UdrDataBuffer(/* IN */ IpcBufferedMsgStream *msgStream, |
| /* IN */ IpcMessageObjSize objSize, |
| /* OUT */ NABoolean &integrityCheckResult ) |
| : UdrMessageObj(msgStream) |
| { |
| integrityCheckResult = copylessUnpack(TRUE, objSize); |
| } |
| |
| NABoolean UdrDataBuffer::copylessUnpack(NABoolean doChecks, |
| IpcMessageObjSize objSize, |
| NABoolean driveUnPack) |
| { |
| // |
| // Notes about this method |
| // |
| // When doChecks is TRUE we verify that the in-place unpacking of |
| // this object does not cause us to create pointers that reference |
| // memory outside the bounds of this object. |
| // |
| // The SqlBuffer starts at the next address beyond "this" that is |
| // aligned on an 8-byte boundary. |
| // |
| theBuffer_ = NULL; |
| NABoolean result = TRUE; |
| IpcConstMessageBufferPtr buffer = (IpcMessageBufferPtr) this; |
| IpcConstMessageBufferPtr lastByte = (doChecks ? buffer + objSize - 1 : 0); |
| |
| IpcMessageObjSize bytesForThis = sizeof(*this); |
| alignSizeForNextObj(bytesForThis); |
| |
| // The buffer must be large enough to hold an instance of this class |
| if (doChecks) |
| { |
| if (!checkBuffer(buffer, bytesForThis, lastByte)) |
| { |
| result = FALSE; |
| } |
| } |
| else |
| { |
| buffer += bytesForThis; |
| } |
| |
| if (result) |
| { |
| if (doChecks) |
| { |
| // The buffer must be large enough to hold a SqlBufferNormal instance |
| IpcConstMessageBufferPtr startOfSqlBuffer = buffer; |
| if (!checkBuffer(startOfSqlBuffer, sizeof(SqlBufferNormal), lastByte)) |
| { |
| result = FALSE; |
| } |
| else |
| { |
| // Now we verify the contents of the SqlBuffer instance. We must |
| // not call virtual methods on the SqlBuffer at this point. That |
| // can only be done reliably after the SqlBuffer has been |
| // unpacked. |
| theBuffer_ = (SqlBuffer *) buffer; |
| if (theBuffer_->bufType() != SqlBufferBase::NORMAL_ || |
| theBuffer_->get_buffer_size() != sqlBufferLength_ || |
| !theBuffer_->packed() || |
| !theBuffer_->driveVerify(lastByte - buffer + 1)) |
| { |
| theBuffer_ = NULL; |
| result = FALSE; |
| } |
| } |
| } // if (doChecks) |
| |
| else |
| { |
| theBuffer_ = (SqlBuffer *) buffer; |
| } |
| |
| } // if (result) |
| |
| if (result && driveUnPack) |
| { |
| theBuffer_->driveUnpack(); |
| |
| // |
| // The sql_buffer state was set to IN_USE by the sender. This |
| // prevents the buffer from being deallocated during I/O. Once all |
| // rows have been consumed from this sql_buffer then isFree() will |
| // return TRUE and the buffer will eventually be deallocated by the |
| // stream. Here we assert that the buffer is not yet free, a way of |
| // showing that the sender set its state to IN_USE. |
| // |
| // This test was not done earlier with the other SqlBuffer tests |
| // because it requires a virtual method and we have to unpack the |
| // object before we can reliably invoke virtual methods. |
| // |
| if (doChecks) |
| { |
| if (theBuffer_->isFree()) |
| { |
| theBuffer_ = NULL; |
| result = FALSE; |
| } |
| } |
| else |
| { |
| UdrExeAssert(!(theBuffer_->isFree()), |
| "An empty UdrDataBuffer arrived on a UDR data stream"); |
| } |
| } // if (result) |
| |
| if (!result) |
| { |
| UdrExeAssert(theBuffer_ == NULL, |
| "SqlBuffer should be NULL following integrity check failure"); |
| } |
| |
| return result; |
| } |
| |
| UdrDataBuffer::~UdrDataBuffer() |
| { |
| if (getHeap()) |
| { |
| getHeap()->deallocateMemory(theBuffer_); |
| } |
| } |
| |
| // |
| // Determine if UdrDataBuffer in IpcMessageBuffer is available for recycle |
| // |
| NABoolean UdrDataBuffer::msgObjIsFree() |
| { |
| NABoolean result = (theBuffer_ && (!theBuffer_->packed()) ? theBuffer_->isFree() : TRUE); |
| return result; |
| } |
| |
| // |
| // Deal with transport issues, change pointers to offsets, etc. |
| // |
| void UdrDataBuffer::prepMsgObjForSend() |
| { |
| theBuffer_->drivePack(); |
| #ifdef UDR_DEBUG |
| // We allow the debug-build UDR server to corrupt an INVOKE |
| // reply. Note that the getenv() test must also check for an empty |
| // string value because in OSS calling putenv("X=") apparently does |
| // not remove the environment setting. |
| { |
| char *val = getenv("MXUDR_CORRUPT_DATA_REPLY"); |
| if (val && val[0]) |
| { |
| sqlBufferLength_ -= 1; |
| } |
| } |
| #endif |
| } |
| |
| NABoolean UdrDataBuffer::moreRows() const |
| { |
| NABoolean result = FALSE; |
| if (theBuffer_ && !theBuffer_->atEOTD()) |
| { |
| result = TRUE; |
| } |
| return result; |
| } |
| |
| IpcMessageObjSize UdrDataBuffer::packedLength() |
| { |
| // |
| // Note: The number returned by this function is valid only for use |
| // with "regular" message streams, not with buffered message streams |
| // using copyless IPC |
| // |
| IpcMessageObjSize result = 0; |
| result = udrBaseClassPackedLength(); |
| result += sizeof(flags_); |
| result += sizeof(sqlBufferLength_); |
| result +=sizeof(tableIndex_); |
| result += sqlBufferLength_; |
| return result; |
| } |
| |
| IpcMessageObjSize UdrDataBuffer::packObjIntoMessage(IpcMessageBufferPtr buffer) |
| { |
| IpcMessageObjSize result = 0; |
| result += packUdrBaseClass(buffer); |
| result += packIntoBuffer(buffer, flags_); |
| result += packIntoBuffer(buffer, sqlBufferLength_); |
| |
| // |
| // Convert pointers in the SqlBuffer to offsets and copy the SqlBuffer |
| // |
| theBuffer_->drivePack(); |
| str_cpy_all(buffer, (char *) theBuffer_, (Lng32)sqlBufferLength_); |
| result += sqlBufferLength_; |
| result += packIntoBuffer(buffer,tableIndex_); |
| return result; |
| } |
| |
| void UdrDataBuffer::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| UdrExeAssert((objType == UDR_MSG_DATA_REQUEST |
| || objType == UDR_MSG_DATA_REPLY) |
| && objVersion == UdrDataBufferVersionNumber |
| && sameEndianness |
| && objSize > sizeof(IpcMessageObj), |
| "Invalid type or version seen by UdrDataBuffer::unpackObj()"); |
| |
| unpackUdrBaseClass(buffer); |
| unpackBuffer(buffer, flags_); |
| unpackBuffer(buffer, sqlBufferLength_); |
| |
| // |
| // Unpack the SqlBuffer |
| // |
| str_cpy_all((char *) theBuffer_, buffer, (Lng32)sqlBufferLength_); |
| theBuffer_->driveUnpack(); |
| unpackBuffer(buffer,tableIndex_); |
| |
| } |
| |
| NABoolean UdrDataBuffer::checkObj(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr buffer) const |
| { |
| // |
| // This method is not implemented for now. All UDR data replies |
| // travel on buffered streams via copyless IPC and should be |
| // verified by calling the appropriate copyless receive constructor. |
| // |
| UdrExeAssert(FALSE, "UdrDataBuffer::checkObj() should not be called"); |
| return FALSE; |
| } |
| |
| //---------------------------------------------------------------------- |
| // class UdrRSMessageObj |
| //---------------------------------------------------------------------- |
| IpcMessageObjSize UdrRSMessageObj::packedLength() |
| { |
| return udrBaseClassPackedLength(); |
| } |
| |
| IpcMessageObjSize UdrRSMessageObj::packObjIntoMessage(IpcMessageBufferPtr buf) |
| { |
| return packUdrBaseClass(buf); |
| } |
| |
| void UdrRSMessageObj::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| unpackUdrBaseClass(buffer); |
| } |
| |
| IpcMessageObjSize UdrRSMessageObj::udrBaseClassPackedLength() |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| IpcMessageObjSize result; |
| result = super::udrBaseClassPackedLength(); |
| result += sizeof(rshandle_); |
| return result; |
| } |
| |
| IpcMessageObjSize UdrRSMessageObj::packUdrBaseClass(IpcMessageBufferPtr &buf) |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| IpcMessageObjSize result; |
| result = super::packUdrBaseClass(buf); |
| result += packIntoBuffer(buf, rshandle_); |
| return result; |
| } |
| |
| void UdrRSMessageObj::unpackUdrBaseClass(IpcConstMessageBufferPtr &buffer) |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| super::unpackUdrBaseClass(buffer); |
| unpackBuffer(buffer, rshandle_); |
| } |
| |
| NABoolean UdrRSMessageObj::checkObj(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr buffer) const |
| { |
| return checkUdrBaseClass(t, v, sameEndianness, size, buffer); |
| } |
| |
| NABoolean |
| UdrRSMessageObj::checkUdrBaseClass(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr &buf) const |
| { |
| // NOTE: changes to any of the following methods also require |
| // corresponding changes in the others: |
| // - udrBaseClassPackedLength() |
| // - packUdrBaseClass() |
| // - unpackUdrBaseClass() |
| // - checkUdrBaseClass() |
| |
| const IpcConstMessageBufferPtr lastByte = buf + size - 1; |
| if (!super::checkUdrBaseClass(t, v, sameEndianness, size, buf)) |
| return FALSE; |
| if (!checkBuffer(buf, sizeof(rshandle_), lastByte)) |
| return FALSE; |
| return TRUE; |
| } |
| |
| //---------------------------------------------------------------------- |
| // class UdrRSLoadMsg |
| //---------------------------------------------------------------------- |
| UdrRSLoadMsg::UdrRSLoadMsg(ComUInt32 rsIndex, |
| ComUInt32 numRSCols, |
| ComUInt32 rowSize, |
| ComUInt32 bufferSize, |
| ComUInt32 flags, |
| NAMemory *heap) |
| : UdrRSControlMsg(UDR_MSG_RS_LOAD, UdrRSLoadMsgVersionNumber, heap), |
| rsIndex_(rsIndex), numRSCols_(numRSCols), rsColumnDesc_(NULL), |
| outputRowSize_(rowSize), outBufferSize_(bufferSize), rsLoadFlags_(flags) |
| { |
| allocateColumnDescs(); |
| } |
| |
| UdrRSLoadMsg::UdrRSLoadMsg(NAMemory *heap) |
| : UdrRSControlMsg(UDR_MSG_RS_LOAD, UdrRSLoadMsgVersionNumber, heap), |
| rsIndex_(0), numRSCols_(0), rsColumnDesc_(NULL), |
| outputRowSize_(0), outBufferSize_(0), rsLoadFlags_(0) |
| { |
| } |
| |
| UdrRSLoadMsg::~UdrRSLoadMsg() |
| { |
| deallocateColumnDescs(); |
| } |
| |
| void UdrRSLoadMsg::allocateColumnDescs() |
| { |
| deallocateColumnDescs(); |
| const ComUInt32 n = numRSCols_ * sizeof(UdrParameterInfo); |
| rsColumnDesc_ = (UdrParameterInfo *) (n ? allocateMemory(n) : NULL); |
| } |
| |
| void UdrRSLoadMsg::deallocateColumnDescs() |
| { |
| deallocateMemory((char *) rsColumnDesc_); |
| rsColumnDesc_ = NULL; |
| } |
| |
| UdrParameterInfo& UdrRSLoadMsg::getColumnDesc(ComUInt32 i) const |
| { |
| UdrExeAssert(rsColumnDesc_ && numRSCols_ > i, |
| "An invalid index was passed to UdrRSLoadMsg::getColumnDesc()"); |
| return rsColumnDesc_[i]; |
| } |
| |
| UdrParameterInfo * UdrRSLoadMsg::setColumnDesc(ComUInt32 i, |
| const UdrParameterInfo &info) |
| { |
| UdrExeAssert(rsColumnDesc_ && numRSCols_ > i, |
| "An invalid index was passed to UdrRSLoadMsg::setColumnDesc()"); |
| rsColumnDesc_[i] = info; |
| return &rsColumnDesc_[i]; |
| } |
| |
| IpcMessageObjSize UdrRSLoadMsg::packedLength() |
| { |
| IpcMessageObjSize result; |
| result = udrBaseClassPackedLength(); |
| result += sizeof(rsIndex_); |
| result += sizeof(numRSCols_); |
| result += sizeof(outputRowSize_); |
| result += sizeof(outBufferSize_); |
| result += sizeof(rsLoadFlags_); |
| |
| ComUInt32 i = 0; |
| for (i = 0; i < numRSCols_; i++) |
| { |
| result += getColumnDesc(i).packedLength(); |
| } |
| |
| return result; |
| } |
| |
| IpcMessageObjSize UdrRSLoadMsg::packObjIntoMessage(IpcMessageBufferPtr buffer) |
| { |
| IpcMessageObjSize result; |
| result = packUdrBaseClass(buffer); |
| result += packIntoBuffer(buffer, rsIndex_); |
| result += packIntoBuffer(buffer, numRSCols_); |
| result += packIntoBuffer(buffer, outputRowSize_); |
| result += packIntoBuffer(buffer, outBufferSize_); |
| result += packIntoBuffer(buffer, rsLoadFlags_); |
| |
| for (ComUInt32 i=0; i<numRSCols_; i++) |
| { |
| result += getColumnDesc(i).pack(buffer); |
| } |
| |
| return result; |
| } |
| |
| void UdrRSLoadMsg::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| unpackUdrBaseClass(buffer); |
| unpackBuffer(buffer, rsIndex_); |
| unpackBuffer(buffer, numRSCols_); |
| unpackBuffer(buffer, outputRowSize_); |
| unpackBuffer(buffer, outBufferSize_); |
| unpackBuffer(buffer, rsLoadFlags_); |
| |
| allocateColumnDescs(); |
| |
| for (ComUInt32 i=0; i<numRSCols_; i++) |
| { |
| getColumnDesc(i).unpack(buffer); |
| } |
| } |
| |
| //---------------------------------------------------------------------- |
| // struct ResultSetInfo |
| //---------------------------------------------------------------------- |
| ResultSetInfo::ResultSetInfo(const char *proxy, |
| SQLSTMT_ID *stmtID, |
| ComUInt32 cntxID, |
| NAMemory *heap) |
| : stmtID_(stmtID), cntxID_(cntxID), proxySyntax_(NULL), heap_(heap) |
| { |
| proxySyntax_ = allocateString(proxy); |
| } |
| |
| ResultSetInfo::~ResultSetInfo() |
| { |
| deallocateString(proxySyntax_); |
| } |
| |
| void ResultSetInfo::deallocateString(char *&s) |
| { |
| if (s) |
| { |
| if (heap_) |
| heap_->deallocateMemory(s); |
| else |
| delete [] s; |
| s = NULL; |
| } |
| } |
| |
| char *ResultSetInfo::allocateString(const char *s) |
| { |
| char *result = NULL; |
| if (s) |
| { |
| ComUInt32 n = str_len(s) + 1; |
| |
| if (heap_) |
| result = (char *) heap_->allocateMemory(n); |
| else |
| result = new char[n]; |
| |
| str_cpy_all(result, s, (Lng32) n); |
| } |
| |
| return result; |
| } |
| |
| IpcMessageObjSize ResultSetInfo::packedLength() |
| { |
| IpcMessageObjSize result = 0; |
| result += sizeof(stmtID_); |
| result += sizeof(cntxID_); |
| result += packedStringLength(proxySyntax_); |
| |
| return result; |
| } |
| |
| IpcMessageObjSize ResultSetInfo::pack(IpcMessageBufferPtr &buffer) const |
| { |
| IpcMessageObjSize result = 0; |
| result += packIntoBuffer(buffer, stmtID_); |
| result += packIntoBuffer(buffer, cntxID_); |
| result += packCharStarIntoBuffer(buffer, proxySyntax_); |
| |
| return result; |
| } |
| |
| void ResultSetInfo::unpack(IpcConstMessageBufferPtr &buffer) |
| { |
| |
| unpackBuffer(buffer, stmtID_); |
| unpackBuffer(buffer, cntxID_); |
| unpackBuffer(buffer, proxySyntax_, heap_); |
| } |
| |
| NABoolean ResultSetInfo::checkResultSetInfoClass(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr &buf) |
| { |
| IpcConstMessageBufferPtr lastByte = buf + size - 1; |
| |
| // check the buffer for stmtID_ |
| if (!checkBuffer(buf, sizeof(void *), lastByte)) |
| { |
| ipcIntegrityCheckEpilogue(FALSE); |
| return FALSE; |
| } |
| |
| // check the buffer after cntxID_ |
| if (!checkBuffer(buf, sizeof(ComUInt32), lastByte)) |
| { |
| ipcIntegrityCheckEpilogue(FALSE); |
| return FALSE; |
| } |
| |
| // check for proxySyntax_, it is stored as (long length, *char) |
| if (!(checkCharStarInBuffer(buf, sameEndianness, lastByte))) |
| return FALSE; |
| |
| return TRUE; |
| } |
| |
| ResultSetInfo& ResultSetInfo::operator=(const ResultSetInfo &src) |
| { |
| // Nothing to do if source and target are same |
| if (this == &src) |
| return *this; |
| |
| deallocateString(proxySyntax_); |
| proxySyntax_ = allocateString(src.proxySyntax_); |
| |
| stmtID_ = src.stmtID_; |
| cntxID_ = src.cntxID_; |
| |
| return *this; |
| } |
| |
| //---------------------------------------------------------------------- |
| // class UdrRSInfoMsg |
| //---------------------------------------------------------------------- |
| UdrRSInfoMsg::UdrRSInfoMsg(ComUInt32 numRS, NAMemory *heap) |
| : UdrMessageObj(UDR_MSG_RS_INFO, UdrRSInfoMsgVersionNumber, heap), |
| numRS_(numRS), resultSetInfo_(NULL) |
| { |
| allocateResultSetInfo(); |
| } |
| |
| UdrRSInfoMsg::~UdrRSInfoMsg() |
| { |
| deallocateResultSetInfo(); |
| } |
| |
| ResultSetInfo &UdrRSInfoMsg::getRSInfo(ComUInt32 i) const |
| { |
| UdrExeAssert(resultSetInfo_ && numRS_ > i, |
| "An invalid index was passed to UdrRSInfoMsg::getRSInfo()"); |
| return resultSetInfo_[i]; |
| } |
| |
| void UdrRSInfoMsg::setRSInfo(ComUInt32 i, const ResultSetInfo &info) |
| { |
| UdrExeAssert(resultSetInfo_ && numRS_ > i, |
| "An invalid index was passed to UdrRSInfoMsg::setRSInfo()"); |
| resultSetInfo_[i] = info; |
| } |
| |
| void UdrRSInfoMsg::allocateResultSetInfo() |
| { |
| deallocateResultSetInfo(); |
| |
| // Allocate memory for resultSetInfo_ field |
| ComUInt32 n = numRS_ * sizeof(ResultSetInfo); |
| resultSetInfo_ = (ResultSetInfo *) (n ? allocateMemory(n) : NULL); |
| memset(resultSetInfo_, 0, n); |
| |
| for (ComUInt32 i=0; i < numRS_; i++) |
| resultSetInfo_[i].setHeap(getHeap()); |
| } |
| |
| void UdrRSInfoMsg::deallocateResultSetInfo() |
| { |
| if (resultSetInfo_) |
| { |
| for (ComUInt32 i=0; i < numRS_; i++) |
| { |
| deallocateMemory(resultSetInfo_[i].proxySyntax_); |
| } |
| } |
| deallocateMemory((char *) resultSetInfo_); |
| resultSetInfo_ = NULL; |
| } |
| |
| IpcMessageObjSize UdrRSInfoMsg::packedLength() |
| { |
| IpcMessageObjSize result = super::packedLength(); |
| result += sizeof(numRS_); |
| |
| for (ComUInt32 i=0; i<numRS_; i++) |
| result += getRSInfo(i).packedLength(); |
| |
| return result; |
| } |
| |
| IpcMessageObjSize UdrRSInfoMsg::packObjIntoMessage(IpcMessageBufferPtr buffer) |
| { |
| IpcMessageObjSize result = 0; |
| |
| result += packUdrBaseClass(buffer); |
| |
| #ifdef UDR_DEBUG |
| char *val = getenv("MXUDR_CORRUPT_UDRRSINFOMSG"); |
| if (val && val[0]) |
| { |
| result += packIntoBuffer(buffer, (numRS_+ 1)); |
| } else |
| result += packIntoBuffer(buffer, numRS_); |
| |
| #else |
| result += packIntoBuffer(buffer, numRS_); |
| #endif |
| |
| for (ComUInt32 i=0; i<numRS_; i++) |
| { |
| result += getRSInfo(i).pack(buffer); |
| } |
| |
| return result; |
| } |
| |
| void UdrRSInfoMsg::unpackObj(IpcMessageObjType objType, |
| IpcMessageObjVersion objVersion, |
| NABoolean sameEndianness, |
| IpcMessageObjSize objSize, |
| IpcConstMessageBufferPtr buffer) |
| { |
| unpackUdrBaseClass(buffer); |
| |
| unpackBuffer(buffer, numRS_); |
| |
| allocateResultSetInfo(); |
| |
| for (ComUInt32 i=0; i<numRS_; i++) |
| { |
| getRSInfo(i).unpack(buffer); |
| } |
| } |
| |
| NABoolean UdrRSInfoMsg::checkObj(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr buffer) const |
| { |
| return checkUdrBaseClass(t, v, sameEndianness, size, buffer); |
| } |
| |
| NABoolean UdrRSInfoMsg::checkUdrBaseClass(IpcMessageObjType t, |
| IpcMessageObjVersion v, |
| NABoolean sameEndianness, |
| IpcMessageObjSize size, |
| IpcConstMessageBufferPtr &buf) const |
| { |
| IpcConstMessageBufferPtr lastByte = buf + size - 1; |
| IpcConstMessageBufferPtr oldBuf = buf; |
| |
| if (!super::checkUdrBaseClass(t, v, sameEndianness, size, buf)) |
| return FALSE; |
| |
| // We need to adjust size since it will be used by |
| // ResultSetInfo::checkResultSetInfoClass() |
| size -= (buf - oldBuf); |
| oldBuf = buf; |
| |
| ComUInt32 numRS = 0; |
| if (!checkAndUnpackBuffer(buf, sizeof(numRS), |
| (char *) &numRS, lastByte)) |
| { |
| ipcIntegrityCheckEpilogue(FALSE); |
| return FALSE; |
| } |
| |
| for (ComUInt32 i=0; i<numRS; i++) |
| { |
| size -= (buf - oldBuf); |
| oldBuf = buf; |
| if (!(ResultSetInfo::checkResultSetInfoClass(t, v, sameEndianness, size, buf))) |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
