| // @@@ 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 @@@ |
|
|
| #include <windows.h>
|
| #include <cee.h>
|
| #include <idltype.h>
|
| #include <marshaling.h>
|
|
|
| #define SRVRTRACE_ENTER(name)
|
| #define SRVRTRACE_EXIT(name)
|
|
|
| //
|
| //----------- input parameters ------------------------------
|
| //
|
| CEE_status decodeParameters(short count, long* param[], char* buffer, long length)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+1);
|
| char* pbuffer = buffer;
|
| long* parptr, *mapptr;
|
| int i;
|
| long start_data = 0;
|
| long end_data = length;
|
| long offset;
|
|
|
| memset (param, 0, count*sizeof(long));
|
|
|
| for (start_data=count * sizeof(long) ;start_data < length; start_data += sizeof(long))
|
| {
|
| if ((long)buffer[start_data] == 0)
|
| {
|
| start_data += sizeof(long);
|
| break;
|
| }
|
| }
|
| if (start_data >= length)
|
| {
|
| SRVRTRACE_EXIT(FILE_IMR+1);
|
| return -1;
|
| }
|
|
|
| for (parptr = (long*)pbuffer, i=0; i < count; i++, parptr++)
|
| {
|
| if (*parptr != 0)
|
| {
|
| offset = *(parptr);
|
| if (offset < start_data || offset >= end_data)
|
| {
|
| SRVRTRACE_EXIT(FILE_IMR+1);
|
| return i+1;
|
| }
|
| *(parptr) += (long)pbuffer;
|
| param[i] = (long*)*(parptr);
|
| }
|
| else
|
| param[i] = NULL;
|
| }
|
|
|
| for (mapptr = (long*)buffer + count; *mapptr != 0; mapptr++, i++)
|
| {
|
| offset =(long)*mapptr;
|
| if (offset < start_data || offset >= end_data)
|
| {
|
| SRVRTRACE_EXIT(FILE_IMR+1);
|
| return i+1;
|
| }
|
| parptr = (long*)(*mapptr + pbuffer);
|
| offset = *(parptr);
|
| if (offset < start_data || offset >= end_data)
|
| {
|
| SRVRTRACE_EXIT(FILE_IMR+1);
|
| return i+1;
|
| }
|
| *parptr += (long)pbuffer;
|
| }
|
|
|
| SRVRTRACE_EXIT(FILE_IMR+1);
|
| return CEE_SUCCESS;
|
| }
|
| //
|
| //---------------- output parameters ---------------------------
|
| //
|
| //---------------- calculate the length ------------------------
|
| //
|
| void LIST_length( LIST_def* pname, long length, long& wlength, long& maplength)
|
| {
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| wlength += ( pname->_length * length);
|
| maplength += sizeof(long);
|
| }
|
| }
|
|
|
| void OCTET_length( OCTET_def* pname, long& wlength, long& maplength)
|
| {
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| wlength += pname->_length;
|
| maplength += sizeof(long);
|
| }
|
| }
|
|
|
| void STRING_length( IDL_string pname, long& wlength, long& maplength)
|
| {
|
| if (pname != NULL)
|
| {
|
| wlength += strlen(pname) + 1;
|
| maplength += sizeof(long);
|
| }
|
| }
|
|
|
| void ERROR_DESC_LIST_length( ERROR_DESC_LIST_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+2);
|
| wlength += sizeof(ERROR_DESC_LIST_def);
|
|
|
| LIST_length((LIST_def*) pname, sizeof(ERROR_DESC_def), wlength, maplength);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| ERROR_DESC_def* pED;
|
| for (unsigned int i = 0; i < pname->_length; i++)
|
| {
|
| pED = pname->_buffer + i;
|
|
|
| STRING_length( pED->errorText, wlength, maplength);
|
| STRING_length( pED->Param1, wlength, maplength);
|
| STRING_length( pED->Param2, wlength, maplength);
|
| STRING_length( pED->Param3, wlength, maplength);
|
| STRING_length( pED->Param4, wlength, maplength);
|
| STRING_length( pED->Param5, wlength, maplength);
|
| STRING_length( pED->Param6, wlength, maplength);
|
| STRING_length( pED->Param7, wlength, maplength);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+2);
|
| }
|
|
|
| // New format
|
| void ERROR_DESC_LIST_length( ERROR_DESC_LIST_def* pname, IDL_long& wlength)
|
| {
|
| IDL_unsigned_long i = 0;
|
|
|
| wlength += sizeof(pname->_length);
|
|
|
| if(pname->_length > 0 && pname->_buffer != NULL)
|
| {
|
| ERROR_DESC_def *ptr = pname->_buffer;
|
|
|
| for(i = 0; i < pname->_length; i++)
|
| {
|
| wlength += sizeof(ptr->rowId);
|
| wlength += sizeof(ptr->errorDiagnosticId);
|
| wlength += sizeof(ptr->sqlcode);
|
| wlength += sizeof(ptr->sqlstate);
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->errorText != NULL)
|
| wlength += strlen(ptr->errorText) + 1;
|
|
|
| wlength += sizeof(ptr->operationAbortId);
|
| wlength += sizeof(ptr->errorCodeType);
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param1 != NULL)
|
| wlength += strlen(ptr->Param1) + 1;
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param2 != NULL)
|
| wlength += strlen(ptr->Param2) + 1;
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param3 != NULL)
|
| wlength += strlen(ptr->Param3) + 1;
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param4 != NULL)
|
| wlength += strlen(ptr->Param4) + 1;
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param5 != NULL)
|
| wlength += strlen(ptr->Param5) + 1;
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param6 != NULL)
|
| wlength += strlen(ptr->Param6) + 1;
|
|
|
| wlength += sizeof(IDL_long);
|
| if (ptr->Param7 != NULL)
|
| wlength += strlen(ptr->Param7) + 1;
|
|
|
| ptr++;
|
|
|
| }
|
|
|
| }
|
|
|
| } // ERROR_DESC_LIST_length
|
|
|
| void SRVR_CONTEXT_length( const SRVR_CONTEXT_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+3);
|
| wlength += sizeof(SRVR_CONTEXT_def);
|
| ENV_DESC_LIST_length( &pname->envDescList, wlength, maplength );
|
| RES_DESC_LIST_length( &pname->resDescList, wlength, maplength );
|
| SRVRTRACE_EXIT(FILE_IMR+3);
|
| }
|
|
|
| void DATASOURCE_CFG_LIST_length( const DATASOURCE_CFG_LIST_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+4);
|
| wlength += sizeof(DATASOURCE_CFG_LIST_def);
|
|
|
| LIST_length((LIST_def*)pname, sizeof(DATASOURCE_CFG_def), wlength, maplength);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| DATASOURCE_CFG_def* pDCFG;
|
|
|
| for (unsigned int i=0; i < pname->_length; i++)
|
| {
|
| pDCFG = pname->_buffer + i;
|
| ENV_DESC_LIST_length( &pDCFG->EnvDescList, wlength, maplength );
|
| RES_DESC_LIST_length( &pDCFG->ResDescList, wlength, maplength );
|
| OCTET_length( (OCTET_def*)&pDCFG->DefineDescList, wlength, maplength);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+4);
|
| }
|
|
|
| void SQLVALUE_LIST_length( const SQLValueList_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+5);
|
| wlength += sizeof(SQLValueList_def);
|
|
|
| LIST_length((LIST_def*)pname, sizeof(SQLValue_def), wlength, maplength);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| SQLValue_def* pSQLValue;
|
|
|
| for (unsigned int i=0; i < pname->_length; i++)
|
| {
|
| wlength += sizeof(SQLValue_def);
|
|
|
| pSQLValue = pname->_buffer + i;
|
|
|
| OCTET_length( (OCTET_def*)&pSQLValue->dataValue, wlength, maplength);
|
|
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+5);
|
| }
|
|
|
| // new format
|
| void SQLVALUE_LIST_length(SQLValueList_def* pname, IDL_long& wlength)
|
| {
|
| IDL_unsigned_long i;
|
|
|
| wlength += sizeof(pname->_length);
|
|
|
| if(pname->_length > 0)
|
| {
|
| SQLValue_def *pSQLValue = pname->_buffer;
|
|
|
| for(i = 0; i < pname->_length; i++)
|
| {
|
| wlength += sizeof(pSQLValue->dataType);
|
| wlength += sizeof(pSQLValue->dataInd);
|
| wlength += sizeof(pSQLValue->dataValue._length);
|
| if(pSQLValue->dataValue._length > 0)
|
| wlength += pSQLValue->dataValue._length;
|
| wlength += sizeof(pSQLValue->dataCharset);
|
| pSQLValue++;
|
| }
|
|
|
| }
|
|
|
| } // SQLVALUE_LIST_length()
|
|
|
|
|
| void SQLITEMDESC_LIST_length(SQLItemDescList_def* pname, IDL_long& wlength)
|
| {
|
| IDL_unsigned_long i;
|
| IDL_unsigned_long tmpLength = 0;
|
|
|
| wlength += sizeof(pname->_length);
|
|
|
| if(pname->_length > 0)
|
| {
|
|
|
| tmpLength += sizeof(pname->_buffer->version);
|
| tmpLength += sizeof(pname->_buffer->dataType);
|
| tmpLength += sizeof(pname->_buffer->datetimeCode);
|
| tmpLength += sizeof(pname->_buffer->maxLen);
|
| tmpLength += sizeof(pname->_buffer->precision);
|
| tmpLength += sizeof(pname->_buffer->scale);
|
| tmpLength += sizeof(pname->_buffer->nullInfo);
|
| tmpLength += sizeof(IDL_long); // length followed by data (colHeadingNm)
|
| tmpLength += sizeof(pname->_buffer->signType);
|
| tmpLength += sizeof(pname->_buffer->ODBCDataType);
|
| tmpLength += sizeof(pname->_buffer->ODBCPrecision);
|
| tmpLength += sizeof(pname->_buffer->SQLCharset);
|
| tmpLength += sizeof(pname->_buffer->ODBCCharset);
|
| tmpLength += sizeof(IDL_long); // length followed by data (TableName)
|
| tmpLength += sizeof(IDL_long); // length followed by data (CatalogName)
|
| tmpLength += sizeof(IDL_long); // length followed by data (SchemaName)
|
| tmpLength += sizeof(IDL_long); // length followed by data (Heading)
|
| tmpLength += sizeof(pname->_buffer->intLeadPrec);
|
| tmpLength += sizeof(pname->_buffer->paramMode);
|
|
|
|
|
| wlength += (pname->_length * tmpLength);
|
|
|
| SQLItemDesc_def *pSQLItemDesc = pname->_buffer;
|
|
|
| for(i = 0; i < pname->_length; i++)
|
| {
|
| if(pSQLItemDesc->colHeadingNm[0] != '\0')
|
| wlength += (strlen(pSQLItemDesc->colHeadingNm) +1);
|
| if(pSQLItemDesc->colHeadingNm[0] != '\0')
|
| wlength += (strlen(pSQLItemDesc->TableName) +1);
|
| if(pSQLItemDesc->colHeadingNm[0] != '\0')
|
| wlength += (strlen(pSQLItemDesc->CatalogName) +1);
|
| if(pSQLItemDesc->colHeadingNm[0] != '\0')
|
| wlength += (strlen(pSQLItemDesc->SchemaName) +1);
|
| if(pSQLItemDesc->colHeadingNm[0] != '\0')
|
| wlength += (strlen(pSQLItemDesc->Heading) +1);
|
| pSQLItemDesc++;
|
| }
|
| }
|
|
|
| } // SQLITEMDESC_LIST_length()
|
|
|
|
|
| void SRVR_STATUS_LIST_length( const SRVR_STATUS_LIST_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+6);
|
| wlength += sizeof(SRVR_STATUS_LIST_def);
|
|
|
| LIST_length((LIST_def*)pname, sizeof(SRVR_STATUS_def), wlength, maplength);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| SRVR_STATUS_def* pSRVR;
|
|
|
| for (unsigned int i=0; i < pname->_length; i++)
|
| {
|
| wlength += sizeof(SRVR_STATUS_def);
|
|
|
| pSRVR = pname->_buffer + i;
|
|
|
| STRING_length( pSRVR->userName, wlength, maplength);
|
| STRING_length( pSRVR->windowText, wlength, maplength);
|
|
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+6);
|
| }
|
|
|
| void ENV_DESC_LIST_length( const ENV_DESC_LIST_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+7);
|
| wlength += sizeof(ENV_DESC_LIST_def);
|
|
|
| LIST_length((LIST_def*)pname, sizeof(ENV_DESC_def), wlength, maplength);
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| ENV_DESC_def* pED;
|
| for (unsigned int i = 0; i < pname->_length; i++)
|
| {
|
| pED = pname->_buffer + i;
|
|
|
| STRING_length( pED->VarVal, wlength, maplength);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+7);
|
| }
|
|
|
| void RES_DESC_LIST_length( const RES_DESC_LIST_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+8);
|
| wlength += sizeof(RES_DESC_LIST_def);
|
|
|
| LIST_length((LIST_def*)pname, sizeof(RES_DESC_def), wlength, maplength);
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| RES_DESC_def* pRD;
|
| for (unsigned int i = 0; i < pname->_length; i++)
|
| {
|
| pRD = pname->_buffer + i;
|
|
|
| STRING_length( pRD->Action, wlength, maplength);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+8);
|
| }
|
|
|
| void DATASOURCE_CFG_length( const DATASOURCE_CFG_def* pname, long& wlength, long& maplength )
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+9);
|
| wlength += sizeof(DATASOURCE_CFG_def);
|
| ENV_DESC_LIST_length( &pname->EnvDescList, wlength, maplength );
|
| RES_DESC_LIST_length( &pname->ResDescList, wlength, maplength );
|
| OCTET_length( (OCTET_def*)&pname->DefineDescList, wlength, maplength);
|
| SRVRTRACE_EXIT(FILE_IMR+9);
|
| }
|
|
|
| //
|
| //--------------------- copy parameters ------------------------
|
| //
|
| void IDL_charArray_copy(const IDL_char* pname, char*& curptr)
|
| {
|
| long length;
|
|
|
| if (pname != NULL)
|
| {
|
| length = strlen(pname) + 1;
|
| memcpy(curptr, pname,length);
|
| curptr += length;
|
| }
|
| }
|
|
|
| void IDL_charArray_Pad_copy(const IDL_char* pname, long length, char*& curptr)
|
| {
|
| if (pname != NULL)
|
| {
|
| memset(curptr,0,length);
|
| memcpy(curptr, pname,length);
|
| curptr += length;
|
| }
|
| }
|
|
|
| void IDL_byteArray_copy(BYTE* pname, long length, char*& curptr)
|
| {
|
| if (pname != NULL)
|
| {
|
| memcpy(curptr, pname,length);
|
| curptr += length;
|
| }
|
| }
|
|
|
| /*
|
| * for 64bit
|
| */
|
|
|
| void Long_copy(Long* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(Long));
|
| curptr += sizeof(Long);
|
| }
|
|
|
| void IDL_long_copy(IDL_long* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(IDL_long));
|
| curptr += sizeof(IDL_long);
|
| }
|
|
|
| void IDL_unsigned_long_copy(IDL_unsigned_long* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(IDL_unsigned_long));
|
| curptr += sizeof(IDL_unsigned_long);
|
| }
|
|
|
| void IDL_short_copy(IDL_short* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(IDL_short));
|
| curptr += sizeof(IDL_short);
|
| }
|
|
|
| void IDL_unsigned_short_copy(IDL_unsigned_short* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(IDL_unsigned_short));
|
| curptr += sizeof(IDL_unsigned_short);
|
| }
|
|
|
| void IDL_long_long_copy(IDL_long_long* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(IDL_long_long));
|
| curptr += sizeof(IDL_long_long);
|
| }
|
|
|
| void IDL_unsigned_long_long_copy(IDL_unsigned_long_long* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(IDL_unsigned_long_long));
|
| curptr += sizeof(IDL_unsigned_long_long);
|
| }
|
|
|
| void IDL_double_copy(double* pname, char*& curptr)
|
| {
|
| memcpy(curptr, pname, sizeof(double));
|
| curptr += sizeof(double);
|
| }
|
|
|
| void LIST_copy( char* buffer, LIST_def* pname, LIST_def* parptr, long length, char*& curptr, long*& mapptr)
|
| {
|
| long* tmpptr;
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| tmpptr = (long*)&(parptr->_buffer);
|
| *(mapptr++) = (char *)tmpptr - buffer;
|
| *tmpptr = curptr - buffer;
|
| memcpy(curptr, pname->_buffer, pname->_length * length);
|
| curptr += pname->_length * length;
|
| }
|
| }
|
|
|
| void OCTET_copy( char* buffer, OCTET_def* pname, OCTET_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| long* tmpptr;
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| tmpptr = (long*)&(parptr->_buffer);
|
| *(mapptr++) = (char *)tmpptr - buffer;
|
| *tmpptr = curptr - buffer;
|
| memcpy(curptr, pname->_buffer, pname->_length);
|
| curptr += pname->_length;
|
| }
|
| }
|
|
|
| void STRING_copy( char* buffer, IDL_string pname, IDL_string* parptr, char*& curptr, long*& mapptr)
|
| {
|
| long length;
|
| long* tmpptr;
|
|
|
| if (pname != NULL)
|
| {
|
| tmpptr = (long*)parptr;
|
| *(mapptr++) = (char *)tmpptr - buffer;
|
| *tmpptr = curptr - buffer;
|
| length = strlen(pname) + 1;
|
| memcpy(curptr,pname, length);
|
| curptr += length;
|
| }
|
| }
|
|
|
| void ERROR_DESC_LIST_copy( char* buffer, ERROR_DESC_LIST_def* pname, ERROR_DESC_LIST_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+10);
|
| memcpy(curptr, pname, sizeof(ERROR_DESC_LIST_def));
|
| curptr += sizeof(ERROR_DESC_LIST_def);
|
|
|
| LIST_copy( buffer, (LIST_def*)pname, (LIST_def*) parptr, sizeof(ERROR_DESC_def), curptr, mapptr);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| ERROR_DESC_def* pED;
|
| ERROR_DESC_def* pEDpar;
|
| for (unsigned int i = 0; i < pname->_length; i++)
|
| {
|
| pED = pname->_buffer + i;
|
| pEDpar = (ERROR_DESC_def*)((ULONG)parptr->_buffer + (ULONG)buffer + i*sizeof(ERROR_DESC_def));
|
|
|
| STRING_copy( buffer, pED->errorText, &pEDpar->errorText, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param1, &pEDpar->Param1, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param2, &pEDpar->Param2, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param3, &pEDpar->Param3, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param4, &pEDpar->Param4, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param5, &pEDpar->Param5, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param6, &pEDpar->Param6, curptr, mapptr);
|
| STRING_copy( buffer, pED->Param7, &pEDpar->Param7, curptr, mapptr);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+10);
|
| }
|
|
|
| // marshalling - new format
|
| void ERROR_DESC_LIST_copy(ERROR_DESC_LIST_def* pname, IDL_char*& curptr)
|
| {
|
|
|
| IDL_unsigned_long i = 0;
|
| IDL_long tmpLength;
|
|
|
| IDL_unsigned_long_copy(&pname->_length, curptr);
|
|
|
| if(pname->_length > 0 && pname->_buffer != NULL)
|
| {
|
| ERROR_DESC_def *ptr = pname->_buffer;
|
|
|
| for(i = 0; i < pname->_length; i++)
|
| {
|
|
|
| IDL_long_copy(&ptr->rowId, curptr);
|
| IDL_long_copy(&ptr->errorDiagnosticId, curptr);
|
| IDL_long_copy(&ptr->sqlcode, curptr);
|
|
|
| strncpy(curptr,ptr->sqlstate,sizeof(ptr->sqlstate));
|
| curptr += sizeof(ptr->sqlstate);
|
|
|
| tmpLength = (ptr->errorText == NULL) ? 0 : strlen(ptr->errorText);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->errorText,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| IDL_long_copy(&ptr->operationAbortId,curptr);
|
| IDL_long_copy(&ptr->errorCodeType,curptr);
|
|
|
| tmpLength = (ptr->Param1 == NULL) ? 0 : strlen(ptr->Param1);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param1,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| tmpLength = (ptr->Param2 == NULL) ? 0 : strlen(ptr->Param2);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param2,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| tmpLength = (ptr->Param3 == NULL) ? 0 : strlen(ptr->Param3);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param3,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| tmpLength = (ptr->Param4 == NULL) ? 0 : strlen(ptr->Param4);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param4,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| tmpLength = (ptr->Param5 == NULL) ? 0 : strlen(ptr->Param5);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param5,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| tmpLength = (ptr->Param6 == NULL) ? 0 : strlen(ptr->Param6);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param6,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| tmpLength = (ptr->Param7 == NULL) ? 0 : strlen(ptr->Param7);
|
| if(tmpLength > 0)
|
| {
|
| tmpLength++; // null terminator
|
| IDL_long_copy(&tmpLength,curptr);
|
| IDL_charArray_copy(ptr->Param7,curptr);
|
|
|
| }
|
| else
|
| IDL_long_copy(&tmpLength,curptr);
|
|
|
| ptr++;
|
| }
|
| }
|
|
|
| } /* ERROR_DESC_LIST_copy() */
|
|
|
| void SRVR_CONTEXT_copy( char* buffer, const SRVR_CONTEXT_def* pname, SRVR_CONTEXT_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+11);
|
| memcpy(curptr, pname, sizeof(SRVR_CONTEXT_def));
|
| curptr += sizeof(SRVR_CONTEXT_def);
|
|
|
| ENV_DESC_LIST_copy(buffer, &pname->envDescList, &parptr->envDescList, curptr, mapptr);
|
| RES_DESC_LIST_copy(buffer, &pname->resDescList, &parptr->resDescList, curptr, mapptr);
|
| SRVRTRACE_EXIT(FILE_IMR+11);
|
| }
|
|
|
| void DATASOURCE_CFG_LIST_copy( char* buffer, const DATASOURCE_CFG_LIST_def* pname, DATASOURCE_CFG_LIST_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+12);
|
| memcpy(curptr, pname, sizeof(DATASOURCE_CFG_LIST_def));
|
| curptr += sizeof(DATASOURCE_CFG_LIST_def);
|
|
|
| LIST_copy( buffer, (LIST_def*)pname, (LIST_def*)parptr, sizeof(DATASOURCE_CFG_def), curptr, mapptr);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| DATASOURCE_CFG_def* pDCFG;
|
| DATASOURCE_CFG_def* pDCFGpar;
|
|
|
| for (unsigned int i=0; i < pname->_length; i++)
|
| {
|
| pDCFG = pname->_buffer + i;
|
| pDCFGpar = (DATASOURCE_CFG_def*)((ULONG)parptr->_buffer + (ULONG)buffer + i*sizeof(DATASOURCE_CFG_def));
|
|
|
| ENV_DESC_LIST_copy(buffer, &pDCFG->EnvDescList, &pDCFGpar->EnvDescList, curptr, mapptr);
|
| RES_DESC_LIST_copy(buffer, &pDCFG->ResDescList, &pDCFGpar->ResDescList, curptr, mapptr);
|
| OCTET_copy( buffer, (OCTET_def*)&pDCFG->DefineDescList, (OCTET_def*)&pDCFGpar->DefineDescList, curptr, mapptr);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+12);
|
| }
|
|
|
| void SQLVALUE_LIST_copy( char* buffer, const SQLValueList_def* pname, SQLValueList_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+13);
|
| memcpy(curptr, pname, sizeof(SQLValueList_def));
|
| curptr += sizeof(SQLValueList_def);
|
|
|
| LIST_copy( buffer, (LIST_def*)pname, (LIST_def*)parptr, sizeof(SQLValue_def), curptr, mapptr);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| SQLValue_def* pSQLValue;
|
| SQLValue_def* pSQLValuepar;
|
|
|
| for (unsigned int i=0; i < pname->_length; i++)
|
| {
|
| pSQLValue = pname->_buffer + i;
|
| pSQLValuepar = (SQLValue_def*)((ULONG)parptr->_buffer + (ULONG)buffer + i*sizeof(SQLValue_def));
|
|
|
| OCTET_copy( buffer, (OCTET_def*)&pSQLValue->dataValue, (OCTET_def*)&pSQLValuepar->dataValue, curptr, mapptr);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+13);
|
| }
|
|
|
| // new format
|
| void SQLVALUE_LIST_copy(SQLValueList_def* pname, IDL_char*& curptr)
|
| {
|
|
|
| IDL_unsigned_long i;
|
|
|
| IDL_unsigned_long_copy(&pname->_length, curptr);
|
|
|
| if(pname->_length > 0)
|
| {
|
| SQLValue_def *pSQLValue = pname->_buffer;
|
|
|
| for(i = 0; i < pname->_length; i++)
|
| {
|
| IDL_long_copy(&pSQLValue->dataType,curptr);
|
| IDL_short_copy(&pSQLValue->dataInd,curptr);
|
| IDL_unsigned_long_copy(&pSQLValue->dataValue._length, curptr);
|
| if(pSQLValue->dataValue._length > 0)
|
| IDL_byteArray_copy(pSQLValue->dataValue._buffer,pSQLValue->dataValue._length,curptr);
|
| IDL_long_copy(&pSQLValue->dataCharset,curptr);
|
| pSQLValue++;
|
| }
|
|
|
| }
|
| } // SQLVALUE_LIST_copy()
|
|
|
| // new format
|
| void SQLITEMDESC_LIST_copy(SQLItemDescList_def* pname, IDL_char*& curptr)
|
| {
|
|
|
| IDL_unsigned_long i;
|
|
|
| IDL_long colHeadingNmLength = 0;
|
| IDL_long TableNameLength = 0;
|
| IDL_long CatalogNameLength = 0;
|
| IDL_long SchemaNameLength = 0;
|
| IDL_long HeadingLength = 0;
|
|
|
|
|
| IDL_unsigned_long_copy(&pname->_length, curptr);
|
|
|
| if(pname->_length > 0 && pname->_buffer != NULL)
|
| {
|
| SQLItemDesc_def *pSQLItemDesc = pname->_buffer;
|
|
|
| for(i = 0; i < pname->_length; i++)
|
| {
|
| IDL_long_copy(&pSQLItemDesc->version,curptr);
|
| IDL_long_copy(&pSQLItemDesc->dataType,curptr);
|
| IDL_long_copy(&pSQLItemDesc->datetimeCode,curptr);
|
| IDL_long_copy(&pSQLItemDesc->maxLen,curptr);
|
| IDL_short_copy(&pSQLItemDesc->precision,curptr);
|
| IDL_short_copy(&pSQLItemDesc->scale,curptr);
|
| IDL_byteArray_copy(&pSQLItemDesc->nullInfo,sizeof(pSQLItemDesc->nullInfo),curptr);
|
|
|
| if(pSQLItemDesc->colHeadingNm[0] != '\0')
|
| colHeadingNmLength = (strlen(pSQLItemDesc->colHeadingNm) +1);
|
| else
|
| colHeadingNmLength = 0;
|
| IDL_long_copy(&colHeadingNmLength,curptr);
|
| if(colHeadingNmLength > 0)
|
| IDL_charArray_copy(pSQLItemDesc->colHeadingNm,curptr);
|
|
|
|
|
| IDL_byteArray_copy(&pSQLItemDesc->signType,sizeof(pSQLItemDesc->signType),curptr);
|
| IDL_long_copy(&pSQLItemDesc->ODBCDataType,curptr);
|
| IDL_short_copy(&pSQLItemDesc->ODBCPrecision,curptr);
|
| IDL_long_copy(&pSQLItemDesc->SQLCharset,curptr);
|
| IDL_long_copy(&pSQLItemDesc->ODBCCharset,curptr);
|
|
|
| if(pSQLItemDesc->TableName[0] != '\0')
|
| TableNameLength = (strlen(pSQLItemDesc->TableName) +1);
|
| else
|
| TableNameLength = 0;
|
| IDL_long_copy(&TableNameLength,curptr);
|
| if(TableNameLength > 0)
|
| IDL_charArray_copy(pSQLItemDesc->TableName,curptr);
|
|
|
| if(pSQLItemDesc->CatalogName[0] != '\0')
|
| CatalogNameLength = (strlen(pSQLItemDesc->CatalogName) +1);
|
| else
|
| CatalogNameLength = 0;
|
| IDL_long_copy(&CatalogNameLength,curptr);
|
| if(CatalogNameLength > 0)
|
| IDL_charArray_copy(pSQLItemDesc->CatalogName,curptr);
|
|
|
| if(pSQLItemDesc->SchemaName[0] != '\0')
|
| SchemaNameLength = (strlen(pSQLItemDesc->SchemaName) +1);
|
| else
|
| SchemaNameLength = 0;
|
| IDL_long_copy(&SchemaNameLength,curptr);
|
| if(SchemaNameLength > 0)
|
| IDL_charArray_copy(pSQLItemDesc->SchemaName,curptr);
|
|
|
| if(pSQLItemDesc->Heading[0] != '\0')
|
| HeadingLength = (strlen(pSQLItemDesc->Heading) +1);
|
| else
|
| HeadingLength = 0;
|
| IDL_long_copy(&HeadingLength,curptr);
|
| if(HeadingLength > 0)
|
| IDL_charArray_copy(pSQLItemDesc->Heading,curptr);
|
|
|
| IDL_long_copy(&pSQLItemDesc->intLeadPrec,curptr);
|
| IDL_long_copy(&pSQLItemDesc->paramMode,curptr);
|
|
|
| pSQLItemDesc++;
|
| }
|
|
|
| }
|
| } // SQLVALUE_LIST_copy()
|
|
|
|
|
| void SRVR_STATUS_LIST_copy(char* buffer, const SRVR_STATUS_LIST_def* pname, SRVR_STATUS_LIST_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+14);
|
| memcpy(curptr, pname, sizeof(SRVR_STATUS_LIST_def));
|
| curptr += sizeof(SRVR_STATUS_LIST_def);
|
|
|
| LIST_copy( buffer, (LIST_def*)pname, (LIST_def*)parptr, sizeof(SRVR_STATUS_def), curptr, mapptr);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| SRVR_STATUS_def* pSRVR;
|
| SRVR_STATUS_def* pSRVRpar;
|
|
|
| for (unsigned int i=0; i < pname->_length; i++)
|
| {
|
| pSRVR = pname->_buffer + i;
|
| pSRVRpar = (SRVR_STATUS_def*)((ULONG)parptr->_buffer + (ULONG)buffer + i*sizeof(SRVR_STATUS_def));
|
|
|
| STRING_copy( buffer, pSRVR->userName, &pSRVRpar->userName, curptr, mapptr);
|
| STRING_copy( buffer, pSRVR->windowText, &pSRVRpar->windowText, curptr, mapptr);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+14);
|
| }
|
|
|
| void ENV_DESC_LIST_copy(char* buffer, const ENV_DESC_LIST_def* pname, ENV_DESC_LIST_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+15);
|
| memcpy(curptr, pname, sizeof(ENV_DESC_LIST_def));
|
| curptr += sizeof(ENV_DESC_LIST_def);
|
|
|
| LIST_copy( buffer, (LIST_def*)pname, (LIST_def*)parptr, sizeof(ENV_DESC_def), curptr, mapptr);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| ENV_DESC_def* pED;
|
| ENV_DESC_def* pEDpar;
|
| for (unsigned int i = 0; i < pname->_length; i++)
|
| {
|
| pED = pname->_buffer + i;
|
| pEDpar = (ENV_DESC_def*)((ULONG)parptr->_buffer + (ULONG)buffer + i*sizeof(ENV_DESC_def));
|
|
|
| STRING_copy( buffer, pED->VarVal, &pEDpar->VarVal, curptr, mapptr);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+15);
|
| }
|
|
|
| void RES_DESC_LIST_copy(char* buffer, const RES_DESC_LIST_def* pname, RES_DESC_LIST_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+16);
|
| memcpy(curptr, pname, sizeof(RES_DESC_LIST_def));
|
| curptr += sizeof(RES_DESC_LIST_def);
|
|
|
| LIST_copy( buffer, (LIST_def*)pname, (LIST_def*)parptr, sizeof(RES_DESC_def), curptr, mapptr);
|
|
|
| if (pname->_buffer != NULL && pname->_length > 0)
|
| {
|
| RES_DESC_def* pRD;
|
| RES_DESC_def* pRDpar;
|
| for (unsigned int i = 0; i < pname->_length; i++)
|
| {
|
| pRD = pname->_buffer + i;
|
| pRDpar = (RES_DESC_def*)((ULONG)parptr->_buffer + (ULONG)buffer + i*sizeof(RES_DESC_def));
|
|
|
| STRING_copy( buffer, pRD->Action, &pRDpar->Action, curptr, mapptr);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_IMR+16);
|
| }
|
|
|
| void DATASOURCE_CFG_copy( char* buffer, const DATASOURCE_CFG_def* pname, DATASOURCE_CFG_def* parptr, char*& curptr, long*& mapptr)
|
| {
|
| SRVRTRACE_ENTER(FILE_IMR+17);
|
| memcpy(curptr, pname, sizeof(DATASOURCE_CFG_def));
|
| curptr += sizeof(DATASOURCE_CFG_def);
|
|
|
| ENV_DESC_LIST_copy(buffer, &pname->EnvDescList, &parptr->EnvDescList, curptr, mapptr);
|
| RES_DESC_LIST_copy(buffer, &pname->ResDescList, &parptr->ResDescList, curptr, mapptr);
|
| OCTET_copy( buffer, (OCTET_def*)&pname->DefineDescList, (OCTET_def*)&parptr->DefineDescList, curptr, mapptr);
|
| SRVRTRACE_EXIT(FILE_IMR+17);
|
| }
|
