src/multirat_file_thread.c

   1 #include "multirat_conf.h"
   2 #include "multirat_process.h"
   3 #include "multirat_libapi.h"
   4 #include "multirat_range_request_thread.h"
   5 #include "multirat_connection.h"
   6 #include "multirat_file_manager.h"
   7 #include "multirat_file_buffer.h"
   8 #include "multirat_decode_http.h"
   9 #include "multirat_file_thread.h"
  10 #include "multirat_watch_dog_thread.h"
  11
  12 #include <sys/time.h>
  13
  14 void file_thread_init(fileThread *fThread, SmartBondingData *SBData, fileStream *fStream)
  15 {
  16         TIZEN_LOGD("File Thread Init");
  17         fThread->pthreadId = 0;
  18         fThread->compRspRcvdFlag = &(fStream->compRspRcvdFlag);
  19         fThread->compRspLen = SBData->resp.cLen ;
  20         fThread->contRngLen = SBData->resp.instanceSize;
  21         fThread->SBData = SBData;
  22         fThread->conn = &SBData->conn;
  23         fThread->socketId = -1;
  24         fThread->fileMgr = fStream->fileMgr;
  25         fThread->firstRngStatus = FIRST_RSP_STATUS_PENDING;
  26 }
  27
  28 uint32 file_thread_start(fileThread *fThread)
  29 {
  30         uint32 multiThreadStarted = B_TRUE;
  31         if(0 != pthread_create(&fThread->pthreadId, NULL, &FileThreadCallBack, fThread))
  32         {
  33                 TIZEN_LOGD("File thread failed");
  34                 multiThreadStarted = B_FALSE;
  35         }
  36         return multiThreadStarted;
  37 }
  38
  39 void *FileThreadCallBack(void *ptr)
  40 {
  41         fileThread *fileReq = (fileThread*)ptr;
  42         file_thread_run(fileReq);
  43         return NULL;
  44 }
  45
  46 void file_thread_run(fileThread *fThread)
  47 {
  48         int8 *newRequest = NULL;
  49         int8 tempBuff[2*MAX_BLOCK_SIZE] = {0};
  50         int8 rcvBuff[MAX_HEADER_SIZE + 1] = {0};
  51         int32 headerRcvd = B_FALSE;
  52         int32 IOException = B_TRUE;
  53         int32 FIRST_TIME = B_TRUE;
  54         int64 chunkInfo[CHUNK_INFO_SIZE] ={0};
  55         uint32 reqLen = 0;
  56         uint32 minBlockLen = MIN_BLOCK_SIZE;
  57         uint32 ifCount = 0;
  58         uint32 connClose = 0;
  59         uint32 ifaceidx = fThread->interface_index;
  60         uint64 currChunkLen = 0;
  61         uint64 rcvdLen = 0;
  62         uint64 blockOffset = 0;
  63         uint32 status = 0;
  64         uint64 blockLen = 0;
  65         int32 lengthRcvd = 0;
  66         fileBuffer *fbuffer = NULL;
  67         fThread->status = FILE_START;
  68         SmartBondingData *SBData = NULL;
  69         fileManager *fileMgr = fThread->fileMgr;
  70         SBData = fThread->SBData;
  71         TIZEN_LOGD("File Thread Main");
  72
  73         while(*fThread->compRspRcvdFlag)
  74         {
  75                 int32 return_val = 0;
  76
  77                 fThread->interface_index =  file_manager_get_file_thread_interface(fileMgr);
  78                 ifaceidx = fThread->interface_index;
  79                 TIZEN_LOGD("Interface Index [%d]", fThread->interface_index );
  80
  81                 if (IOException == B_TRUE)
  82                 {
  83                         int32 retval = 0;
  84
  85                         retval = file_thread_handleIOExp(fThread,&ifCount,SBData->conn.ip_family);
  86
  87                         if(THREAD_EXIT == retval)
  88                         {
  89                                 break;
  90                         }
  91                         else if (THREAD_CONTINUE == retval)
  92                         {
  93                                 sleep(1);
  94                                 continue;
  95                         }
  96                 }
  97
  98                 fbuffer = file_manager_getNextChunkForFileThread(chunkInfo, SBData);
  99
 100                 if(NULL == fbuffer)
 101                 {
 102                         break;
 103                 }
 104
 105                 fThread->status = FILE_START;
 106                 fThread->interface_index =  file_manager_get_file_thread_interface(fileMgr);
 107
 108                 if(fbuffer->fThread_read != FILE_THREAD_SOCK_READ)
 109                 {
 110                         if(ifaceidx != fThread->interface_index)
 111                         {
 112                                 int32 retval = 0;
 113
 114                                 retval = file_thread_handleIOExp(fThread,&ifCount,SBData->conn.ip_family);
 115
 116                                 if(THREAD_EXIT == retval)
 117                                 {
 118                                         break;
 119                                 }
 120                                 else if (THREAD_CONTINUE == retval)
 121                                 {
 122                                         sleep(1);
 123                                         continue;
 124                                 }
 125                         }
 126                         ifaceidx = fThread->interface_index ;
 127
 128                         if((FIRST_TIME != B_TRUE))
 129                         {
 130                                 return_val = file_thread_connet_server_interface(fThread);
 131                                 if(THREAD_EXIT == return_val)
 132                                 {
 133                                         break;
 134                                 }
 135                                 else if (THREAD_CONTINUE == return_val)
 136                                 {
 137                                         sleep(1);
 138                                         continue;
 139                                 }
 140
 141                                 fThread->req = SBData->req.request[ifaceidx] ;
 142                                 fThread->headerLen = strlen(SBData->req.request[ifaceidx]);
 143
 144                                 if(newRequest != NULL)
 145                                         free(newRequest);
 146
 147                                 newRequest = (int8 *)malloc(fThread->headerLen + MAX_RANGE_FIELD_LEN);
 148                                 if(NULL == newRequest)
 149                                 {
 150                                         return;
 151                                 }
 152
 153                                 memset(newRequest,0,(fThread->headerLen + MAX_RANGE_FIELD_LEN));
 154                                 reqLen = file_thread_rebuildReq(newRequest, chunkInfo, fThread);
 155
 156                                 SECURE_DB_INFO("In file thread New Request [%s]",newRequest) ;
 157
 158                                 if(-1 == send(fThread->socketId,newRequest,reqLen,0))
 159                                 {
 160                                         TIZEN_LOGD("Sending of HTTP Req from File Thread Failed");
 161                                         break;
 162                                 }
 163                                 headerRcvd = B_FALSE;
 164                         }
 165                         else
 166                         {
 167                                 int32 result = -1;
 168                                 TIZEN_LOGD("First Time File Thread Connection");
 169                                 result = file_thread_FirstConnection(fThread->SBData, fThread, chunkInfo, rcvBuff, &lengthRcvd);
 170                                 return_val = file_thread_connect_server_interface_first(result, fThread);
 171                                 if(THREAD_EXIT == return_val)
 172                                 {
 173                                         break;
 174                                 }
 175                                 else if (THREAD_CONTINUE == return_val)
 176                                 {
 177                                         sleep(1);
 178                                         continue;
 179                                 }
 180                                 headerRcvd = B_FALSE;
 181                         }
 182                         fbuffer->socketId = fThread->socketId ;
 183                 }
 184                 else
 185                 {
 186                         fThread->socketId = fbuffer->socketId;
 187                         headerRcvd = B_TRUE;
 188                 }
 189                 currChunkLen = chunkInfo[1] - chunkInfo[0] + 1;
 190                 TIZEN_LOGD("File Thread Interface Index [%d]",fThread->interface_index);
 191                 TIZEN_LOGD("currChunkLen [%llu]",currChunkLen);
 192                 IOException = B_FALSE;
 193                 minBlockLen = MIN_BLOCK_SIZE;
 194                 rcvdLen = 0;
 195
 196                 while(rcvdLen < currChunkLen && *fThread->compRspRcvdFlag)
 197                 {
 198                         blockOffset = 0;
 199                         status = 0;
 200                         blockLen = MIN(minBlockLen, currChunkLen - rcvdLen);
 201                         minBlockLen = MIN((2*MAX_BLOCK_SIZE),(minBlockLen << 2));
 202                         memset(tempBuff,0,2*MAX_BLOCK_SIZE);
 203
 204                         /*If  Main thread Read stops for more than 2 sec , file thread stops reading */
 205                         if(SBData->read_state_check == MAIN_SOCK_READ_INACTIVE)
 206                         {
 207                                 usleep(10000);
 208                                 continue;
 209                         }
 210
 211                         TIZEN_LOGD("File Thread Total Len [%llu] received [%llu] Block Len [%llu]",file_buffer_getTotalLen(fbuffer), rcvdLen, blockLen);
 212                         status = file_manager_check_main_thread_status(fileMgr);
 213                         if((status == MAIN_IO_EXCEPTION) && (SBData->file_status != NO_REDIVISION))
 214                         {
 215                                 TIZEN_LOGD("IO Exception of Main Socket");
 216                                 fThread->status = FILE_IO_EXCEPTION;
 217                                 fbuffer->state = NODE_STATE_BLOCKED;
 218                                 IOException = B_TRUE;
 219                                 break;
 220                         }
 221                         else if((status == MAIN_COMPLETE)&& (SBData->file_status != NO_REDIVISION))
 222                         {
 223                                 TIZEN_LOGD("Main Thread is Completed");
 224                                 fThread->status = MAIN_COMPLETE;
 225                                 fbuffer->state = NODE_STATE_BLOCKED;
 226                                 IOException = B_TRUE;
 227                                 break;
 228                         }
 229                         if(B_FALSE == headerRcvd)
 230                         {
 231                                 int32 retval = HTTP_RSP_DECODING_ERROR;
 232                                 if(FIRST_TIME == B_TRUE)
 233                                 {
 234                                         retval = file_thread_range_request_recv_rng_rsp_headers_first_req(&blockOffset, tempBuff, currChunkLen, &connClose, fThread, rcvBuff, lengthRcvd);
 235                                         FIRST_TIME = B_FALSE;
 236                                 }
 237                                 else
 238                                         retval = file_thread_range_request_recv_rng_rsp_headers(&blockOffset, tempBuff, currChunkLen, &connClose, fThread);
 239                                 if(HTTP_RSP_DECODING_SUCCESS != retval)
 240                                 {
 241                                         if((fThread->firstRngStatus == FIRST_RSP_STATUS_PENDING)
 242                                                         && (retval == HTTP_RSP_DECODING_ERROR))
 243                                         {
 244                                                 TIZEN_LOGD("First Response failed");
 245                                                 *fThread->compRspRcvdFlag = 0;
 246                                                 fThread->firstRngStatus = FIRST_RSP_STATUS_FAILED;
 247                                         }
 248                                         else
 249                                         {
 250                                                 IOException = B_TRUE;
 251                                                 TIZEN_LOGD("File Thread got Exception during recv headers");
 252                                         }
 253                                         break;
 254                                 }
 255                                 else
 256                                 {
 257                                         headerRcvd = B_TRUE;
 258                                         if(fThread->firstRngStatus == FIRST_RSP_STATUS_PENDING)
 259                                         {
 260                                                 fThread->firstRngStatus = FIRST_RSP_STATUS_SUCCESS;
 261                                                 TIZEN_LOGD("First Response Success");
 262                                         }
 263                                         if(blockOffset > 0)
 264                                         {
 265                                                 uint64 temp_history = 0;
 266                                                 uint64 temp_data = 0;
 267                                                 speedStat *sStat = &(SBData->sStat);
 268                                                 file_buffer_add(fbuffer, tempBuff, blockOffset, chunkInfo, rcvdLen, SBData);
 269                                                 if(SBData->bRafMode)
 270                                                 {
 271                                                         sprintf(SBData->FileData,"%lld-%llu",chunkInfo[0],file_buffer_getOffset(fbuffer));
 272                                                 }
 273                                                 rcvdLen = rcvdLen + blockOffset;
 274
 275                                                 temp_data = sStat->recv_length[fThread->interface_index];
 276                                                 sStat->recv_length[fThread->interface_index] = sStat->recv_length[fThread->interface_index] + blockOffset;
 277                                                 if(sStat->start_recv_time[fThread->interface_index] == 0)
 278                                                         sStat->start_recv_time[fThread->interface_index] = get_time_in_microsec();
 279                                                 sStat->prev_recv_time[fThread->interface_index] = get_time_in_microsec();
 280                                                 temp_history = (sStat->prev_recv_time[fThread->interface_index] - sStat->start_recv_time[fThread->interface_index])/1000000;
 281                                                 if((sStat->timeArray[fThread->interface_index] < (MAX_HISTORY)) && (temp_history < MAX_HISTORY) && (temp_history > sStat->timeArray[fThread->interface_index]))
 282                                                 {
 283                                                         int i = 0;
 284                                                         sStat->dataArray[fThread->interface_index][temp_history] = sStat->recv_length[fThread->interface_index];
 285                                                         for( i = sStat->timeArray[fThread->interface_index] + 1 ;  i < temp_history; i++)
 286                                                         {
 287                                                                 sStat->dataArray[fThread->interface_index][i] = temp_data;
 288                                                         }
 289                                                         sStat->timeArray[fThread->interface_index] = temp_history;
 290                                                         TIZEN_LOGD("Data History Time [%llu] Data [%llu]", temp_history, sStat->dataArray[fThread->interface_index][temp_history]);
 291                                                         TIZEN_LOGD("temp_hist [%llu] tdata [%llu] Data [%llu]", temp_history, temp_data, sStat->dataArray[fThread->interface_index][temp_history]);
 292                                                 }
 293                                                 TIZEN_LOGD("File Thread Total Len [%llu] received [%llu] Block Len [%llu]",file_buffer_getTotalLen(fbuffer), rcvdLen, blockLen);
 294                                         }
 295                                 }
 296                         }
 297                         else
 298                         {
 299                                 int32 lenRcvd = 0;
 300                                 while(blockOffset != blockLen)
 301                                 {
 302                                         if (file_thread_conn_poll(fThread->socketId, SBData) <= 0)
 303                                         {
 304                                                 TIZEN_LOGD("File Thread Fail Polling");
 305                                                 IOException = B_TRUE;
 306                                                 break;
 307                                         }
 308                                         //sleep(1);
 309                                         lenRcvd = recv(fThread->socketId, tempBuff+blockOffset, blockLen-blockOffset,0);
 310                                         if((lenRcvd == -1) || (lenRcvd == 0))
 311                                         {
 312                                                 break;
 313                                         }
 314                                         else if(lenRcvd > 0)
 315                                         {
 316                                                 blockOffset = blockOffset + lenRcvd;
 317                                                 uint64 temp_history = 0;
 318                                                 uint64 temp_data = 0;
 319                                                 speedStat *sStat = &(SBData->sStat);
 320                                                 temp_data = sStat->recv_length[fThread->interface_index];
 321
 322                                                 sStat->recv_length[fThread->interface_index] = sStat->recv_length[fThread->interface_index] + lenRcvd;
 323
 324                                                 if(sStat->start_recv_time[fThread->interface_index] == 0)
 325                                                         sStat->start_recv_time[fThread->interface_index] = get_time_in_microsec();
 326
 327                                                 sStat->prev_recv_time[fThread->interface_index] = get_time_in_microsec();
 328
 329                                                 temp_history = (sStat->prev_recv_time[fThread->interface_index] - sStat->start_recv_time[fThread->interface_index])/1000000;
 330                                                 if((sStat->timeArray[fThread->interface_index] < (MAX_HISTORY)) && (temp_history < MAX_HISTORY) && (temp_history > sStat->timeArray[fThread->interface_index]))
 331                                                 {
 332                                                         int i = 0;
 333                                                         sStat->dataArray[fThread->interface_index][temp_history] = sStat->recv_length[fThread->interface_index];
 334                                                         for( i = sStat->timeArray[fThread->interface_index] + 1 ;  i < temp_history; i++)
 335                                                         {
 336                                                                 sStat->dataArray[fThread->interface_index][i] = temp_data;
 337                                                         }
 338                                                         sStat->timeArray[fThread->interface_index] = temp_history;
 339                                                         TIZEN_LOGD("idx [%d] Data History Time [%llu] Data [%llu]", fThread->interface_index, temp_history, sStat->dataArray[fThread->interface_index][temp_history]);
 340                                                 }
 341                                         }
 342                                 }
 343                                 if(blockOffset != blockLen)
 344                                 {
 345                                         /* IO Exception */
 346                                         TIZEN_LOGD("File Thread  IOException during read");
 347                                         IOException = B_TRUE;
 348                                         break;
 349                                 }
 350                                 else
 351                                 {
 352                                         TIZEN_LOGD("File Buffer Write [%x]", fbuffer);
 353                                         //file_buffer_add(fbuffer, tempBuff, blockOffset);
 354                                         file_buffer_add(fbuffer, tempBuff, blockOffset,chunkInfo,rcvdLen,SBData);
 355
 356                                         if(SBData->bRafMode)
 357                                         {
 358                                                 sprintf(SBData->FileData,"%lld-%llu",chunkInfo[0],file_buffer_getOffset(fbuffer));
 359                                         }
 360                                         rcvdLen = rcvdLen + blockOffset;
 361                                         TIZEN_D_LOGD("File Thread Total Len [%llu] received [%llu] Block Len [%llu]", file_buffer_getTotalLen(fbuffer), rcvdLen, blockLen);
 362                                 }
 363                         }
 364                 }
 365                 if((IOException == B_TRUE) && (file_buffer_getTotalLen(fbuffer) != rcvdLen))
 366                 {
 367                         fbuffer->state = NODE_STATE_BLOCKED;
 368                         IOException = B_TRUE;
 369                         if(SBData->file_status == NO_REDIVISION)
 370                         {
 371                                 TIZEN_LOGD("Close Socket ID As Exception and No Redivision");
 372                                 fThread->status = FILE_IO_EXCEPTION;
 373                                 CLOSE_SOCKET(fbuffer->socketId);
 374                                 fbuffer->socketId = 0;
 375                                 fThread->socketId = 0;
 376                         }
 377                         else if((fThread->SBData->status == MAIN_COMPLETE))
 378                         {
 379                                 TIZEN_LOGD("Dont Close Socket ID As Main Complete");
 380                                 if(blockOffset > 0)
 381                                 {
 382                                         TIZEN_LOGD("File Buffer Write [%x] Data Length [%llu]", fbuffer, blockOffset);
 383                                         file_buffer_add(fbuffer, tempBuff, blockOffset,chunkInfo,rcvdLen,SBData);
 384                                         if(SBData->bRafMode)
 385                                         {
 386                                                 sprintf(SBData->FileData,"%lld-%llu",chunkInfo[0],file_buffer_getOffset(fbuffer));
 387                                         }
 388                                 }
 389                                 fThread->status = MAIN_COMPLETE;
 390                         }
 391                         else
 392                         {
 393                                 TIZEN_LOGD("Close Socket ID As Exception and Main is not Complete");
 394                                 fThread->status = FILE_IO_EXCEPTION;
 395                                 CLOSE_SOCKET(fbuffer->socketId);
 396                                 fbuffer->socketId = -1;
 397                                 fThread->socketId = -1;
 398                         }
 399
 400                         TIZEN_LOGD("File Thread Interupted Download FILE NODE [%x] Total length [%llu] Received [%llu]", fbuffer, file_buffer_getTotalLen(fbuffer), file_buffer_getOffset(fbuffer));
 401                 }
 402                 else
 403                 {
 404                         fThread->status = FILE_COMPLETE; // Means here it is complete
 405                         TIZEN_LOGD("File Thread Finished Downloading FILE NODE [%x] Total length [%llu] Received [%llu]", fbuffer, file_buffer_getTotalLen(fbuffer), file_buffer_getOffset(fbuffer));
 406
 407                         if(fThread->SBData->file_status == NO_REDIVISION)
 408                                 *fThread->compRspRcvdFlag = 0;
 409
 410                         if(NULL == fbuffer->next)
 411                         {
 412                                 TIZEN_LOGD("Close Socket ID as No Available Buffer");
 413                                 CLOSE_SOCKET(fbuffer->socketId);
 414                                 fbuffer->socketId = -1;
 415                                 fThread->socketId = -1;
 416                                 fThread->status = FILE_COMPLETE;
 417                                 IOException = B_TRUE;
 418                         }
 419                         if(NULL != fbuffer->next && fThread->socketId != file_buffer_getSocketId(fbuffer->next))
 420                         {
 421                                 TIZEN_LOGD("Close Socket ID as Next Avalaible Buffer Socket is Not Same");
 422                                 CLOSE_SOCKET(fbuffer->socketId);
 423                                 fbuffer->socketId = -1;
 424                                 fThread->socketId = -1;
 425                                 fThread->status = FILE_COMPLETE;
 426                                 IOException = B_TRUE;
 427                         }
 428                 }
 429         }
 430         TIZEN_LOGD("Exiting FILE THREAD");
 431         if(NULL != newRequest)
 432         {
 433                 free(newRequest);
 434                 newRequest = NULL;
 435         }
 436         TIZEN_LOGD("Exiting FILE THREAD ...");
 437 }
 438
 439
 440 int file_thread_handleIOExp(fileThread *fThread, uint32 *ifCount,int iptype)
 441 {
 442         /* Check if interface is available */
 443         if (!connection_is_ifaceup(fThread->interface_index, fThread->conn->ifaceInfo,iptype))
 444         {
 445                 if((fThread->firstRngStatus == FIRST_RSP_STATUS_PENDING) && (*ifCount++ > 2))
 446                 {
 447                         fThread->firstRngStatus = FIRST_RSP_STATUS_FAILED;
 448                         *(fThread->compRspRcvdFlag) = 0;
 449                         TIZEN_LOGD("First Response Failed for File ThreadId");
 450                         return THREAD_EXIT;
 451                 }
 452                 else
 453                 {
 454                         return THREAD_CONTINUE;
 455                 }
 456         }
 457         /* IOException case */
 458         return 0;
 459 }
 460
 461
 462 int file_thread_connect_server_interface_first(int32 result, fileThread *fThread)
 463 {
 464         fThread->socketId = result;
 465         TIZEN_LOGD("File Thread socketId [%d]", fThread->socketId);
 466     if ((-1 == fThread->socketId) || (!(*(fThread->compRspRcvdFlag))))
 467     {
 468         if (fThread->firstRngStatus == FIRST_RSP_STATUS_PENDING)
 469         {
 470             fThread->firstRngStatus = FIRST_RSP_STATUS_FAILED;
 471             TIZEN_LOGD("First Response failed");;
 472             /* server doest support Range Request */
 473             /* Exit all threads */
 474             *(fThread->compRspRcvdFlag) = 0;
 475             TIZEN_LOGD("First Response Failed for File ThreadId");
 476             return THREAD_EXIT;
 477         }
 478         else
 479         {
 480             if(fThread->SBData->file_status == NO_REDIVISION)
 481             {
 482                 fThread->status = FILE_IO_EXCEPTION;
 483             }
 484             else if(fThread->SBData->status == MAIN_COMPLETE)
 485             {
 486                 fThread->status = MAIN_COMPLETE;
 487             }
 488             else
 489             {
 490                 fThread->status = FILE_IO_EXCEPTION;
 491             }
 492             return THREAD_CONTINUE;
 493         }
 494     }
 495     return 0;
 496 }
 497
 498 int file_thread_connet_server_interface(fileThread *fThread)
 499 {
 500         file_thread_connect_server(fThread);
 501         TIZEN_LOGD("File Thread socketId [%d]", fThread->socketId);
 502
 503         if ((0 > fThread->socketId) || (!(*(fThread->compRspRcvdFlag))))
 504         {
 505                 if (fThread->firstRngStatus == FIRST_RSP_STATUS_PENDING)
 506                 {
 507                         fThread->firstRngStatus = FIRST_RSP_STATUS_FAILED;
 508                         TIZEN_LOGD("First Response failed");;
 509                         /* server doest support Range Request */
 510                         /* Exit all threads */
 511                         *(fThread->compRspRcvdFlag) = 0;
 512                         TIZEN_LOGD("First Response Failed for File ThreadId");
 513                         return THREAD_EXIT;
 514                 }
 515                 else
 516                 {
 517                         if(fThread->SBData->file_status == NO_REDIVISION)
 518                         {
 519                                 fThread->status = FILE_IO_EXCEPTION;
 520                         }
 521                         else if(fThread->SBData->status == MAIN_COMPLETE)
 522                         {
 523                                 fThread->status = MAIN_COMPLETE;
 524                         }
 525                         else
 526                         {
 527                                 fThread->status = FILE_IO_EXCEPTION;
 528                         }
 529                         return THREAD_CONTINUE;
 530                 }
 531         }
 532         return 0;
 533 }
 534
 535
 536
 537 int32 file_thread_range_request_recv_rng_rsp_headers_first_req(uint64 *bodyLen, char *blockSize, uint64 currChunkLen, uint32 *connClose, fileThread *fThread, int8 *rcvBuff, int32 lengthRcvd)
 538 {
 539         uint32 offset = lengthRcvd;
 540         int32 retval = -1;
 541         int32 len = 0;
 542         int8 rspPrint[MAX_HEADERS_SIZE] = {0};
 543         httpResp httpRsp ;
 544         uint64 instanceSize =  fThread->contRngLen;
 545         uint64 respLen = fThread->compRspLen;
 546         len = decode_http_find_str(rcvBuff, END_OF_HEADERS);
 547         uint32 headerLen = (len+4);
 548         *bodyLen = (uint64)(offset - headerLen);
 549         memcpy(rspPrint, rcvBuff, headerLen);
 550         SECURE_DB_INFO("Response [%s]", rspPrint);
 551         TIZEN_LOGD("Total Data Received [%d]", lengthRcvd);
 552         memset(&httpRsp, 0, sizeof(httpResp));
 553         decode_http_rsp_init(rcvBuff, headerLen, &httpRsp);
 554         retval = process_http_rsp(&httpRsp);
 555         if(HTTP_RSP_DECODING_SUCCESS == retval)
 556         {
 557                 TIZEN_LOGD("File Thread Response Decode Success");
 558                 retval = range_request_validate_rsp(instanceSize, &httpRsp, currChunkLen, respLen, connClose);
 559                 if((retval == HTTP_RSP_DECODING_SUCCESS) && (*bodyLen > 0))
 560                 {
 561                         memcpy(blockSize,rcvBuff+headerLen,*bodyLen);
 562                 }
 563         }
 564         delete_http_rsp(&httpRsp);
 565         TIZEN_LOGD("File Thread Response Decode Success ...");
 566         return retval;
 567 }
 568
 569 int32 file_thread_range_request_recv_rng_rsp_headers(uint64 *bodyLen, char *blockSize, uint64 currChunkLen, uint32 *connClose, fileThread *fThread)
 570 {
 571         int32 rcvdLen = 0;
 572         uint32 offset = 0;
 573         int32 retval = -1;
 574         int32 len = 0;
 575         int8 rspSize[MAX_HEADERS_SIZE] = {0};
 576         int8 rspPrint[MAX_HEADERS_SIZE] = {0};
 577         httpResp httpRsp ;
 578         uint64 instanceSize =  fThread->contRngLen;
 579         uint64 respLen = fThread->compRspLen;
 580         while(1)
 581         {
 582                 TIZEN_LOGD("Recv Response");
 583                 if (file_thread_conn_poll(fThread->socketId, fThread->SBData) <= 0)
 584                 {
 585                         TIZEN_LOGD("File Thread Fail Polling");
 586                         return HTTP_RSP_SOCKET_ERROR;
 587                 }
 588                 TIZEN_LOGD("Recved Response");
 589                 rcvdLen = recv(fThread->socketId,rspSize+offset,MAX_HEADERS_SIZE-offset,0);
 590                 if(rcvdLen > 0)
 591                 {
 592                         rspSize[offset + rcvdLen +1] = '\0';
 593                         len = decode_http_find_str(rspSize,END_OF_HEADERS);
 594                         if(-1 != len)
 595                         {
 596                                 uint32 headerLen = len+4;
 597                                 offset  = offset + rcvdLen;
 598                                 *bodyLen = offset-headerLen;
 599                                 memcpy(rspPrint, rspSize, headerLen);
 600                                 SECURE_DB_INFO("Response [%s]", rspPrint);
 601                                 memset(&httpRsp, 0, sizeof(httpResp));
 602                                 decode_http_rsp_init(rspSize, headerLen, &httpRsp);
 603                                 retval = process_http_rsp(&httpRsp);
 604                                 if(HTTP_RSP_DECODING_SUCCESS == retval)
 605                                 {
 606                                         TIZEN_LOGD("File Thread Response Decode Success");
 607                                         retval = range_request_validate_rsp(instanceSize,
 608                                                         &httpRsp, currChunkLen, respLen, connClose);
 609                                         if((retval == HTTP_RSP_DECODING_SUCCESS) && (*bodyLen > 0))
 610                                         {
 611                                                 memcpy(blockSize,rspSize+headerLen,*bodyLen);
 612                                         }
 613                                 }
 614                                 delete_http_rsp(&httpRsp);
 615                                 TIZEN_LOGD("File Thread Response Decode Success ...");
 616                                 return retval;
 617                         }
 618                         else
 619                         {
 620                                 offset  = offset + rcvdLen;
 621                                 if (offset == MAX_HEADERS_SIZE)
 622                                 {
 623                                         /* Rsp header too large */
 624                                         retval = HTTP_RSP_DECODING_ERROR;
 625                                         break;
 626                                 }
 627                         }
 628                 }
 629                 else
 630                 {
 631                         retval = HTTP_RSP_SOCKET_ERROR;
 632                         break;
 633                 }
 634         }
 635         return retval;
 636 }
 637
 638 int32 file_thread_rebuildReq(char *newRequest, int64 *chunkInfo, fileThread *fThread)
 639 {
 640         int32 rangeLen = 0;
 641         int8 rangeField[MAX_RANGE_FIELD_LEN] = {0};
 642         rangeLen = sprintf(rangeField,"%s%llu%s%llu%s","Range: bytes=",chunkInfo[0],"-",chunkInfo[1],"\r\n\r\n");
 643         memcpy(newRequest, fThread->req, fThread->headerLen - 2);
 644         memcpy(newRequest + fThread->headerLen -2, rangeField, rangeLen);
 645         return (rangeLen+fThread->headerLen);
 646 }
 647
 648 void file_thread_exit(fileThread *fThread)
 649 {
 650         TIZEN_LOGD("File_Thread_Exit [%p]", fThread);
 651
 652         if (0 < fThread->socketId)
 653         {
 654                 shutdown(fThread->socketId, 1);
 655         }
 656
 657         if (0 != fThread->pthreadId)
 658         {
 659                 pthread_join(fThread->pthreadId,NULL);
 660                 TIZEN_LOGD("File Thread Closed");
 661                 fThread->pthreadId = 0;
 662         }
 663         if (0 < fThread->socketId)
 664         {
 665                 CLOSE_SOCKET(fThread->socketId);
 666                 fThread->socketId = -1;
 667         }
 668         free(fThread);
 669         fThread = NULL;
 670         TIZEN_LOGD("File Thread Exit Sucess [%p]", fThread);
 671 }
 672