src/network/SqlNetworkHandler.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 <os.h>
  21 #include <TableConfig.h>
  22 #include <SqlNetworkHandler.h>
  23 #include <AbsSqlConnection.h>
  24 #include <SqlConnection.h>
  25 #include <SqlOdbcConnection.h>
  26 #include <AbsSqlStatement.h>
  27 #include <SqlStatement.h>
  28 #include <SqlOdbcStatement.h>
  29 #include <SqlLogStatement.h>
  30 #include <Parser.h>
  31
  32 List SqlNetworkHandler::stmtList;
  33 List SqlNetworkHandler::tableNameList;
  34 AbsSqlConnection* SqlNetworkHandler::conn;
  35 SqlApiImplType SqlNetworkHandler::type;
  36 int SqlNetworkHandler::stmtID;
  37 int SqlNetworkHandler::sockfd;
  38
  39 void *SqlNetworkHandler::process(PacketHeader &header, char *buffer)
  40 {
  41     DbRetVal rv = OK;
  42     char *ptr = NULL;
  43     void *rpkt = NULL;
  44     switch(header.packetType)
  45     {
  46         case SQL_NW_PKT_CONNECT:
  47             rpkt = processSqlConnect(header, buffer);
  48             break;
  49         case SQL_NW_PKT_EXECDIRECT:
  50             rpkt = processSqlExecuteDirect(header, buffer);
  51             break;
  52         case SQL_NW_PKT_PREPARE:
  53             rpkt = processSqlPrepare(header, buffer);
  54             break;
  55         case SQL_NW_PKT_EXECUTE:
  56             rpkt = processSqlExecute(header, buffer);
  57             break;
  58         case SQL_NW_PKT_FETCH:
  59             rpkt = processSqlFetch(header);
  60             break;
  61         case SQL_NW_PKT_COMMIT:
  62             rpkt = processSqlCommit(header, buffer);
  63             break;
  64         case SQL_NW_PKT_ROLLBACK:
  65             rpkt = processSqlRollback(header, buffer);
  66             break;
  67         case SQL_NW_PKT_DISCONNECT:
  68             rpkt = processSqlDisconnect(header);
  69             break;
  70         case SQL_NW_PKT_FREE:
  71             rpkt = processSqlFree(header, buffer);
  72             break;
  73         case SQL_NW_PKT_SHOWTABLES:
  74             rpkt = processSqlShowTables(header, buffer);
  75             break;
  76         case SQL_NW_PKT_ISTABLEPRESENT:
  77             rpkt = processSqlIsTablePresent(header, buffer);
  78             break;
  79         case SQL_NW_PKT_GETRECORDS:
  80             rpkt =  processSqlLoadRecords(header, buffer);
  81             break;
  82     }
  83     if (rpkt != NULL) sendResponse(rpkt);
  84     return rpkt;
  85 }
  86
  87 DbRetVal SqlNetworkHandler::sendResponse(void *rpkt)
  88 {
  89     size_t numbytes = os::send(sockfd, rpkt, sizeof(ResponsePacket), 0);
  90     if (numbytes == -1) {
  91         printError(ErrOS, "Error writing to socket\n");
  92         closeConnection();
  93         exit(1);
  94     }
  95     return OK;
  96 }
  97
  98 DbRetVal SqlNetworkHandler::closeConnection()
  99 {
 100     conn->rollback();
 101     return conn->disconnect();
 102 }
 103
 104 void * SqlNetworkHandler::processSqlConnect(PacketHeader &header, char *buffer)
 105 {
 106     ResponsePacket *rpkt = new ResponsePacket();
 107     printDebug(DM_Network, "Processing CONNECT");
 108     SqlPacketConnect *pkt = new SqlPacketConnect();
 109     pkt->setBuffer(buffer);
 110     pkt->setBufferSize(header.packetLength);
 111     pkt->unmarshall();
 112     type = (SqlApiImplType) pkt->sqlApiImplType;
 113     conn = createConnection(type);
 114     char *ptr = (char *) &rpkt->retVal;
 115     DbRetVal rv=conn->connect(pkt->userName, pkt->passWord);
 116     if (rv != OK) {
 117         //*ptr = 0;
 118         rpkt->errRetVal = rv;
 119         fillErrorString(rpkt);
 120         delete pkt;
 121         return rpkt;
 122     }
 123     if (rv == OK) {
 124         //*ptr = 1;
 125         rv = conn->beginTrans();
 126         delete pkt;
 127         return rpkt;
 128     }
 129 }
 130
 131 void * SqlNetworkHandler::processSqlDisconnect(PacketHeader &header)
 132 {
 133     DbRetVal rv = conn->rollback();
 134     rv = conn->disconnect();
 135     ResponsePacket *rpkt = new ResponsePacket();
 136     char *ptr = (char *) &rpkt->retVal;
 137     //*ptr = 1;
 138     strcpy(rpkt->errorString, "Success");
 139     return rpkt;
 140 }
 141
 142 void* SqlNetworkHandler::processSqlExecuteDirect(PacketHeader &header, char *buffer)
 143 {
 144     ResponsePacket *rpkt = new ResponsePacket();
 145     rpkt->isSelect = false;
 146     char *retval = (char *) &rpkt->retVal;
 147     SqlPacketPrepare *pkt = new SqlPacketPrepare();
 148     pkt->setBuffer(buffer);
 149     pkt->setBufferSize(header.packetLength);
 150     pkt->unmarshall();
 151     printDebug(DM_Network, "EXECDIRECT %s\n", pkt->stmtString);
 152     AbsSqlStatement *sqlstmt = createStatement(type);
 153     sqlstmt->setConnection(conn);
 154     NetworkStmt *nwStmt = new NetworkStmt();
 155     nwStmt->stmtID = ++stmtID;
 156     printDebug(DM_Network, "Statement string %s\n", pkt->stmtString);
 157     nwStmt->stmt = sqlstmt;
 158     DbRetVal rv = sqlstmt->executeDirect(pkt->stmtString);
 159     delete pkt;
 160     if (rv != OK)
 161     {
 162         printError(ErrSysInit, "ExecuteDirect failed\n");
 163         rpkt->errRetVal = rv;
 164         fillErrorString(rpkt);
 165         if (rpkt->errorString[0] == '\0')
 166             strcpy(rpkt->errorString, "Prepare failed.");
 167         delete nwStmt;
 168         delete sqlstmt;
 169         return rpkt;
 170     }
 171
 172     stmtList.append(nwStmt);
 173     rpkt->stmtID = nwStmt->stmtID;
 174     strcpy(rpkt->errorString, "Success");
 175     return rpkt;
 176 }
 177
 178 void* SqlNetworkHandler::processSqlPrepare(PacketHeader &header, char *buffer)
 179 {
 180     ResponsePacket *rpkt = new ResponsePacket();
 181     rpkt->isSelect = false;
 182     char *retval = (char *) &rpkt->retVal;
 183     SqlPacketPrepare *pkt = new SqlPacketPrepare();
 184     pkt->setBuffer(buffer);
 185     pkt->setBufferSize(header.packetLength);
 186     pkt->unmarshall();
 187     printDebug(DM_Network, "PREPARE %s\n", pkt->stmtString);
 188     AbsSqlStatement *sqlstmt = createStatement(type);
 189     sqlstmt->setConnection(conn);
 190     NetworkStmt *nwStmt = new NetworkStmt();
 191     nwStmt->stmtID = ++stmtID;
 192     printDebug(DM_Network, "Statement string %s\n", pkt->stmtString);
 193     nwStmt->stmt = sqlstmt;
 194     DbRetVal rv = sqlstmt->prepare(pkt->stmtString);
 195     delete pkt;
 196     if (rv != OK)
 197     {
 198         printError(ErrSysInit, "statement prepare failed\n");
 199         rpkt->errRetVal = rv;
 200         fillErrorString(rpkt);
 201         if (rpkt->errorString[0] == '\0')
 202             strcpy(rpkt->errorString, "Prepare failed.");
 203         delete nwStmt;
 204         delete sqlstmt;
 205         return rpkt;
 206     }
 207     //TODO: need to change retVal name
 208     ResultSetPlan plan = sqlstmt->getResultSetPlan();
 209     *retval = plan;
 210
 211     int param = sqlstmt->noOfParamFields();
 212     int proj = sqlstmt->noOfProjFields();
 213     BindSqlField *bindField = NULL;
 214     BindSqlProjectField *projField = NULL;
 215     //populate paramList
 216     FieldInfo * fInfo = new FieldInfo();
 217     for (int i = 0; i < param; i++) {
 218         bindField = new BindSqlField();
 219         sqlstmt->getParamFldInfo(i + 1, fInfo);
 220         strcpy(bindField->fName, fInfo->fldName);
 221         bindField->type = fInfo->type;
 222         bindField->length = fInfo->length;
 223         bindField->offset = fInfo->offset;
 224         strcpy(bindField->defaultValueBuf, fInfo->defaultValueBuf);
 225         bindField->isNull = fInfo->isNull;
 226         bindField->isPrimary = fInfo->isPrimary;
 227         bindField->isDefault = fInfo->isDefault;
 228         bindField->isUnique = fInfo->isUnique;
 229         bindField->isUnique = fInfo->isUnique;
 230         //bindField->value = AllDataType::alloc(bindField->type, bindField->length);
 231         bindField->value = NULL;
 232         nwStmt->paramList.append(bindField);
 233     }
 234     delete fInfo;
 235     FieldInfo *fldInfo = new FieldInfo();
 236     for (int i = 0; i < proj; i++) {
 237         projField = new BindSqlProjectField();
 238         sqlstmt->getProjFldInfo(i + 1, fldInfo);
 239         strcpy(projField->fName, fldInfo->fldName);
 240         projField->type = fldInfo->type;
 241         projField->length = fldInfo->length;
 242         projField->offset = fldInfo->offset;
 243         strcpy(projField->defaultValueBuf, fldInfo->defaultValueBuf);
 244         projField->aType = fldInfo->aType;
 245         projField->isNull = fldInfo->isNull;
 246         projField->isPrimary = fldInfo->isPrimary;
 247         projField->isDefault = fldInfo->isDefault;
 248         projField->isUnique = fldInfo->isUnique;
 249         projField->value = AllDataType::alloc(projField->type, projField->length);
 250         memset(projField->value, 0, projField->length);
 251         nwStmt->projList.append(projField);
 252     }
 253     delete fldInfo;
 254     stmtList.append(nwStmt);
 255     if(sqlstmt->isSelect()) rpkt->isSelect = true;
 256     if (param) *(retval+2) = 1;
 257     if (proj) *(retval+3) = 1;
 258     rpkt->stmtID = nwStmt->stmtID;
 259     strcpy(rpkt->errorString, "Success");
 260     return rpkt;
 261 }
 262
 263 void * SqlNetworkHandler::processSqlExecute(PacketHeader &header, char *buffer)
 264 {
 265     ResponsePacket *rpkt = new ResponsePacket();
 266     char *retval = (char *) &rpkt->retVal;
 267     SqlPacketExecute *pkt = new SqlPacketExecute();
 268     pkt->setBuffer(buffer);
 269     pkt->setBufferSize(header.packetLength);
 270     pkt->setStatementList(stmtList);
 271     pkt->unmarshall();
 272     printDebug(DM_Network, "EXECUTE %d\n", pkt->stmtID);
 273     rpkt->stmtID = pkt->stmtID;
 274     ListIterator stmtIter = stmtList.getIterator();
 275     NetworkStmt *stmt;
 276     while (stmtIter.hasElement())
 277     {
 278        stmt = (NetworkStmt*) stmtIter.nextElement();
 279        //TODO::Also check the srcNetworkID
 280        if (stmt->stmtID == pkt->stmtID ) break;
 281     }
 282     AbsSqlStatement *sqlstmt = stmt->stmt;
 283     int rows = 0;
 284     char *nullInfo = NULL;
 285     if (pkt->noParams) nullInfo = pkt->getNullInfo();
 286     for (int i=0; i < pkt->noParams; i++) {
 287         BindSqlField *bindField = (BindSqlField *) stmt->paramList.get(i+1);
 288         if (nullInfo[i]) sqlstmt->setNull(i+1);
 289         else setParamValues(sqlstmt, i+1, bindField->type, bindField->length, (char *)bindField->value);
 290     }
 291     //SqlStatement *st = (SqlStatement *)sqlstmt;
 292     if(sqlstmt->isSelect()) {
 293         int noProj = stmt->projList.size();
 294         for (int i=0; i < noProj; i++) {
 295             BindSqlProjectField *prjFld = (BindSqlProjectField *) stmt->projList.get(i+1);
 296             sqlstmt->bindField(i+1, prjFld->value);
 297         }
 298     }
 299     delete pkt;
 300     DbRetVal rv = sqlstmt->execute(rows);
 301     if (rv != OK) {
 302         rpkt->errRetVal = rv;
 303         fillErrorString(rpkt);
 304         return rpkt;
 305     }
 306     rpkt->rows = rows;
 307     strcpy(rpkt->errorString, "Success");
 308     return rpkt;
 309 }
 310
 311 void * SqlNetworkHandler::processSqlFetch(PacketHeader &header)
 312 {
 313     ListIterator stmtIter = stmtList.getIterator();
 314     NetworkStmt *stmt;
 315     SqlPacketResultSet *rspkt = new SqlPacketResultSet();
 316     while (stmtIter.hasElement())
 317     {
 318        stmt = (NetworkStmt*) stmtIter.nextElement();
 319        //TODO::Also check srcNetworkID
 320        if (stmt->stmtID == header.stmtID ) break;
 321     }
 322     printDebug(DM_Network, "FETCH STMTID: %d", stmt->stmtID);
 323     AbsSqlStatement *sqlstmt = stmt->stmt;
 324     void *data=NULL;
 325     int len=1;
 326     DbRetVal rv = OK;
 327     if ((data = sqlstmt->fetch(rv)) != NULL && rv == OK) {
 328         len = 0;//means record is there
 329     }
 330     else if (data == NULL && rv == OK) {
 331         sqlstmt->close();
 332         len =1; //end of resultset
 333     }
 334     else {
 335         len=2;//error
 336     }
 337     rspkt->noProjs = stmt->projList.size();
 338     // set null info for all the fetched field values in projection list
 339     int nullInfoLen = os::align(rspkt->noProjs);
 340     char *nullInfo = (char *) malloc(nullInfoLen);
 341     memset(nullInfo, 0, nullInfoLen);
 342     char *ptr = nullInfo;
 343     ListIterator it = stmt->projList.getIterator();
 344     while (it.hasElement()) {
 345         BindSqlProjectField *prjFld = (BindSqlProjectField *) it.nextElement();
 346         if (sqlstmt->isFldNull(prjFld->fName)) *ptr = 1;
 347         ptr++;
 348     }
 349     rspkt->setNullInfo(nullInfo);
 350     rspkt->setProjList(stmt->projList);
 351     rspkt->marshall();
 352     if (rv != OK) { printf("marshall failed\n"); }
 353
 354     if(len == 0) len = rspkt->getBufferSize();
 355     int numbytes = os::send(sockfd, &len , 4, 0);
 356     if (len == 1 || len == 2) { delete rspkt; ::free (nullInfo); return NULL; }
 357     int dummy =0;
 358     //numbytes = os::recv(sockfd, &dummy, 4, 0);
 359     numbytes = os::send(sockfd,rspkt->getMarshalledBuffer(),
 360                            rspkt->getBufferSize(), 0);
 361     delete rspkt;
 362     if (numbytes == -1) {
 363        printf("Error in sending the row to the client\n");
 364        ::free (nullInfo);
 365        sqlstmt->free();
 366        delete sqlstmt; sqlstmt= NULL;
 367        conn->disconnect();
 368        exit(1);
 369     }
 370     ::free (nullInfo);
 371     return NULL;
 372 }
 373
 374 void * SqlNetworkHandler::processSqlFree(PacketHeader &header, char *buffer)
 375 {
 376     ResponsePacket *rpkt = new ResponsePacket();
 377     char *retval = (char *) &rpkt->retVal;
 378     SqlPacketFree *pkt = new SqlPacketFree();
 379     pkt->setBuffer(buffer);
 380     pkt->unmarshall();
 381     rpkt->stmtID = pkt->stmtID;
 382     ListIterator stmtIter = stmtList.getIterator();
 383     NetworkStmt *stmt = NULL;
 384     while (stmtIter.hasElement())
 385     {
 386        stmt = (NetworkStmt*) stmtIter.nextElement();
 387        //TODO::Also check teh srcNetworkID
 388        if (stmt->stmtID == pkt->stmtID ) break;
 389     }
 390     if (stmt == NULL)
 391     {
 392         printError(ErrWarning, "Statement already freed.");
 393         delete pkt;
 394         rpkt->errRetVal = ErrAlready;
 395         return rpkt;
 396     }
 397     AbsSqlStatement *sqlstmt = stmt->stmt;
 398     if (sqlstmt) sqlstmt->free();
 399     ListIterator itprm = stmt->paramList.getIterator();
 400     BindSqlField *fld = NULL;
 401     while((fld = (BindSqlField *) itprm.nextElement()) != NULL) {
 402         //if (fld->value) free(fld->value); memory never allocated for this
 403         delete fld;
 404     }
 405     stmt->paramList.reset();
 406     ListIterator itprj = stmt->projList.getIterator();
 407     BindSqlProjectField *pfld = NULL;
 408     while((pfld = (BindSqlProjectField *) itprj.nextElement()) != NULL) {
 409        if (pfld->value) free(pfld->value);
 410        delete pfld;
 411     }
 412     stmt->projList.reset();
 413     delete stmt->stmt;
 414     stmt->stmt = NULL;
 415     stmtList.remove(stmt);
 416     delete stmt;
 417     stmt= NULL;
 418     delete pkt;
 419     strcpy(rpkt->errorString, "Success");
 420     return rpkt;
 421 }
 422
 423
 424 void * SqlNetworkHandler::processSqlCommit(PacketHeader &header, char *buffer)
 425 {
 426     ResponsePacket *rpkt = new ResponsePacket();
 427     char *retval = (char *) &rpkt->retVal;
 428     DbRetVal rv = conn->commit();
 429     if (rv != OK) {
 430         rpkt->errRetVal = rv;
 431         strcpy(rpkt->errorString, "Commit failure\n");
 432         return rpkt;
 433     }
 434     rv = conn->beginTrans();
 435     strcpy(rpkt->errorString, "Success");
 436     return rpkt;
 437 }
 438
 439 void *SqlNetworkHandler::processSqlRollback(PacketHeader &header, char *buffer)
 440 {
 441     ResponsePacket *rpkt = new ResponsePacket();
 442     char *retval = (char *) &rpkt->retVal;
 443     DbRetVal rv = conn->rollback();
 444     if (rv != OK) {
 445         rpkt->errRetVal = rv;
 446         strcpy(rpkt->errorString, "Rollback failure\n");
 447         return rpkt;
 448     }
 449     rv = conn->beginTrans();
 450     strcpy(rpkt->errorString, "Success");
 451     return rpkt;
 452 }
 453
 454 void SqlNetworkHandler::setParamValues(AbsSqlStatement *stmt, int parampos, DataType type,
 455                     int length, char *value)
 456 {
 457     switch(type)
 458     {
 459         case typeInt:
 460             stmt->setIntParam(parampos, *(int*)value);
 461             break;
 462         case typeLong:
 463             stmt->setLongParam(parampos, *(long*)value);
 464             break;
 465         case typeLongLong:
 466             stmt->setLongLongParam(parampos, *(long long*)value);
 467             break;
 468         case typeShort:
 469             stmt->setShortParam(parampos, *(short*)value);
 470             break;
 471         case typeByteInt:
 472             stmt->setByteIntParam(parampos, *(char*)value);
 473             break;
 474         case typeDouble:
 475             stmt->setDoubleParam(parampos, *(double*)value);
 476             break;
 477         case typeFloat:
 478             stmt->setFloatParam(parampos, *(float*)value);
 479             break;
 480         case typeDate:
 481             stmt->setDateParam(parampos, *(Date*)value);
 482             break;
 483         case typeTime:
 484             stmt->setTimeParam(parampos, *(Time*)value);
 485             break;
 486         case typeTimeStamp:
 487             stmt->setTimeStampParam(parampos, *(TimeStamp*)value);
 488             break;
 489         case typeString:
 490             {
 491                 char *d =(char*)value;
 492                 d[length-1] = '\0';
 493                 stmt->setStringParam(parampos, (char*)value);
 494                 break;
 495             }
 496         case typeBinary:
 497             stmt->setBinaryParam(parampos, (char *) value, length);
 498             break;
 499     }
 500     return;
 501 }
 502
 503 AbsSqlConnection * SqlNetworkHandler::createConnection(SqlApiImplType type)
 504 {
 505     AbsSqlConnection *con = NULL;
 506     switch(type) {
 507         case CSqlNetwork:
 508             con = SqlFactory::createConnection(CSql);
 509             break;
 510         case CSqlNetworkAdapter:
 511             con = SqlFactory::createConnection(CSqlAdapter);
 512             break;
 513         case CSqlNetworkGateway:
 514             con = SqlFactory::createConnection(CSqlGateway);
 515             break;
 516         default:
 517             return NULL;
 518     }
 519     return con;
 520 }
 521
 522 AbsSqlStatement * SqlNetworkHandler::createStatement(SqlApiImplType type)
 523 {
 524     AbsSqlStatement *stmt = NULL;
 525     switch(type) {
 526         case CSqlNetwork:
 527             stmt = SqlFactory::createStatement(CSql);
 528             break;
 529         case CSqlNetworkAdapter:
 530             stmt = SqlFactory::createStatement(CSqlAdapter);
 531             break;
 532         case CSqlNetworkGateway:
 533             stmt = SqlFactory::createStatement(CSqlGateway);
 534             break;
 535         default:
 536             return NULL;
 537     }
 538     return stmt;
 539 }
 540
 541 void * SqlNetworkHandler::processSqlShowTables(PacketHeader &header, char *buffer)
 542 {
 543     ResponsePacket *rpkt = new ResponsePacket();
 544     rpkt->isSelect = false;
 545     char *retval = (char *) &rpkt->retVal;
 546     AbsSqlStatement *sqlstmt = createStatement(type);
 547     sqlstmt->setConnection(conn);
 548     DbRetVal rv = OK;
 549     tableNameList = sqlstmt->getAllTableNames(rv);
 550     rpkt->errRetVal = rv;
 551     rpkt->rows = tableNameList.size();
 552     strcpy(rpkt->errorString, "Success");
 553     delete sqlstmt;
 554     return rpkt;
 555 }
 556
 557 //only csql connection asks for this with or without durability.
 558 void *SqlNetworkHandler::processSqlIsTablePresent(PacketHeader &header, char *buffer)
 559 {
 560     ResponsePacket *rpkt = new ResponsePacket();
 561     rpkt->isSelect = false;
 562     SqlPacketIsTablePresent *pkt = new SqlPacketIsTablePresent();
 563     pkt->setBuffer(buffer);
 564     pkt->unmarshall();
 565     SqlStatement *sqlstmt = new SqlStatement();
 566     SqlConnection *sqlcon = NULL;
 567     if (Conf::config.useDurability())
 568         sqlcon = (SqlConnection *) conn->getInnerConnection();
 569     else sqlcon = (SqlConnection *) conn;
 570     sqlstmt->setSqlConnection(sqlcon);
 571     DbRetVal rv = OK; bool found = false;
 572     tableNameList = sqlstmt->getAllTableNames(rv);
 573     ListIterator it = tableNameList.getIterator();
 574     while (it.hasElement()) {
 575         Identifier *elem = (Identifier *) it.nextElement();
 576         if (strcmp(elem->name, pkt->tblName) == 0) {
 577             found = true;
 578             break;
 579         }
 580     }
 581     rpkt->errRetVal = rv;
 582     if (!found) {
 583         rpkt->errRetVal = ErrNotFound;
 584         strcpy(rpkt->errorString, "Table Not found.");
 585     }
 586     ListIterator tblIter = SqlNetworkHandler::tableNameList.getIterator();
 587     while (tblIter.hasElement()) delete tblIter.nextElement();
 588     SqlNetworkHandler::tableNameList.reset();
 589     delete pkt;
 590     delete sqlstmt;
 591     return rpkt;
 592 }
 593
 594 //only csql connection asks for this with or without durability.
 595 void *SqlNetworkHandler::processSqlLoadRecords(PacketHeader &header, char *buffer)
 596 {
 597     ResponsePacket *rpkt = new ResponsePacket();
 598     rpkt->isSelect = false;
 599     char *retval = (char *) &rpkt->retVal;
 600     SqlPacketGetRecords *pkt = new SqlPacketGetRecords();
 601     pkt->setBuffer(buffer);
 602     pkt->unmarshall();
 603     SqlStatement *sqlstmt = new SqlStatement();
 604     SqlConnection *sqlcon = NULL;
 605     if (Conf::config.useDurability())
 606         sqlcon = (SqlConnection *) conn->getInnerConnection();
 607     else sqlcon = (SqlConnection *) conn;
 608     sqlstmt->setSqlConnection(sqlcon);
 609     DbRetVal rv = OK;
 610     int pages = sqlstmt->getNoOfPagesForTable(pkt->tblName);
 611     printDebug(DM_Network, "No of pages to be shipped: %d", pages);
 612     rpkt->rows = pages;
 613     strcpy(rpkt->errorString, pkt->tblName);
 614     delete pkt;
 615     delete sqlstmt;
 616     return rpkt;
 617 }
 618
 619 void SqlNetworkHandler::fillErrorString(ResponsePacket *rpkt)
 620 {
 621     switch(rpkt->errRetVal) {
 622         case ErrNoConnection:
 623             strcpy(rpkt->errorString, "Connection not open.");
 624             break;
 625         case ErrUnique:
 626             strcpy(rpkt->errorString, "Unique constraint violation");
 627             break;
 628         case ErrNullViolation:
 629             strcpy(rpkt->errorString, "Not null constraint violation");
 630             break;
 631     }
 632 }
 633
 634 DbRetVal SqlNetworkHandler::servePacket(PacketHeader &header, void *respkt)
 635 {
 636     ResponsePacket *rpkt = (ResponsePacket *) respkt;
 637     DbRetVal rv = OK;
 638     int params=0;
 639     int proj=0;
 640     NetworkStmt *stmt=NULL;
 641
 642     if (header.packetType == SQL_NW_PKT_ISTABLEPRESENT ||
 643                       header.packetType == SQL_NW_PKT_EXECDIRECT ) {
 644         delete rpkt;
 645         return OK;
 646     }
 647     char *ptr = (char *)&rpkt->retVal;
 648     /*if (*ptr==0) {
 649         delete rpkt;
 650         return OK;
 651     }*/
 652     if (rpkt->errRetVal) {
 653         delete rpkt;
 654         return OK;
 655     }
 656     params =  *(ptr + 2);
 657     proj = *(ptr + 3);
 658     if ((header.packetType == SQL_NW_PKT_PREPARE && params != 0) ||
 659                       (header.packetType == SQL_NW_PKT_PREPARE && proj != 0)) {
 660         if (params) {
 661             SqlPacketParamMetadata *prmpkt = new SqlPacketParamMetadata();
 662             prmpkt->stmtID = rpkt->stmtID;
 663             ListIterator stmtIter = SqlNetworkHandler::stmtList.getIterator();
 664             while (stmtIter.hasElement()) {
 665                 stmt = (NetworkStmt*) stmtIter.nextElement();
 666                 if (stmt->stmtID == prmpkt->stmtID) break;
 667             }
 668             prmpkt->noParams = stmt->paramList.size();
 669             rv = prmpkt->marshall();
 670             rv = send(SQL_NW_PKT_PARAM_METADATA, prmpkt->getMarshalledBuffer(), prmpkt->getBufferSize());
 671             delete prmpkt;
 672             if (rv != OK) {
 673                 printf("Error in sending the metadata to the client\n");
 674                 closeConnection();
 675                 exit(1);
 676             }
 677         }
 678         if (proj) {
 679             //fill projection list and send it to client
 680             SqlPacketProjMetadata *prjpkt = new SqlPacketProjMetadata();
 681             prjpkt->stmtID = rpkt->stmtID;
 682             ListIterator stmtIter = SqlNetworkHandler::stmtList.getIterator();
 683             while (stmtIter.hasElement()) {
 684                 stmt = (NetworkStmt*) stmtIter.nextElement();
 685                 if (stmt->stmtID == prjpkt->stmtID) break;
 686             }
 687             prjpkt->noProjs = stmt->projList.size();
 688             rv = prjpkt->marshall();
 689             rv = send(SQL_NW_PKT_PROJ_METADATA, prjpkt->getMarshalledBuffer(), prjpkt->getBufferSize());
 690             delete prjpkt;
 691             if (rv != OK) {
 692                 printf("Error in sending the metadata to the client\n");
 693                 closeConnection();
 694                 exit(1);
 695             }
 696         }
 697     }
 698     else if (header.packetType == SQL_NW_PKT_SHOWTABLES) {
 699         SqlPacketShowTables *shTblPkt = new SqlPacketShowTables();
 700         shTblPkt->numOfTables = rpkt->rows;
 701         rv = shTblPkt->marshall();
 702         if (rv != OK) { printf("marshall failed\n"); }
 703         ListIterator tblIter = SqlNetworkHandler::tableNameList.getIterator();
 704         while (tblIter.hasElement()) delete tblIter.nextElement();
 705         SqlNetworkHandler::tableNameList.reset();
 706         rv = send(SQL_NW_PKT_SHOWTABLES, shTblPkt->getMarshalledBuffer(), shTblPkt->getBufferSize());
 707         delete shTblPkt;
 708         if (rv != OK) {
 709             printError(ErrOS, "Error in sending the metadata to the client\n");
 710             closeConnection();
 711             exit(1);
 712         }
 713     }
 714     else if (header.packetType == SQL_NW_PKT_GETRECORDS) {
 715         if (!rpkt->rows) return OK;
 716         SqlPacketLoadRecords *pkt = new SqlPacketLoadRecords();
 717         pkt->setPages(rpkt->rows);
 718         pkt->marshall();
 719         SqlStatement *sqlstmt = new SqlStatement();
 720         SqlConnection *sqlcon = NULL;
 721         if (Conf::config.useDurability())
 722             sqlcon = (SqlConnection *) conn->getInnerConnection();
 723         else sqlcon = (SqlConnection *) conn;
 724         sqlstmt->setSqlConnection(sqlcon);
 725         sqlstmt->loadRecords(&rpkt->errorString[0], pkt->getMarshalledBuffer());
 726         char *buf = pkt->getMarshalledBuffer();
 727         rv = send(SQL_NW_PKT_LOADRECORDS, pkt->getMarshalledBuffer(), pkt->getBufferSize());
 728         delete pkt;
 729         delete sqlstmt;
 730         if (rv != OK) {
 731             printf("Error in sending the metadata to the client\n");
 732             closeConnection();
 733             exit(1);
 734         }
 735     }
 736     else if (header.packetType == SQL_NW_PKT_DISCONNECT) exit(0);
 737     if (rpkt) { delete rpkt; rpkt = NULL; }
 738     return OK;
 739 }
 740
 741 DbRetVal SqlNetworkHandler::send(NetworkPacketType type, char *buf, int len)
 742 {
 743     DbRetVal rv = OK;
 744     PacketHeader *hdr=  new PacketHeader();
 745     hdr->packetType = type;
 746     hdr->packetLength = len;
 747     hdr->srcNetworkID = 0;//networkid;
 748     hdr->version = 1;
 749     int numbytes=0;
 750     if ((numbytes=os::send(sockfd, hdr, sizeof(PacketHeader), 0)) == -1) {
 751         printError(ErrOS, "Unable to send the packet\n");
 752         return ErrOS;
 753     }
 754     if ((numbytes=os::send(sockfd, buf, len, 0)) == -1) {
 755         printError(ErrOS, "Unable to send the packet\n");
 756         return ErrOS;
 757     }
 758     delete hdr;
 759     return rv;
 760 }