src/multirat_file_stream.c

   1 #include "multirat_libapi.h"
   2 #include "multirat_file_stream.h"
   3 #include "multirat_file_manager.h"
   4 #include "multirat_file_buffer.h"
   5 #include "multirat_range_request_thread.h"
   6 #include "multirat_file_thread.h"
   7 #include "multirat_process.h"
   8 #include "multirat_watch_dog_thread.h"
   9 #include "multirat_watchthread.h"
  10
  11 void file_stream_init(SmartBondingData *SBData)
  12 {
  13         fileStream *fStream = malloc(sizeof(fileStream));
  14         fileManager *fileMgr = NULL;
  15
  16         if(fStream == NULL)
  17         {
  18                 TIZEN_LOGD("Error malloc fileStream failed");
  19                 return;
  20         }
  21
  22         memset(fStream, 0, sizeof(fileStream));
  23
  24         SBData->fStream = fStream;
  25         fStream->SBData = SBData;
  26
  27         fStream->mainSockExpBytes = &(SBData->expectedbytes);
  28         fStream->totalLen = (SBData->resp.cLen);
  29         fStream->mainSockRead = &(SBData->response_body_read);
  30         fStream->strtOffset = SBData->req.rangeStart;
  31
  32         fileMgr = (fileManager *)malloc(sizeof(fileManager));
  33         if(fileMgr == NULL)
  34         {
  35                 TIZEN_LOGD("fileManager Allocation Error");
  36                 return;
  37         }
  38         memset(fileMgr, 0, sizeof(fileManager));
  39
  40         fStream->fileMgr = fileMgr;
  41         file_manager_init(fStream, fileMgr);
  42         fileMgr->SBData = SBData;
  43         fileMgr->interface[MAIN_THREAD] = SBData->interface_index;
  44         fileMgr->interface[FILE_THREAD] = (SBData->interface_index + 1) % 2;
  45
  46         fStream->fThread = NULL;
  47         fStream->compRspRcvdFlag = 1;
  48 }
  49
  50 uint32 file_stream_start(SmartBondingData *SBData)
  51 {
  52         TIZEN_D_LOGD("File Stream _start");
  53         fileStream *fStream = SBData->fStream;
  54         fileThread *fThread = malloc(sizeof (fileThread));
  55         if(fThread == NULL)
  56                 return 0;
  57         memset(fThread, 0, sizeof (fileThread));
  58         fStream->fThread = fThread;
  59         file_thread_init(fThread, SBData, fStream);
  60         return file_thread_start(fThread);
  61 }
  62
  63 int32 file_stream_read_from_socket(int32 socket, int8 *buff, uint64 toBeRead, int32 *tempLen, SmartBondingData *SBData, uint32 index)
  64 {
  65         SBData->sStat.prev_read = MAIN_THREAD ;
  66
  67         if((index == 1) && (socket == -1))
  68         {
  69                 SBData->node_exception = SOCKET_NODE_FORCE_EXCEPTION;
  70                 TIZEN_LOGD("Socket is Negative, Go for Main Socket Exception");
  71                 SBData->fStreamFileBufferReady =  B_FALSE;
  72                 SBData->fileThreadStarted = B_FALSE;
  73                 SBData->enableMultiRat = B_FALSE;
  74                 return SB_ERR;
  75         }
  76         *tempLen = recv(socket, buff, toBeRead, 0);
  77         if(*tempLen > 0)
  78         {
  79                 return SB_OK;
  80         }
  81         else
  82         {
  83                 if((errno == EAGAIN) || (errno == EWOULDBLOCK))
  84                 {
  85                         if(SBData->curl)
  86                                 return SB_WOULD_BLOCK;
  87                         else if(SBData->sync)
  88                         {
  89                                 int retval = 0;
  90                                 retval = read_conn_poll(socket, SBData);
  91                                 if(retval <= 0)
  92                                 {
  93                                         TIZEN_LOGD("Error !!! Main socket time out");
  94                                         return SB_ERR;
  95                                 }
  96                                 else
  97                                 {
  98                                         *tempLen = recv(socket, buff, toBeRead, 0);
  99                                         if(*tempLen <= 0)
 100                                         {
 101                                                 TIZEN_LOGD("Error !!! Main socket error in recv [%s] ",strerror (errno));
 102                                                 return SB_ERR;
 103                                         }
 104                                         return SB_OK;
 105                                 }
 106                         }
 107                         else
 108                                 return SB_ERR;
 109                 }
 110                 else
 111                 {
 112                         if((index == 0))
 113                         {
 114                                 TIZEN_LOGD("Normal Socket Exception");
 115                                 SBData->node_exception = SOCKET_NORMAL_EXCEPTION;
 116                                 return SB_ERR;
 117                         }
 118                         SBData->node_exception = SOCKET_NODE_NORMAL_EXCEPTION;
 119                         TIZEN_LOGD("Reading from socket node failed [%s] erro No [%d]", strerror(errno), errno);
 120                         TIZEN_LOGD("Go for Main Socket Exception");
 121                         SBData->fStreamFileBufferReady =  B_FALSE;
 122                         SBData->fileThreadStarted = B_FALSE;
 123                         SBData->enableMultiRat = B_FALSE;
 124                         return SB_ERR;
 125                 }
 126         }
 127 }
 128
 129 int32 file_stream_read(int8 *buff, int32 maxAppLen, SmartBondingData *SBData, int32 *my_nread)
 130 {
 131         int32 retval = SB_ERR;
 132         uint64 toBeRead = 0;
 133         int32 tempLen = -1;
 134         fileBuffer *fbuff = NULL;
 135
 136         fileManager *fMgr = SBData->fStream->fileMgr;
 137         fileBuffer *fileBuff = SBData->fStream->fileBuff;
 138         if(fileBuff != NULL)
 139         {
 140                 fbuff = file_manager_getReadingNode(fMgr);
 141                 if(NULL == fbuff)
 142                 {
 143                         return SB_ERR;
 144                 }
 145                 tempLen = 0;
 146                 while(tempLen <= maxAppLen)
 147                 {
 148                         TIZEN_D_LOGD("Reading File Buffer ... [%x] total length  ... [%llu] read length ... [%llu]", fbuff, file_buffer_getTotalLen(fbuff), file_buffer_getReadRspLen(fbuff));
 149                         if(file_buffer_getTotalLen(fbuff) == file_buffer_getReadRspLen(fbuff))
 150                         {
 151                                 TIZEN_D_LOGD("completed reading from node [%p] len [%llu]", fbuff, file_buffer_getTotalLen(fbuff));
 152                                 if(file_buffer_getNodeType(fbuff) == SOCKET_NODE)
 153                                 SBData->status = MAIN_COMPLETE;
 154
 155                                 fbuff = file_manager_getReadingNode(fMgr);
 156                                 if(NULL == fbuff)
 157                                 {
 158                                         if(tempLen > 0)
 159                                         {
 160                                                 break;
 161                                         }
 162                                         return SB_ERR;
 163                                 }
 164                         }
 165
 166                         if(tempLen> 0)
 167                         {
 168                                 /* already read some bytes */
 169                                 break;
 170                         }
 171
 172                         if(file_buffer_getNodeType(fbuff) == SOCKET_NODE)
 173                         {
 174                                 TIZEN_D_LOGD("completed reading from socket node [%x] total lenght [%llu]  read length [%llu]", fbuff, file_buffer_getTotalLen(fbuff), file_buffer_getReadRspLen(fbuff));
 175                                 toBeRead = MIN(maxAppLen,(file_buffer_getTotalLen(fbuff) - file_buffer_getReadRspLen(fbuff)));
 176                                 retval = file_stream_read_from_socket(file_buffer_getSocketId(fbuff), buff, toBeRead, &tempLen, SBData, 1);
 177                                 if(tempLen > 0)
 178                                 {
 179                                         file_buffer_read_from_socket(fbuff, tempLen);
 180                                         *my_nread = tempLen;
 181                                         TIZEN_D_LOGD("completed reading from socket node [%x] total lenght [%llu]  read length [%llu] ...", fbuff, file_buffer_getTotalLen(fbuff), file_buffer_getReadRspLen(fbuff));
 182                                         if(file_buffer_getTotalLen(fbuff) == file_buffer_getReadRspLen(fbuff))
 183                                         {
 184                                                 TIZEN_LOGD("completed reading from Socket node [%x]", fbuff);
 185                                                 SBData->status = MAIN_COMPLETE;
 186                                         }
 187                                         return SB_OK;
 188                                 }
 189                                 else
 190                                 {
 191                                         if(retval == SB_ERR)
 192                                                 TIZEN_LOGD("SBData[%p] Sending Error", SBData);
 193                                         return retval;
 194                                 }
 195                         }
 196                         TIZEN_D_LOGD("Reading File Buffer [%x] total length [%llu] read length [%llu]", fbuff, file_buffer_getTotalLen(fbuff), file_buffer_getReadRspLen(fbuff));
 197                         if(file_buffer_noOfRspBytes(fbuff)== 0)
 198                         {
 199                                 if(fbuff->state == NODE_STATE_BLOCKED)
 200                                 {
 201                                         TIZEN_LOGD("Looks like File Node is Blocked");
 202                                         if(!file_manager_file_node_block_handle(SBData))
 203                                                 return SB_ERR;
 204                                 }
 205                                 return SB_WOULD_BLOCK;
 206                         }
 207                         toBeRead = MIN((maxAppLen-tempLen),file_buffer_noOfRspBytes(fbuff));
 208
 209                         file_buffer_read_from_file(fbuff, buff+tempLen, &toBeRead);
 210                         tempLen = tempLen + toBeRead;
 211                         TIZEN_D_LOGD("Completed Reading File Buffer [%x] total length [%llu] read length [%llu] ... ", fbuff, file_buffer_getTotalLen(fbuff), file_buffer_getReadRspLen(fbuff));
 212                 }
 213         }
 214         else
 215         {
 216                 TIZEN_LOGD("File buffer not created failed");
 217                 return SB_ERR;
 218         }
 219         *my_nread = tempLen;
 220         return SB_OK;
 221 }
 222
 223 void is_file_stream_read(SmartBondingData *SBData)
 224 {
 225         fileThread *fThread = SBData->fStream->fThread;
 226         if (SBData->response_body_read >= SBData->expectedbytes)
 227         {
 228                 TIZEN_LOGD("Expected Bytes more");
 229                 if(fThread->firstRngStatus == FIRST_RSP_STATUS_SUCCESS)
 230                 {
 231                         TIZEN_LOGD("Read Expected Bytes from Main thread");
 232                         SBData->status = MAIN_COMPLETE;
 233                         SBData->fStreamFileBufferReady = B_TRUE;
 234                         CLOSE_SOCKET(SBData->socket_fd);
 235                         SBData->socket_fd = -1;
 236                         TIZEN_LOGD("FirstRangeRequest Success is_multirat_read");
 237                 }
 238                 else
 239                 {
 240                         SBData->fStreamFileBufferReady =  B_FALSE;
 241                         SBData->fileThreadStarted = B_FALSE;
 242                         SBData->enableMultiRat = B_FALSE;
 243                         TIZEN_LOGD("FirstRangeRequest FAILED");
 244                         file_stream_exit(SBData->fStream);
 245                         SBData->fStream =  NULL;
 246                 }
 247         }
 248 }
 249
 250 void submit_ratio_history(SmartBondingData *SBData)
 251 {
 252         FILE *fp = fopen("/opt/usr/media/Ratiostat", "w");
 253         if(fp == NULL)
 254         {
 255                 TIZEN_LOGD("Opening File /opt/usr/media/Ratiostat Failed");
 256                 return ;
 257         }
 258         fprintf(fp,"%u %u",SBData->speed[1],SBData->speed[0]);
 259         TIZEN_LOGD("Ratiostat Write Success spd[1] [%u] spd[0] [%u]", SBData->speed[1],SBData->speed[0]);
 260         fclose(fp);
 261 }
 262
 263 void file_stream_exit(fileStream *fStream)
 264 {
 265         fileBuffer *fileBuff =  NULL;
 266         fileBuffer *tempBuff =  NULL;
 267         TIZEN_LOGD("file stream exit [%p]", fStream);
 268         fStream->compRspRcvdFlag = 0;
 269         submit_ratio_history(fStream->SBData);
 270
 271         if(fStream->SBData->cthread != NULL)
 272         {
 273                 cthread_exit(fStream->SBData->cthread);
 274                 fStream->SBData->cthread =  NULL;
 275         }
 276
 277         file_thread_exit(fStream->fThread);
 278         fStream->fThread = NULL;
 279
 280         TIZEN_LOGD("file stream exit file Mgr [%p]", fStream->fileMgr);
 281         if(NULL != fStream->fileMgr)
 282         {
 283                 file_manager_exit(fStream->fileMgr);
 284                 free(fStream->fileMgr);
 285                 TIZEN_LOGD("File Manager Freed");
 286         }
 287         fStream->fileMgr = NULL;
 288
 289         fileBuff = fStream->fileBuff ;
 290
 291         while(fileBuff != NULL)
 292         {
 293                 tempBuff = fileBuff;
 294                 fileBuff = tempBuff->next;
 295                 file_buffer_exit(tempBuff);
 296         }
 297         fileBuff = NULL;
 298         free(fStream);
 299         fStream = NULL;
 300
 301         TIZEN_LOGD("File Stream _exit finished");
 302 }
 303
 304 void PollThread_poll_buffer(SmartBondingData *SBData)
 305 {
 306         fileManager *fMgr = SBData->fStream->fileMgr;
 307         fileBuffer *fileBuff = SBData->fStream->fileBuff;
 308         fileBuffer *fbuff =  NULL;
 309         uint64 startTime = 0;
 310
 311         if(fileBuff != NULL)
 312         {
 313                 fbuff = file_manager_getReadingNode(fMgr);
 314                 if(NULL == fbuff)
 315                 {
 316                         return;
 317                 }
 318                 if(file_buffer_getTotalLen(fbuff) == file_buffer_getReadRspLen(fbuff))
 319                 {
 320                         return;
 321                 }
 322                 if(file_buffer_getNodeType(fbuff) == SOCKET_NODE)
 323                 {
 324                         TIZEN_D_LOGD("Socket Node ... [%x]", fbuff);
 325                         if(fbuff->socketId == -1)
 326                         {
 327                                 TIZEN_LOGD("SBData[%p] Socket Node Socket -1", SBData);
 328                                 return;
 329                         }
 330                         PollThread_poll(fbuff->socketId, SBData, 10);
 331                         return;
 332                 }
 333                 else
 334                 {
 335                         startTime = get_time_in_sec();
 336                         while(SBData->PollThrd->threadStatus != THREAD_FINISH)
 337                         {
 338                                 fbuff = file_manager_getReadingNode(fMgr);
 339                                 TIZEN_D_LOGD("SBData[%p] File Node ... [%x]", SBData, fbuff);
 340                                 if(NULL == fbuff)
 341                                 {
 342                                         return;
 343                                 }
 344                                 if(file_buffer_getTotalLen(fbuff) == file_buffer_getReadRspLen(fbuff))
 345                                 {
 346                                         TIZEN_LOGD("Node Completed");
 347                                         return;
 348                                 }
 349                                 if(file_buffer_getNodeType(fbuff) != FILE_NODE)
 350                                 {
 351                                         return;
 352                                 }
 353                                 if(file_buffer_noOfRspBytes(fbuff)== 0)
 354                                 {
 355                                         if(fbuff->fThread_read != 0)
 356                                         {
 357                                                 TIZEN_LOGD("Making File Thread Exit");
 358                                                 SBData->status = MAIN_COMPLETE;
 359                                         }
 360                                         if(((fbuff->state == NODE_STATE_BLOCKED) && ((get_time_in_sec() - startTime) >= 2)))
 361                                         {
 362                                                 TIZEN_LOGD("SBData[%p] Node State is BLOCK ...", SBData);
 363                                                 return;
 364                                         }
 365                                         else
 366                                         {
 367                                                         TIZEN_D_LOGD("SBData[%p] Node State BLOCK sleep", SBData);
 368                                         }
 369                                         usleep(10000);
 370                                         continue;
 371                                 }
 372                                 else
 373                                 {
 374                                         return;
 375                                 }
 376                         }
 377                 }
 378         }
 379 }