src/network/NetworkPacket.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.com   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include <CSql.h>
  21 #include <Network.h>
  22 #include <DataType.h>
  23 #include <SqlLogStatement.h>
  24
  25 DbRetVal PacketPrepare::marshall()
  26 {
  27     printDebug(DM_Network, "PacketPrepare::marshall called\n");
  28     bufferSize  = sizeof(int) * 4 + strlen(stmtString) + 1;
  29     printDebug(DM_Network, "NOOFPARAMS %d buffer size %d\n", noParams, bufferSize);
  30     printDebug(DM_Network, "stmt %s size %d\n", stmtString, strlen(stmtString));
  31     printDebug(DM_Network, "noParams is %d\n", noParams);
  32     if (noParams >0)
  33         bufferSize = bufferSize + 2 * sizeof(int) * noParams;
  34     buffer = (char*) malloc(bufferSize);
  35     *(int*)buffer = stmtID;
  36     char *bufIter = buffer + sizeof(int);
  37     *(int*)bufIter = syncMode;
  38     bufIter = bufIter + sizeof(int);
  39     *(int*)bufIter = strlen(stmtString);
  40     bufIter = bufIter + sizeof(int);
  41     *(int*)bufIter = noParams;
  42     bufIter = bufIter + sizeof(int);
  43     if (noParams >0) {
  44        memcpy(bufIter, type, sizeof(int) * noParams);
  45        bufIter = bufIter + sizeof(int)* noParams;
  46        memcpy(bufIter, length, sizeof(int) * noParams);
  47        bufIter = bufIter + sizeof(int)* noParams;
  48     }
  49     strcpy(bufIter, stmtString);
  50     printDebug(DM_Network, "PacketPrepare::marshall ended\n");
  51     return OK;
  52 }
  53 DbRetVal PacketPrepare::unmarshall()
  54 {
  55     printDebug(DM_Network, "PacketPrepare::unmarshall called\n");
  56     stmtID = *(int*)buffer;
  57     printDebug(DM_Network, "start of the buffer is %x\n", buffer);
  58     char *bufIter = buffer + sizeof (int);
  59     syncMode = *(int*)bufIter;
  60     bufIter = bufIter + sizeof(int);
  61     stmtLength = *(int*)bufIter;
  62     bufIter = bufIter + sizeof(int);
  63     noParams = *(int*)bufIter;
  64     bufIter = bufIter + sizeof(int);
  65     if (noParams >0) {
  66         type = (int*) bufIter;
  67         bufIter = bufIter + sizeof(int) * noParams;
  68         length = (int*) bufIter;
  69         bufIter = bufIter + sizeof(int) * noParams;
  70     }
  71     stmtString = bufIter;
  72     printDebug(DM_Network, "stmtString ptr is %x\n", stmtString);
  73     stmtString[stmtLength+1] = '\0';
  74     printDebug(DM_Network, "PacketPrepare::unmarshall ended\n");
  75     return OK;
  76 }
  77 DbRetVal PacketFree::marshall()
  78 {
  79     bufferSize  = sizeof(int);
  80     buffer = (char*) malloc(bufferSize);
  81     *(int*)buffer = stmtID;
  82     return OK;
  83 }
  84 DbRetVal PacketFree::unmarshall()
  85 {
  86     stmtID = *(int*)buffer;
  87     return OK;
  88 }
  89 void PacketExecute::setParams(List list)
  90 {
  91     paramList = list;
  92     noParams = list.size();
  93     paramValues = new char*[noParams];
  94     BindSqlField* bindField = NULL;
  95     for (int i = 0 ; i < noParams; i++)
  96     {
  97         bindField = (BindSqlField*) paramList.get(i+1);
  98         paramValues[i] = (char*) bindField->value;
  99     }
 100     return;
 101 }
 102 void PacketExecute::setStatementList(List stmtlist)
 103 {
 104     stmtList = stmtlist;
 105     return;
 106 }
 107 DbRetVal PacketExecute::marshall()
 108 {
 109     bufferSize  = sizeof(int)+ sizeof(int);
 110     BindSqlField* bindField = NULL;
 111     for (int i = 0 ; i < noParams; i++)
 112     {
 113         bindField = (BindSqlField*) paramList.get(i+1);
 114         bufferSize = bufferSize + AllDataType::size(bindField->type, bindField->length);
 115     }
 116     buffer = (char*) malloc(bufferSize);
 117     *(int*)buffer = stmtID;
 118     char* bufIter = (char*) buffer + sizeof(int);
 119     *(int*)bufIter = noParams;
 120     bufIter = (char*) bufIter + sizeof(int);
 121     for (int i = 0 ; i < noParams; i++)
 122     {
 123         bindField = (BindSqlField*) paramList.get(i+1);
 124         AllDataType::copyVal(bufIter, bindField->value, bindField->type,bindField->length);
 125         bufIter = bufIter + AllDataType::size(bindField->type, bindField->length);
 126     }
 127     return OK;
 128 }
 129 DbRetVal PacketExecute::unmarshall()
 130 {
 131     stmtID = *(int*)buffer;
 132     char *bufIter = buffer + sizeof(int);
 133     noParams = *(int*)bufIter;
 134     bufIter = bufIter +sizeof(int);
 135     ListIterator stmtIter = stmtList.getIterator();
 136     NetworkStmt *stmt;
 137     while (stmtIter.hasElement())
 138     {
 139        stmt = (NetworkStmt*) stmtIter.nextElement();
 140        //TODO::Also check teh srcNetworkID
 141        if (stmt->stmtID == stmtID ) break;
 142     }
 143     if (noParams == 0) return OK;
 144     paramValues = new char*[noParams];
 145     ListIterator paramIter = stmt->paramList.getIterator();
 146     BindSqlField *bindField = NULL;
 147     for (int i=0; i <noParams; i++)
 148     {
 149         paramValues[i] = bufIter;
 150         bindField = (BindSqlField*) stmt->paramList.get(i+1);
 151         bufIter = bufIter + AllDataType::size(bindField->type, bindField->length);
 152     }
 153     return OK;
 154 }
 155
 156 void PacketCommit::setExecPackets(int tid, List list)
 157 {
 158     txnID = tid;
 159     noOfStmts = list.size();
 160     stmtBufSize = new int[noOfStmts];
 161     stmtBuffer = new char*[noOfStmts];
 162     PacketExecute* pkt = NULL;
 163     int totalSize =0;
 164     for (int i = 0 ; i < noOfStmts; i++)
 165     {
 166         pkt = (PacketExecute*) list.get(i+1);
 167         if (pkt == NULL) printError(ErrSysFatal, "pkt is null.should never happen\n");
 168         stmtBufSize[i] = pkt->getBufferSize();
 169         stmtBuffer[i] = pkt->getMarshalledBuffer();
 170         //                             *(int*)(((char*)stmtBuffer[i]) + 4));
 171         totalSize = totalSize + stmtBufSize[i];
 172     }
 173     totalSize = sizeof(int) + sizeof(int) + noOfStmts * sizeof(int) +
 174                totalSize;
 175     bufferSize = totalSize;
 176     return;
 177 }
 178 DbRetVal PacketCommit::marshall()
 179 {
 180     buffer = (char*) malloc(bufferSize);
 181     *(int*)buffer = txnID;
 182     char* bufIter = (char*) buffer + sizeof(int);
 183     *(int*)bufIter = noOfStmts;
 184     bufIter = (char*) bufIter + sizeof(int);
 185     memcpy(bufIter, stmtBufSize, noOfStmts*sizeof(int));
 186     bufIter = (char*) bufIter + noOfStmts* sizeof(int);
 187     for (int i=0; i < noOfStmts; i++)
 188     {
 189         memcpy(bufIter, stmtBuffer[i], stmtBufSize[i]);
 190         bufIter = bufIter + stmtBufSize[i];
 191     }
 192     return OK;
 193 }
 194 DbRetVal PacketCommit::unmarshall()
 195 {
 196     txnID = *(int*)buffer;
 197     char *bufIter = buffer + sizeof(int);
 198     noOfStmts = *(int*)bufIter;
 199     bufIter = bufIter + sizeof(int);
 200     stmtBufSize = new int[noOfStmts];
 201     memcpy(stmtBufSize, bufIter, noOfStmts*sizeof(int));
 202     bufIter = bufIter + noOfStmts * sizeof(int);
 203     stmtBuffer = new char*[noOfStmts];
 204     for (int i = 0 ; i  <noOfStmts; i++)
 205     {
 206        stmtBuffer[i] = bufIter;
 207        bufIter = bufIter + stmtBufSize[i];
 208     }
 209 }
 210 //call unmarshall  before calling this
 211 void PacketCommit::getExecPacketList(List stmtList, List &list)
 212 {
 213     PacketExecute* pkt = NULL;
 214     for (int i = 0 ; i < noOfStmts; i++)
 215     {
 216         pkt = new PacketExecute();
 217         pkt->setBuffer(stmtBuffer[i]);
 218         pkt->setBufferSize(stmtBufSize[i]);
 219         pkt->setStatementList(stmtList);
 220         pkt->unmarshall();
 221         list.append(pkt);
 222     }
 223
 224 }