| // @@@ 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 "DrvrSrvr.h"
|
| #include "TransportBase.h"
|
| #include "marshaling.h"
|
| #include "swap.h"
|
|
|
| #ifndef NSK_PLATFORM
|
| #define SRVRTRACE_ENTER(name)
|
| #define SRVRTRACE_EXIT(name)
|
| #endif
|
|
|
| #ifdef __OBSOLETE
|
| void swapPointers(char* buffer, short number_of_param)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+1);
|
| long* ptr;
|
| short i=0;
|
|
|
| for (long* mapptr = (long*)buffer; ; mapptr++, i++)
|
| {
|
| if (i>= number_of_param)
|
| {
|
| if (*mapptr == 0) break;
|
| ptr = (long*)(*mapptr + (long)buffer);
|
| POINTER_swap(ptr);
|
| POINTER_swap(mapptr);
|
| }
|
| else
|
| POINTER_swap(mapptr);
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+1);
|
| }
|
| #endif /* __OBSOLETE */
|
|
|
| void SHORT_swap(short* pshort,char swap)
|
| {
|
| if(swap == SWAP_NO) return;
|
|
|
| SRVRTRACE_ENTER(FILE_SWAP+2);
|
| if (*pshort != 0 && *pshort != -1)
|
| {
|
| union
|
| {
|
| char c[2];
|
| unsigned short i;
|
| } u;
|
| char hold;
|
| u.i = *pshort;
|
| hold = u.c[0];
|
| u.c[0] = u.c[1];
|
| u.c[1] = hold;
|
| *pshort = u.i;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+2);
|
| }
|
|
|
| void USHORT_swap(unsigned short* pushort, char swap)
|
| {
|
| if(swap == SWAP_NO) return;
|
|
|
| SRVRTRACE_ENTER(FILE_SWAP+3);
|
| if (*pushort != 0 && *pushort != 0xFFFF)
|
| {
|
| union
|
| {
|
| char c[2];
|
| unsigned short i;
|
| } u;
|
| char hold;
|
| u.i = *pushort;
|
| hold = u.c[0];
|
| u.c[0] = u.c[1];
|
| u.c[1] = hold;
|
| *pushort = u.i;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+3);
|
| }
|
|
|
| /*
|
| * for stmtHandle 64bit
|
| */
|
| void Long_swap(Long* plong, char swap)
|
| {
|
| if(swap == SWAP_NO) return;
|
|
|
| SRVRTRACE_ENTER(FILE_SWAP+4);
|
| if (*plong != 0 && *plong != -1 )
|
| {
|
| union
|
| {
|
| char c[4];
|
| unsigned int l;
|
| } u;
|
| char hold;
|
| u.l = *plong;
|
| hold = u.c[0];
|
| u.c[0] = u.c[3];
|
| u.c[3] = hold;
|
| hold = u.c[2];
|
| u.c[2] = u.c[1];
|
| u.c[1] = hold;
|
| *plong = u.l;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+4);
|
|
|
| }
|
|
|
| #if defined(_WIN32) || defined(_WIN64)
|
| void LONG_swap(long* plong, char swap)
|
| #else
|
| void LONG_swap(int* plong, char swap)
|
| #endif
|
| {
|
| if(swap == SWAP_NO) return;
|
|
|
| SRVRTRACE_ENTER(FILE_SWAP+4);
|
| if (*plong != 0 && *plong != -1 )
|
| {
|
| union
|
| {
|
| char c[4];
|
| unsigned int l;
|
| } u;
|
| char hold;
|
| u.l = *plong;
|
| hold = u.c[0];
|
| u.c[0] = u.c[3];
|
| u.c[3] = hold;
|
| hold = u.c[2];
|
| u.c[2] = u.c[1];
|
| u.c[1] = hold;
|
| *plong = u.l;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+4);
|
|
|
| }
|
| #if defined(_WIN32) || defined(_WIN64)
|
| void ULONG_swap(unsigned long* pulong, char swap)
|
| #else
|
| void ULONG_swap(unsigned int* pulong, char swap)
|
| #endif
|
| {
|
| if(swap == SWAP_NO) return;
|
|
|
| SRVRTRACE_ENTER(FILE_SWAP+5);
|
| if (*pulong != 0 && *pulong != 0xFFFFFFFF)
|
| {
|
| union
|
| {
|
| char c[4];
|
| unsigned int l;
|
| } u;
|
| char hold;
|
| u.l = *pulong;
|
| hold = u.c[0];
|
| u.c[0] = u.c[3];
|
| u.c[3] = hold;
|
| hold = u.c[2];
|
| u.c[2] = u.c[1];
|
| u.c[1] = hold;
|
| *pulong = u.l;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+5);
|
|
|
| }
|
|
|
| #if !(defined(NSK_PLATFORM) || defined(NA_LINUX))
|
| void LONGLONG_swap(__int64* plonglong, char swap)
|
| {
|
| if (swap == SWAP_NO) return;
|
| if (*plonglong != 0)
|
| {
|
| union
|
| {
|
| char c[8];
|
| unsigned __int64 ll;
|
| } u;
|
| char llc[8];
|
| u.ll = *plonglong;
|
| memcpy(llc, u.c, 8);
|
| for(int i=0; i<8; i++)
|
| u.c[i] = llc[7-i];
|
| *plonglong = u.ll;
|
| }
|
| }
|
| void ULONGLONG_swap(unsigned __int64* plonglong, char swap)
|
| {
|
| if (swap == SWAP_NO) return;
|
|
|
| if (*plonglong != 0)
|
| {
|
| union
|
| {
|
| char c[8];
|
| unsigned __int64 ll;
|
| } u;
|
| char llc[8];
|
| u.ll = *plonglong;
|
| memcpy(llc, u.c, 8);
|
| for(int i=0; i<8; i++)
|
| u.c[i] = llc[7-i];
|
| *plonglong = u.ll;
|
| }
|
| }
|
| #else
|
| void LONGLONG_swap(long long* plonglong)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+7);
|
| if (*plonglong != 0)
|
| {
|
| union
|
| {
|
| char c[8];
|
| long long ll;
|
| } u;
|
| char llc[8];
|
| u.ll = *plonglong;
|
| memcpy(llc, u.c, 8);
|
| for(int i=0; i<8; i++)
|
| u.c[i] = llc[7-i];
|
| *plonglong = u.ll;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+7);
|
| }
|
|
|
| void ULONGLONG_swap(unsigned long long* plonglong)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+7);
|
| if (*plonglong != 0)
|
| {
|
| union
|
| {
|
| char c[8];
|
| unsigned long long ll;
|
| } u;
|
| char llc[8];
|
| u.ll = *plonglong;
|
| memcpy(llc, u.c, 8);
|
| for(int i=0; i<8; i++)
|
| u.c[i] = llc[7-i];
|
| *plonglong = u.ll;
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+7);
|
| }
|
| #endif
|
|
|
|
|
| void VERSION_LIST_swap(char* buffer, VERSION_LIST_def* pverlist)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+8);
|
|
|
| if (pverlist->_buffer != NULL && pverlist->_length != 0 )
|
| {
|
| VERSION_def *_buffer = pverlist->_buffer;
|
| IDL_unsigned_long _length = pverlist->_length;
|
|
|
| VERSION_def *pver;
|
| ULONG_swap(&pverlist->_length);
|
| _buffer = (VERSION_def *)((long)_buffer + (long)buffer);
|
|
|
| for (unsigned int i=0; i<_length; i++)
|
| {
|
| pver = _buffer + i;
|
| SHORT_swap(&pver->componentId);
|
| SHORT_swap(&pver->majorVersion);
|
| SHORT_swap(&pver->minorVersion);
|
| ULONG_swap(&pver->buildId);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+8);
|
| }
|
|
|
| #if defined(_WIN32) || defined(_WIN64)
|
| void HEADER_swap(HEADER* header)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+9);
|
| SHORT_swap(&header->operation_id);
|
| LONG_swap((long*)&header->dialogueId);
|
| ULONG_swap((unsigned long*)&header->total_length);
|
| ULONG_swap((unsigned long*)&header->cmp_length);
|
| LONG_swap((long*)&header->hdr_type);
|
| ULONG_swap((unsigned long*)&header->signature);
|
| ULONG_swap((unsigned long*)&header->version);
|
| SHORT_swap(&header->error);
|
| SHORT_swap(&header->error_detail);
|
| SRVRTRACE_EXIT(FILE_SWAP+9);
|
| }
|
| #else
|
| void HEADER_swap(HEADER* header)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+9);
|
| SHORT_swap(&header->operation_id);
|
| LONG_swap(&header->dialogueId);
|
| ULONG_swap(&header->total_length);
|
| ULONG_swap(&header->cmp_length);
|
| LONG_swap((int*)&header->hdr_type);
|
| ULONG_swap(&header->signature);
|
| ULONG_swap(&header->version);
|
| SHORT_swap(&header->error);
|
| SHORT_swap(&header->error_detail);
|
| SRVRTRACE_EXIT(FILE_SWAP+9);
|
| }
|
| #endif
|
|
|
| void SQL_WARNING_OR_ERROR_swap(BYTE *WarningOrError, IDL_long WarningOrErrorLengthCheck,char swap)
|
| {
|
| IDL_long msg_total_len = 0;
|
|
|
| IDL_long numConditions = 0;
|
| IDL_long errorTextLen = 0;
|
|
|
| unsigned char *curptr;
|
| int i;
|
|
|
| curptr = (unsigned char *)WarningOrError;
|
|
|
| //swap numConditions and then pull it out, for indexing
|
| LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
|
| numConditions = *(IDL_long*)(curptr+msg_total_len);
|
| msg_total_len +=4;
|
|
|
| if (numConditions > 0)
|
| {
|
| for (i = 0; i < numConditions; i++)
|
| {
|
| //rowId= *(IDL_long*)(curptr+msg_total_len);
|
| LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
|
| msg_total_len +=4;
|
|
|
| //sqlCode= *(IDL_long*)(curptr+msg_total_len);
|
| LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
|
| msg_total_len +=4;
|
|
|
| //swap errorTextLen then grab it
|
| LONG_swap((IDL_long*)(curptr+msg_total_len),swap);
|
| errorTextLen= *(IDL_long*)(curptr+msg_total_len);
|
| msg_total_len +=4;
|
| msg_total_len +=errorTextLen;
|
|
|
| msg_total_len += 6 * (sizeof(char));//sizeof(sqlState);
|
| }
|
| }
|
| //if(msg_total_len!=WarningOrErrorLengthCheck) return appropriate error;
|
| }
|
| void ERROR_DESC_LIST_swap(char* buffer, ERROR_DESC_LIST_def *errorList)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+10);
|
|
|
| if (errorList->_buffer != NULL && errorList->_length != 0 )
|
| {
|
| ERROR_DESC_def *_buffer = errorList->_buffer;
|
| IDL_unsigned_long _length = errorList->_length;
|
|
|
| ERROR_DESC_def *perr;
|
| ULONG_swap(&errorList->_length);
|
| _buffer = (ERROR_DESC_def *)((long)_buffer + (long)buffer);
|
|
|
| for (unsigned int i=0; i<_length; i++)
|
| {
|
| perr = _buffer + i;
|
| LONG_swap(&perr->rowId);
|
| LONG_swap(&perr->errorDiagnosticId);
|
| LONG_swap(&perr->sqlcode);
|
| LONG_swap(&perr->operationAbortId);
|
| LONG_swap(&perr->errorCodeType);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+10);
|
| }
|
|
|
| void OUT_CONNECTION_CONTEXT_swap(char* buffer, OUT_CONNECTION_CONTEXT_def *outContext)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+11);
|
| VERSION_LIST_swap(buffer, &outContext->versionList);
|
| SHORT_swap(&outContext->nodeId);
|
| ULONG_swap(&outContext->processId);
|
| SRVRTRACE_EXIT(FILE_SWAP+11);
|
| }
|
|
|
| void SQL_VALUE_LIST_swap(char* buffer, SQLValueList_def *valueList)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+12);
|
|
|
| if (valueList->_buffer != NULL && valueList->_length != 0 )
|
| {
|
| SQLValue_def *_buffer = valueList->_buffer;
|
| IDL_unsigned_long _length = valueList->_length;
|
|
|
| SQLValue_def *pval;
|
| ULONG_swap(&valueList->_length);
|
| _buffer = (SQLValue_def *)((long)_buffer + (long)buffer);
|
|
|
| for (unsigned int i=0; i<_length; i++)
|
| {
|
| SQL_DataValue_def *pdataValue;
|
| pval = _buffer + i;
|
|
|
| LONG_swap(&pval->dataType);
|
| SHORT_swap(&pval->dataInd);
|
| LONG_swap(&pval->dataCharset);
|
|
|
| pdataValue = &pval->dataValue;
|
| ULONG_swap(&pdataValue->_length);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+12);
|
| }
|
|
|
| void SQL_ITEM_DESC_LIST_swap(char* buffer, SQLItemDescList_def *itemList)
|
| {
|
| SRVRTRACE_ENTER(FILE_SWAP+13);
|
|
|
| if (itemList->_buffer != NULL && itemList->_length != 0 )
|
| {
|
| SQLItemDesc_def *_buffer = itemList->_buffer;
|
| IDL_unsigned_long _length = itemList->_length;
|
|
|
| SQLItemDesc_def *pitem;
|
| ULONG_swap(&itemList->_length);
|
| _buffer = (SQLItemDesc_def *)((long)_buffer + (long)buffer);
|
|
|
| for (unsigned int i=0; i<_length; i++)
|
| {
|
| pitem = _buffer + i;
|
|
|
| LONG_swap(&pitem->version);
|
| LONG_swap(&pitem->dataType);
|
| LONG_swap(&pitem->datetimeCode);
|
| LONG_swap(&pitem->maxLen);
|
| SHORT_swap(&pitem->precision);
|
| SHORT_swap(&pitem->scale);
|
| LONG_swap(&pitem->ODBCDataType);
|
| SHORT_swap(&pitem->ODBCPrecision);
|
| LONG_swap(&pitem->SQLCharset);
|
| LONG_swap(&pitem->ODBCCharset);
|
| LONG_swap(&pitem->intLeadPrec);
|
| LONG_swap(&pitem->paramMode);
|
| }
|
| }
|
| SRVRTRACE_EXIT(FILE_SWAP+13);
|
| }
|