src/multirat_connection.c

   1 #include "multirat_conf.h"
   2 #include "multirat_process.h"
   3 #include "multirat_connection.h"
   4 #include "multirat_libapi.h"
   5 #include <vconf.h>
   6 #include <vconf-keys.h>
   7
   8 int32 connection_interface_status(struct ifreq *ifr, char *name)
   9 {
  10         int32 sock = -1;
  11         uint32 i = 0;
  12         uint32 interfaces = 0;
  13         struct ifconf ifconf;
  14         struct ifreq ifreq[10];
  15
  16         sock = socket(AF_INET, SOCK_STREAM, 0);
  17         if (sock < 0)
  18         {
  19                 TIZEN_LOGD("Error !!! while creating socket [%d] [%s]", errno, strerror(errno));
  20                 return -1;
  21         }
  22
  23         ifconf.ifc_buf = (char *) ifreq;
  24         ifconf.ifc_len = sizeof ifreq;
  25
  26         if (ioctl(sock, SIOCGIFCONF, &ifconf) == -1)
  27         {
  28                 TIZEN_LOGD("Error !!! while executing ioctl [%d] [%s]", errno, strerror(errno));
  29                 CLOSE_SOCKET(sock);
  30                 return -1;
  31         }
  32
  33         interfaces = ifconf.ifc_len / sizeof(ifreq[0]);
  34         TIZEN_LOGD("Number of interfaces [%d]",interfaces);
  35
  36         for (i = 0; i < interfaces; i++)
  37         {
  38                 TIZEN_D_LOGD("Name of Interface [%s]", ifreq[i].ifr_name);
  39                 if(!strncmp(ifreq[i].ifr_name, name, strlen(name)))
  40                 {
  41                         ioctl(sock,  SIOCGIFFLAGS, &ifreq[i]);
  42                         if((ifreq[i].ifr_flags & IFF_UP)  && (ifreq[i].ifr_flags & IFF_RUNNING))
  43                         {
  44                                 memcpy(ifr,&(ifreq[i]),sizeof(struct ifreq));
  45                                 CLOSE_SOCKET(sock);
  46                                 return B_TRUE;
  47                         }
  48                 }
  49         }
  50         CLOSE_SOCKET(sock);
  51         return -1;
  52 }
  53
  54 int32 connection_is_ifaceup(uint32 ifaceidx, interfaceInfo *ifaceInfo,int iptype)
  55 {
  56         int32 status = 0 ;
  57         int8 *default_iname = DEFAULT_INTERFACE;
  58         int8 *ifacename = NULL;
  59         int8 ip[INET_ADDRSTRLEN] = {0};
  60         struct sockaddr_in *address = NULL;
  61         struct sockaddr_in6 *address_ip6 = NULL;
  62         struct ifreq ifreq;
  63
  64         if (0 == strncasecmp(default_iname, LTE, strlen(LTE)))
  65         {
  66                 /*
  67                  * thread  0 should get interface LTE (1)
  68                  * and thread 1 should get interface WIFI(0)
  69                  */
  70                 ifaceidx = (ifaceidx + 1) % 2;
  71         }
  72
  73         if(ifaceidx)
  74         {
  75                 ifacename = LTE_IFACE_NAME;
  76         }
  77         else
  78         {
  79                 ifacename = WIFI_IFACE_NAME;
  80         }
  81
  82         memset(&ifreq,0,sizeof(struct ifreq));
  83         status = connection_interface_status(&ifreq,ifacename);
  84
  85         if(status == -1)
  86         {
  87                 return B_FALSE ;
  88         }
  89
  90         if(iptype)
  91         {
  92                 address_ip6= (struct sockaddr_in6 *) &ifreq.ifr_addr;
  93                 if (!inet_ntop(AF_INET6, &address_ip6->sin6_addr, ip, sizeof(ip)))
  94                 {
  95                         TIZEN_LOGD("Error !!! while executing inet_ntop [%d] [%s]", errno, strerror(errno));
  96                         return B_FALSE;
  97                 }
  98         }
  99         else
 100         {
 101                 address = (struct sockaddr_in *) &ifreq.ifr_addr;
 102                 if (!inet_ntop(AF_INET, &address->sin_addr, ip, sizeof(ip)))
 103                 {
 104                         TIZEN_LOGD("Error !!! while executing inet_ntop [%d] [%s]", errno, strerror(errno));
 105                         return B_FALSE;
 106                 }
 107         }
 108
 109         memset(ifaceInfo[ifaceidx].ip, 0, INET_ADDRSTRLEN);
 110         strcpy(ifaceInfo[ifaceidx].ip,ip);
 111
 112         return B_TRUE;
 113 }
 114
 115 int32 file_thread_connServer (int32 sockFd, struct sockaddr_in *remote_addr,struct sockaddr_in6 *remote_addr_ip6, uint32 timeout,
 116   SmartBondingData *SBData)
 117 {
 118         //int32 flags = 0;
 119         int32 retval = 0;
 120         int32 select_ret = 0;
 121         uint32 connTimeOut = 0;
 122         uint64 connect_start = 0;
 123         int8 tmp_ip_addr[INET6_ADDRSTRLEN];
 124         int32 connect_status = -1;
 125
 126         if((0 != timeout))
 127         {
 128                 connTimeOut = MIN(timeout, 60);
 129         }
 130         else
 131         {
 132                 connTimeOut = 60;
 133         }
 134
 135         //flags = fcntl(sockFd, F_GETFL, 0);
 136
 137         if(SBData->conn.ip_family)
 138         {
 139                 SECURE_DB_INFO("destIPv6 address [%s]", inet_ntop(AF_INET6,&(remote_addr_ip6->sin6_addr),tmp_ip_addr,INET6_ADDRSTRLEN));
 140         }
 141         else
 142         {
 143                 SECURE_DB_INFO("destIPv4 address [%s]", inet_ntoa(remote_addr->sin_addr));
 144         }
 145
 146         if(-1 == fcntl(sockFd, F_SETFL, O_NONBLOCK))
 147         {
 148                 TIZEN_LOGD("Error !!! connection FCNTL failed [%d] [%s]", errno, strerror(errno));
 149                 return -1;
 150         }
 151
 152         if(SBData->conn.ip_family)
 153         {
 154                 connect_status = connect(sockFd, (struct sockaddr *)remote_addr_ip6, sizeof(struct sockaddr_in6));
 155         }
 156         else
 157         {
 158                 connect_status = connect(sockFd, (struct sockaddr *)remote_addr, sizeof(struct sockaddr_in6));
 159         }
 160         if(connect_status == -1)
 161         {
 162                 if(errno != EINPROGRESS)
 163                 {
 164                         TIZEN_LOGD("Error !!! connection failure [%d] [%d] [%s]", sockFd, errno, strerror(errno));
 165                         return -1;
 166                 }
 167                 retval = -1;
 168
 169                 struct timeval tv;
 170                 fd_set write_fds;
 171
 172                 connect_start = get_time_in_sec();
 173                 while(((get_time_in_sec() - connect_start) < connTimeOut) && ((SBData->fStream->compRspRcvdFlag)) && ((SBData->status == MAIN_START) || (SBData->file_status == NO_REDIVISION)))
 174                 {
 175                         tv.tv_sec = 1;
 176                         tv.tv_usec = 0;
 177                         FD_ZERO(&write_fds);
 178                         FD_SET(sockFd, &write_fds);
 179                         select_ret = select(sockFd + 1, NULL, &write_fds, NULL, &tv);
 180                         if(select_ret == 0)
 181                         {
 182                                 TIZEN_LOGD("Time out on select with socket [%d]",sockFd);
 183                                 continue;
 184                         }
 185                         else if(select_ret == -1)
 186                         {
 187                                 TIZEN_LOGD("Error !!! select failed [%d] [%s]", errno, strerror(errno));
 188                                 retval = -1;
 189                         }
 190                         else if(select_ret == 1)
 191                         {
 192                                 int so_error;
 193                                 socklen_t slen = sizeof (so_error);
 194                                 if(getsockopt(sockFd, SOL_SOCKET, SO_ERROR, &so_error, &slen) == 0)
 195                                 {
 196                                         if(so_error)
 197                                         {
 198                                                 TIZEN_LOGD("Error !!! getsockopt failed, so_error is true [%d] [%s]", errno, strerror(errno));
 199                                         }
 200                                         else
 201                                         {
 202                                                 retval = 0;
 203                                         }
 204                                 }
 205                                 else
 206                                 {
 207                                         TIZEN_LOGD("Error !!! getsockopt failed [%d] [%s]", errno, strerror(errno));
 208                                 }
 209                         }
 210                         break;
 211                 }
 212         }
 213         return retval;
 214 }
 215
 216 int32 get_connection_status(SmartBondingData *SBData)
 217 {
 218         struct timeval tv;
 219         fd_set write_fds;
 220
 221         int32 sockFd = SBData->socket_fd;
 222
 223         int32 retval = -1;
 224         int32 select_ret = 0;
 225
 226         tv.tv_sec = 1;
 227         tv.tv_usec = 0;
 228
 229         FD_ZERO(&write_fds);
 230         FD_SET(sockFd, &write_fds);
 231
 232         TIZEN_LOGD("SBData[%p] Check Connection Status ", SBData);
 233
 234         select_ret = select(sockFd + 1, NULL, &write_fds, NULL, &tv);
 235         if(select_ret == 0)
 236         {
 237                 SBData->con_status = CONNECTION_WAIT;
 238                 TIZEN_LOGD("Time out on select with socket [%d] SBData[%p]",sockFd, SBData);
 239         }
 240         else if(select_ret == -1)
 241         {
 242                 SBData->con_status = CONNECTION_FAIL;
 243                 TIZEN_LOGD("Error !!! select failed [%d] [%s] SBData[%p]", errno, strerror(errno), SBData);
 244         }
 245         else if(select_ret == 1)
 246         {
 247                 int so_error;
 248                 socklen_t slen = sizeof (so_error);
 249                 if(getsockopt(sockFd, SOL_SOCKET, SO_ERROR, &so_error, &slen) == 0)
 250                 {
 251                         if(so_error)
 252                         {
 253                                 SBData->con_status = CONNECTION_FAIL;
 254                                 TIZEN_LOGD("Error !!! getsockopt failed, so_error is true [%d] [%s] SBData[%p]", errno, strerror(errno), SBData);
 255                         }
 256                         else
 257                         {
 258                                 SBData->con_status = CONNECTION_SUCCESS;
 259                                 TIZEN_LOGD("Connection Success");
 260                                 retval = 0;
 261                         }
 262                 }
 263                 else
 264                 {
 265                         SBData->con_status = CONNECTION_FAIL;
 266                         TIZEN_LOGD("Error !!! getsockopt failed [%d] [%s] SBData[%p]", errno, strerror(errno), SBData);
 267                 }
 268         }
 269         return retval;
 270 }
 271
 272 int32 connServer (int32 sockFd, struct sockaddr_in *remote_addr,struct sockaddr_in6 *remote_addr_ip6, uint32 timeout,
 273   SmartBondingData *SBData)
 274 {
 275         int32 retval = 0;
 276         int32 select_ret = 0;
 277         uint32 connTimeOut = 0;
 278         uint64 connect_start = 0;
 279         int8 tmp_ip_addr[INET_ADDRSTRLENG];
 280         int32 connect_status = -1;
 281
 282         if((0 != timeout))
 283         {
 284                 connTimeOut = MIN(timeout, 60);
 285         }
 286         else
 287         {
 288                 connTimeOut = 60;
 289         }
 290
 291         if(SBData->conn.ip_family)
 292         {
 293                 SECURE_DB_INFO("SBData[%p] destIPv6 address [%s] timeout [%d]", SBData, inet_ntop(AF_INET6,&(remote_addr_ip6->sin6_addr),tmp_ip_addr,INET6_ADDRSTRLEN), connTimeOut);
 294         }
 295         else
 296         {
 297                 SECURE_DB_INFO("SBData[%p] destIPv4 address [%s] timeout [%d]", SBData, inet_ntoa(remote_addr->sin_addr), connTimeOut);
 298         }
 299
 300         if(-1 == fcntl(sockFd, F_SETFL, O_NONBLOCK))
 301         {
 302                 TIZEN_LOGD("SBData[%p] Error !!! connection FCNTL failed [%d] [%s]", SBData, errno, strerror(errno));
 303                 return -1;
 304         }
 305         if(SBData->conn.ip_family)
 306         {
 307                 connect_status = connect(sockFd, (struct sockaddr *)remote_addr_ip6, sizeof(struct sockaddr_in6));
 308         }
 309         else
 310         {
 311                 connect_status = connect(sockFd, (struct sockaddr *)remote_addr, sizeof(struct sockaddr_in6));
 312         }
 313         if(connect_status == -1)
 314         {
 315                 if(errno != EINPROGRESS)
 316                 {
 317                         SBData->con_status = CONNECTION_FAIL;
 318                         TIZEN_LOGD("SBData[%p] Error !!! connection failure [%d] [%d] [%s]", SBData, sockFd, errno, strerror(errno));
 319                         return -1;
 320                 }
 321                 retval = -1;
 322                 SBData->con_status = CONNECTION_FAIL;
 323                 struct timeval tv;
 324                 fd_set write_fds;
 325
 326                 connect_start = get_time_in_sec();
 327                 while(((get_time_in_sec() - connect_start) < connTimeOut) && (SBData->cancel != 1))
 328                 {
 329                         tv.tv_sec = 0;
 330                         tv.tv_usec = 500000; /* half sec */
 331                         FD_ZERO(&write_fds);
 332                         FD_SET(sockFd, &write_fds);
 333                         select_ret = select(sockFd + 1, NULL, &write_fds, NULL, &tv);
 334                         if(select_ret == 0)
 335                         {
 336                                 SBData->con_status = CONNECTION_WAIT;
 337                                 TIZEN_LOGD("SBData[%p] Time out on select with socket [%d]",SBData, sockFd);
 338                                 continue;
 339                         }
 340                         else if(select_ret == -1)
 341                         {
 342                                 SBData->con_status = CONNECTION_FAIL;
 343                                 TIZEN_LOGD("SBData[%p] Error !!! select failed [%d] [%s]", SBData, errno, strerror(errno));
 344                                 retval = -1;
 345                         }
 346                         else if(select_ret == 1)
 347                         {
 348                                 int so_error;
 349                                 socklen_t slen = sizeof (so_error);
 350                                 if(getsockopt(sockFd, SOL_SOCKET, SO_ERROR, &so_error, &slen) == 0)
 351                                 {
 352                                         if(so_error)
 353                                         {
 354                                                 SBData->con_status = CONNECTION_FAIL;
 355                                                 TIZEN_LOGD("SBData[%p] Error !!! getsockopt failed, so_error is true [%d] [%s]",SBData, errno, strerror(errno));
 356                                         }
 357                                         else
 358                                         {
 359                                                 struct sockaddr sockname;
 360                                                 unsigned int len = sizeof(sockname);
 361                                                 unsigned short port = 0;
 362                                                 memset(&sockname, 0, len);
 363                                                 if(getsockname(sockFd, &sockname, &len) != -1)
 364                                                 {
 365                                                         port = ntohs(((struct sockaddr_in*)(&sockname))->sin_port);
 366                                                 }
 367                                                 else
 368                                                 {
 369                                                         TIZEN_LOGD("SBData[%p] Error !!! getsockname failed [%d] [%s]",SBData, errno, strerror(errno));
 370                                                 }
 371                                                 SBData->con_status = CONNECTION_SUCCESS;
 372
 373                                                 SECURE_DB_INFO("SBData[%p] Conection Success source_port=%hu",SBData, port);
 374                                                 retval = 0;
 375                                         }
 376                                 }
 377                                 else
 378                                 {
 379                                         SBData->con_status = CONNECTION_FAIL;
 380                                         TIZEN_LOGD("SBData[%p] Error !!! getsockopt failed [%d] [%s]",SBData, errno, strerror(errno));
 381                                 }
 382                         }
 383                         break;
 384                 }
 385         }
 386         else
 387                 SBData->con_status = CONNECTION_SUCCESS;
 388         return retval;
 389 }
 390
 391 void file_thread_connect_server(fileThread *fThread)
 392 {
 393         int32 socketId = -1;
 394         uint32 index = 0;
 395         uint32 bindCount = 0;
 396         struct hostent *h;
 397         struct sockaddr_in remote_addr;
 398         struct sockaddr_in6 remote_addr_ip6;
 399
 400         connection *conn = fThread->conn ;
 401
 402         index = fThread->interface_index;
 403
 404         TIZEN_LOGD("Connect Server");
 405
 406         h = gethostbyname(conn->ifaceInfo[index].server_ip);
 407
 408         SECURE_DB_INFO("Server IP %s For %d interface", conn->ifaceInfo[index].server_ip, index);
 409
 410         //      memset(&remote_addr, 0, sizeof(struct sockaddr_in));
 411
 412         if(conn->ip_family)
 413         {
 414                 memset(&remote_addr_ip6, 0, sizeof(struct sockaddr_in6));
 415                 remote_addr_ip6.sin6_family = h->h_addrtype;
 416                 memcpy((char *) &remote_addr_ip6.sin6_addr.s6_addr, h->h_addr_list[0], h->h_length);
 417                 remote_addr_ip6.sin6_port = htons(conn->ifaceInfo[index].server_port);
 418         }
 419         else
 420         {
 421                 memset(&remote_addr, 0, sizeof(struct sockaddr_in));
 422                 remote_addr.sin_family = h->h_addrtype;
 423                 memcpy((char *) &remote_addr.sin_addr.s_addr, h->h_addr_list[0], h->h_length);
 424                 remote_addr.sin_port = htons(conn->ifaceInfo[index].server_port);
 425         }
 426
 427         while (*fThread->compRspRcvdFlag)
 428         {
 429                 if(bindCount> 3)
 430                 {
 431                         TIZEN_LOGD("thread ID Tried Connect More Times File Thread");
 432                         socketId = -1;
 433                         break;
 434                 }
 435
 436                 socketId = conn_get_socket_bind(conn->ifaceInfo[index].ip,index,conn->ip_family);
 437                 if(socketId < 0)
 438                 {
 439                         socketId = -1;
 440                         usleep(100000);
 441                         bindCount++;
 442                         continue;
 443                 }
 444
 445                 TIZEN_LOGD("Socket ID [%d]",socketId);
 446
 447                 if(-1 == file_thread_connServer(socketId, &remote_addr,&remote_addr_ip6, fThread->SBData->timeout, fThread->SBData))
 448                 {
 449                         CLOSE_SOCKET(socketId);
 450                         socketId = -1;
 451                 }
 452                 break;
 453         }
 454         if (((*fThread->compRspRcvdFlag)== 0) && (socketId >= 0))
 455         {
 456                 TIZEN_LOGD("socket compRspRcvdFlag 0 and socket thread id [%d]", socketId);
 457                 CLOSE_SOCKET(socketId);
 458                 socketId = -1;
 459         }
 460         fThread->socketId = socketId;
 461         return;
 462 }
 463
 464 void connect_server(RangeRequestThread *rrthread)
 465 {
 466         int32 socketId = -1;
 467         uint32 index = 0;
 468         uint32 bindCount = 0;
 469         int8 *default_iname = DEFAULT_INTERFACE;
 470         struct hostent *h;
 471         struct sockaddr_in remote_addr;
 472         struct sockaddr_in6 remote_addr_ip6;
 473         connection *conn = rrthread->conn ;
 474
 475         index = rrthread->threadId;
 476
 477         if (0 == strncasecmp(default_iname, LTE, strlen(LTE)))
 478         {
 479                 index = (index +1) % 2;
 480         }/* End of if */
 481
 482         h = gethostbyname(conn->ifaceInfo[index].server_ip);
 483
 484         SECURE_DB_INFO("Server IP [%s] For [%d] interface", conn->ifaceInfo[index].server_ip, index);
 485
 486         //      memset(&remote_addr, 0, sizeof(struct sockaddr_in));
 487
 488         if(conn->ip_family)
 489         {
 490                 memset(&remote_addr_ip6, 0, sizeof(struct sockaddr_in6));
 491                 remote_addr_ip6.sin6_family = h->h_addrtype;
 492                 memcpy((char *) &remote_addr_ip6.sin6_addr.s6_addr, h->h_addr_list[0], h->h_length);
 493                 remote_addr_ip6.sin6_port = htons(conn->ifaceInfo[index].server_port);
 494         }
 495         else
 496         {
 497                 memset(&remote_addr, 0, sizeof(struct sockaddr_in));
 498                 remote_addr.sin_family = h->h_addrtype;
 499                 memcpy((char *) &remote_addr.sin_addr.s_addr, h->h_addr_list[0], h->h_length);
 500                 remote_addr.sin_port = htons(conn->ifaceInfo[index].server_port);
 501         }
 502
 503         while (*rrthread->compRspRcvdFlag)
 504         {
 505                 if(bindCount> 3)
 506                 {
 507                         TIZEN_LOGD("thread ID [%d] Tried Connect More Times",rrthread->threadId);
 508                         socketId = -1;
 509                         break;
 510                 }
 511
 512                 socketId = conn_get_socket_bind(conn->ifaceInfo[index].ip,index,conn->ip_family);
 513                 if(socketId < 0)
 514                 {
 515                         socketId = -1;
 516                         usleep(100000);
 517                         bindCount++;
 518                         continue;
 519                 }
 520
 521                 TIZEN_LOGD("Socket ID [%d]",socketId);
 522
 523                 if(-1 == connServer(socketId, &remote_addr,&remote_addr_ip6,rrthread->SBData->timeout, rrthread->SBData))
 524                 {
 525                         CLOSE_SOCKET(socketId);
 526                         socketId = -1;
 527                 }
 528                 break;
 529         }
 530         if (((*rrthread->compRspRcvdFlag)== 0) && (socketId >= 0))
 531         {
 532                 TIZEN_LOGD("socket compRspRcvdFlag 0 and socket thread id [%d]", socketId);
 533                 CLOSE_SOCKET(socketId);
 534                 socketId = -1;
 535         }
 536         conn->sockId[rrthread->threadId] = socketId;
 537         rrthread->socketId = socketId;
 538         return;
 539 }
 540
 541 uint32 is_interface_up(int8* ifacename, interfaceInfo *ifaceinfo,int iptype)
 542 {
 543         int32 status = 0 ;
 544         int8 ip[INET_ADDRSTRLEN] = {0};
 545         struct ifreq ifreq;
 546
 547         memset(&ifreq,0,sizeof(struct ifreq));
 548         status = connection_interface_status(&ifreq, ifacename);
 549         if (status!= -1)
 550         {
 551                 if(iptype)
 552                 {
 553                         struct sockaddr_in6 *address_ip6 = (struct sockaddr_in6 *) &ifreq.ifr_addr;
 554                         if (!inet_ntop(AF_INET6, &address_ip6->sin6_addr, ip, sizeof(ip)))
 555                         {
 556                                 TIZEN_LOGD("socket error");
 557                                 return B_FALSE;
 558                         }
 559                 }
 560                 else
 561                 {
 562                         struct sockaddr_in *address = (struct sockaddr_in *) &ifreq.ifr_addr;
 563                         if (!inet_ntop(AF_INET, &address->sin_addr, ip, sizeof(ip)))
 564                         {
 565                                 TIZEN_LOGD("socket error");
 566                                 return B_FALSE;
 567                         }
 568                 }
 569
 570
 571                 if (!strncmp(ifacename, LTE_IFACE_NAME ,  strlen(ifacename)))
 572                 {
 573                         memset(ifaceinfo[LTE_INTERFACE].ip , 0 , INET_ADDRSTRLENG);
 574                         strcpy(ifaceinfo[LTE_INTERFACE].interface_name, ifreq.ifr_name);
 575                         strcpy(ifaceinfo[LTE_INTERFACE].ip,ip);
 576                         SECURE_DB_INFO("IP address of LTE [%s]",ip);
 577                         return B_TRUE;
 578                 }
 579                 else if (!strncmp(ifacename, WIFI_IFACE_NAME , strlen(ifacename)))
 580                 {
 581                         int32 is_on = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
 582                         memset(ifaceinfo[WIFI_INTERFACE].ip , 0 , INET_ADDRSTRLENG);
 583                         strcpy(ifaceinfo[WIFI_INTERFACE].interface_name, ifreq.ifr_name);
 584                         strcpy(ifaceinfo[WIFI_INTERFACE].ip,ip);
 585                         SECURE_DB_INFO("IP address of WiFi [%s]", ip);
 586
 587                         vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on);
 588                         if(is_on != VCONFKEY_MOBILE_HOTSPOT_MODE_NONE)
 589                         {
 590                                 TIZEN_LOGD("Wi-Fi is Not in Normal Wi-Fi Mode");
 591                                 return B_FALSE;
 592                         }
 593                         return B_TRUE;
 594                 }
 595         }
 596         TIZEN_LOGD ("Interface name [%s] is not found", ifacename);
 597         return B_FALSE;
 598 }
 599
 600 uint32 is_both_interface_avail(interfaceInfo *ifaceInfo,int iptype)
 601 {
 602         uint32 lteFlag = 0;
 603         uint32 wifiFlag = 0;
 604
 605         lteFlag = is_interface_up(LTE_IFACE_NAME, ifaceInfo,iptype);
 606         TIZEN_LOGD ("MultiRat Main Thread lte [%u]", lteFlag);
 607
 608         wifiFlag = is_interface_up(WIFI_IFACE_NAME, ifaceInfo,iptype);
 609         TIZEN_LOGD ("MultiRat Main Thread wifi [%u]", wifiFlag);
 610
 611         return (lteFlag && wifiFlag);
 612 }
 613
 614 int32 conn_get_socket_bind(int8 *ip, int ifaceidx, int iptype)
 615 {
 616         int32 socket_fd = -1;
 617         int32 bind_ret = -1;
 618         struct sockaddr_in sa_loc;
 619         struct sockaddr_in6 sa_loc6;
 620
 621         memset(&sa_loc6, 0, sizeof(struct sockaddr_in6));
 622         memset(&sa_loc, 0, sizeof(struct sockaddr_in));
 623
 624         if(iptype)
 625         {
 626                 socket_fd = socket(AF_INET6, SOCK_STREAM, 0);
 627                 if (socket_fd < 0)
 628                 {
 629                         TIZEN_LOGD("Error !!! socket creation failed [%d] [%s]", errno, strerror(errno));
 630                         return -1;
 631                 }
 632                 sa_loc6.sin6_family = AF_INET6;
 633                 sa_loc6.sin6_port = htons(0);
 634                 inet_pton(AF_INET6,ip,&(sa_loc6.sin6_addr));
 635         }
 636         else
 637         {
 638                 socket_fd = socket(AF_INET, SOCK_STREAM, 0);
 639                 if (socket_fd < 0)
 640                 {
 641                         TIZEN_LOGD("Error !!! socket creation failed [%d] [%s]", errno, strerror(errno));
 642                         return -1;
 643                 }
 644                 sa_loc.sin_family = AF_INET;
 645                 sa_loc.sin_port = htons(0);
 646                 sa_loc.sin_addr.s_addr = inet_addr(ip);
 647         }
 648
 649         if(iptype == 0)
 650         {
 651                 bind_ret = bind(socket_fd,(struct sockaddr *)&sa_loc, sizeof(struct sockaddr));
 652         }
 653         else
 654         {
 655                 bind_ret = bind(socket_fd,(struct sockaddr *)&sa_loc6, sizeof(struct sockaddr_in6));
 656         }
 657
 658         SECURE_DB_INFO("Binding [%d] on IP Address [%s]",socket_fd,ip);
 659         if(bind_ret == -1)
 660         {
 661                 TIZEN_LOGD("Error !!! bind failed [%d] [%s]", errno, strerror(errno));
 662                 CLOSE_SOCKET(socket_fd);
 663                 return -1;
 664         }
 665         SECURE_DB_INFO("Binding to the IP address[%s] Successful",ip);
 666         return socket_fd;
 667 }
 668
 669 int32 conn_poll(int32 socketId, uint32 timeout)
 670 {
 671         struct pollfd rcvfd;
 672         memset(&rcvfd, 0, sizeof(struct pollfd));
 673         rcvfd.fd = socketId;
 674         rcvfd.events = POLLIN;
 675
 676         return poll(&rcvfd, 1, timeout);
 677 }
 678
 679 int32 file_thread_conn_poll(int32 socket, SmartBondingData *SBData)
 680 {
 681         int32 pollret = 0;
 682         uint32 pollStartTime = get_time_in_sec();
 683         while((SBData->fStream->compRspRcvdFlag) && (((SBData->status == MAIN_START) || (SBData->file_status == NO_REDIVISION)) && ((get_time_in_sec() - pollStartTime) < 30)))
 684         {
 685                 pollret = 0;
 686                 pollret = conn_poll(socket, 200);
 687                 if (pollret < 0)
 688                 {
 689                         TIZEN_LOGD("Error !!! watchdog thread pollfd failed");
 690                         break;
 691                 }
 692                 else if(pollret == 0)
 693                 {
 694                         TIZEN_D_LOGD("Timeout on File Thread Poll");
 695                         continue;
 696                 }
 697                 else
 698                 {
 699                         TIZEN_D_LOGD("File Thread Response");
 700                         break;
 701                 }
 702         }
 703         return pollret;
 704 }
 705
 706
 707 int32 watchdog_conn_poll(int32 socket, SmartBondingData *SBData)
 708 {
 709         int32 pollret = 0;
 710         uint32 pollStartTime = get_time_in_sec();
 711         while((SBData->cthread->threadStatus != THREAD_FINISH) && ((get_time_in_sec() - pollStartTime) < 30))
 712         {
 713                 pollret = 0;
 714                 pollret = conn_poll(socket, 2000);
 715                 if (pollret < 0)
 716                 {
 717                         TIZEN_LOGD("Error !!! watchdog thread pollfd failed");
 718                         break;
 719                 }
 720                 else if(pollret == 0)
 721                 {
 722                         TIZEN_D_LOGD("Timeout on Watch Dog Poll");
 723                         continue;
 724                 }
 725                 else
 726                 {
 727                         TIZEN_D_LOGD("WatchDog Received Response");
 728                         break;
 729                 }
 730         }
 731         return pollret;
 732 }
 733
 734 void PollThread_poll(int32 socket, SmartBondingData *SBData, uint32 timeout_check)
 735 {
 736         int32 pollret = 0;
 737         uint32 pollStartTime = get_time_in_sec();
 738     while((SBData->PollThrd->threadStatus != THREAD_FINISH) && ((get_time_in_sec() - pollStartTime) < 30))
 739     {
 740         pollret = 0;
 741                 pollret = conn_poll(socket, timeout_check);
 742                 if (pollret < 0)
 743                 {
 744                         TIZEN_LOGD("Error !!! Poll Thread pollfd failed");
 745                         break;
 746                 }
 747                 else if(pollret == 0)
 748                 {
 749                         TIZEN_D_LOGD("Timeout on Pollthread Poll");
 750                         continue;
 751                 }
 752                 else
 753                 {
 754                         TIZEN_D_LOGD("Poll Thread Received Data");
 755                         break;
 756                 }
 757         }
 758         return ;
 759 }
 760
 761 void lib_conn_poll(int32 socket, SmartBondingData *SBData)
 762 {
 763         int32 pollret = 0;
 764         while((SBData->cancel != 1))
 765         {
 766                 pollret = 0;
 767                 pollret = conn_poll(socket, 1000);
 768                 if (pollret < 0)
 769                 {
 770                         TIZEN_LOGD("Error !!! Libapi pollfd failed");
 771                         break;
 772                 }
 773                 else if(pollret == 0)
 774                 {
 775                         TIZEN_D_LOGD("Timeout on Libapi Poll");
 776                         continue;
 777                 }
 778                 else
 779                 {
 780                         TIZEN_D_LOGD("App Read Received Data to Read");
 781                         break;
 782                 }
 783         }
 784         return;
 785 }
 786
 787 int32 read_conn_poll(int32 socket, SmartBondingData *SBData)
 788 {
 789         int32 pollret = 0;
 790         uint32 pollStartTime = get_time_in_sec();
 791         while((SBData->cancel != 1) && ((get_time_in_sec() - pollStartTime) < SBData->timeout))
 792         {
 793                 pollret = 0;
 794                 pollret = conn_poll(socket, 200);
 795                 if (pollret < 0)
 796                 {
 797                         TIZEN_LOGD("Error !!! Read pollfd failed");
 798                         break;
 799                 }
 800                 else if(pollret == 0)
 801                 {
 802                         TIZEN_D_LOGD("Timeout on Read Poll");
 803                         continue;
 804                 }
 805                 else
 806                 {
 807                         TIZEN_D_LOGD("Received Data to Read");
 808                         break;
 809                 }
 810         }
 811         return pollret;
 812 }
 813