daemon/daemon.c

   1 /*
   2 *  DA manager
   3 *
   4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5 *
   6 * Contact:
   7 *
   8 * Jaewon Lim <jaewon81.lim@samsung.com>
   9 * Woojin Jung <woojin2.jung@samsung.com>
  10 * Juyoung Kim <j0.kim@samsung.com>
  11 *
  12  * Licensed under the Apache License, Version 2.0 (the "License");
  13 * you may not use this file except in compliance with the License.
  14 * You may obtain a copy of the License at
  15 *
  16 * http://www.apache.org/licenses/LICENSE-2.0
  17 *
  18 * Unless required by applicable law or agreed to in writing, software
  19 * distributed under the License is distributed on an "AS IS" BASIS,
  20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  21 * See the License for the specific language governing permissions and
  22 * limitations under the License.
  23 *
  24 * Contributors:
  25 * - S-Core Co., Ltd
  26 *
  27 */
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>                     // for realpath
  31 #include <string.h>                     // for strtok, strcpy, strncpy
  32 #include <limits.h>                     // for realpath
  33
  34 #include <errno.h>                      // for errno
  35 #include <sys/types.h>          // for accept, mkdir, opendir, readdir
  36 #include <sys/socket.h>         // for accept
  37 #include <sys/stat.h>           // for mkdir
  38 #include <sys/eventfd.h>        // for eventfd
  39 #include <sys/epoll.h>          // for epoll apis
  40 #include <sys/timerfd.h>        // for timerfd
  41 #include <unistd.h>                     // for access, sleep
  42
  43 #include <ctype.h>
  44
  45 #ifndef LOCALTEST
  46 #include <attr/xattr.h>         // for fsetxattr
  47 #include <sys/smack.h>
  48 #endif
  49
  50 #include <linux/input.h>
  51 #include <dirent.h>
  52 #include <fcntl.h>
  53 #include "daemon.h"
  54 #include "sys_stat.h"
  55 #include "utils.h"
  56 #include "da_protocol.h"
  57 #include "da_data.h"
  58
  59 #define DA_WORK_DIR                             "/home/developer/sdk_tools/da/"
  60 #define DA_READELF_PATH                 "/home/developer/sdk_tools/da/readelf"
  61 #define SCREENSHOT_DIR                  "/tmp/da"
  62
  63 #define EPOLL_SIZE                              10
  64 #define MAX_CONNECT_SIZE                12
  65 #define MAX_APP_LAUNCH_TIME             6
  66
  67 #define MAX_DEVICE                              10
  68 #define MAX_FILENAME                    128
  69 #define BUF_SIZE                                1024
  70 #define ARRAY_END                               (-11)
  71
  72 input_dev g_key_dev[MAX_DEVICE];
  73 input_dev g_touch_dev[MAX_DEVICE];
  74
  75 // return bytes size of readed data
  76 // return 0 if no data readed or error occurred
  77 static int _file_read(FILE* fp, char *buffer, int size)
  78 {
  79         int ret = 0;
  80
  81         if(fp != NULL && size > 0)
  82         {
  83                 ret = fread((void*)buffer, sizeof(char), size, fp);
  84         }
  85         else
  86         {
  87                 // fp is null
  88                 if(size > 0)
  89                         buffer[0] = '\0';
  90
  91                 ret = 0;        // error case
  92         }
  93
  94         return ret;
  95 }
  96
  97 // get input id of given input device
  98 static int get_input_id(char* inputname)
  99 {
 100         static int query_cmd_type = 0;  // 1 if /lib/udev/input_id, 2 if udevadm
 101         FILE* cmd_fp = NULL;
 102         char buffer[BUF_SIZE];
 103         char command[MAX_FILENAME];
 104         int ret = -1;
 105
 106         // determine input_id query command
 107         if(unlikely(query_cmd_type == 0))
 108         {
 109                 if(access("/lib/udev/input_id", F_OK) == 0)             // there is /lib/udev/input_id
 110                 {
 111                         query_cmd_type = 1;
 112                 }
 113                 else    // there is not /lib/udev/input_id
 114                 {
 115                         query_cmd_type = 2;
 116                 }
 117         }
 118
 119         // make command string
 120         if(query_cmd_type == 1)
 121         {
 122                 sprintf(command, "/lib/udev/input_id /class/input/%s", inputname);
 123         }
 124         else
 125         {
 126                 sprintf(command, "udevadm info --name=input/%s --query=property", inputname);
 127         }
 128
 129         // run command
 130         cmd_fp = popen(command, "r");
 131         _file_read(cmd_fp, buffer, BUF_SIZE);
 132
 133         // determine input id
 134         if(strstr(buffer, INPUT_ID_STR_KEY))                    // key
 135         {
 136                 ret = INPUT_ID_KEY;
 137         }
 138         else if(strstr(buffer, INPUT_ID_STR_TOUCH))             // touch
 139         {
 140                 ret = INPUT_ID_TOUCH;
 141         }
 142         else if(strstr(buffer, INPUT_ID_STR_KEYBOARD))  // keyboard
 143         {
 144                 ret = INPUT_ID_KEY;
 145         }
 146         else if(strstr(buffer, INPUT_ID_STR_TABLET))    // touch (emulator)
 147         {
 148                 ret = INPUT_ID_TOUCH;
 149         }
 150
 151         if(cmd_fp != NULL)
 152                 pclose(cmd_fp);
 153         return ret;
 154 }
 155
 156 // get filename and fd of given input type devices
 157 static void _get_fds(input_dev *dev, int input_id)
 158 {
 159         DIR *dp;
 160         struct dirent *d;
 161         int count = 0;
 162
 163         dp = opendir("/sys/class/input");
 164
 165         if(dp != NULL)
 166         {
 167                 while((d = readdir(dp)) != NULL)
 168                 {
 169                         if(!strncmp(d->d_name, "event", 5))     // start with "event"
 170                         {
 171                                 // event file
 172                                 if(input_id == get_input_id(d->d_name))
 173                                 {
 174                                         sprintf(dev[count].fileName, "/dev/input/%s", d->d_name);
 175                                         dev[count].fd = open(dev[count].fileName, O_RDWR | O_NONBLOCK);
 176                                         count++;
 177                                 }
 178                         }
 179                 }
 180
 181                 closedir(dp);
 182         }
 183         dev[count].fd = ARRAY_END;      // end of input_dev array
 184 }
 185
 186 //static
 187 void _device_write(input_dev *dev, struct input_event* in_ev)
 188 {
 189         int i;
 190         for(i = 0; dev[i].fd != ARRAY_END; i++)
 191         {
 192                 if(dev[i].fd >= 0)
 193                 {
 194                         write(dev[i].fd, in_ev, sizeof(struct input_event));
 195                         LOGI("write(%d, %d, %d)\n",dev[i].fd, (int)in_ev, sizeof(struct input_event));
 196                 }
 197         }
 198 }
 199
 200 long long get_total_alloc_size()
 201 {
 202         int i;
 203         long long allocsize = 0;
 204
 205         for(i = 0; i < MAX_TARGET_COUNT; i++)
 206         {
 207                 if(manager.target[i].socket != -1 && manager.target[i].allocmem > 0)
 208                         allocsize += manager.target[i].allocmem;
 209         }
 210         return allocsize;
 211 }
 212
 213 static int getEmptyTargetSlot()
 214 {
 215         int i;
 216         for(i = 0; i < MAX_TARGET_COUNT; i++)
 217         {
 218                 if(manager.target[i].socket == -1)
 219                         break;
 220         }
 221
 222         return i;
 223 }
 224
 225 static void setEmptyTargetSlot(int index)
 226 {
 227         if(index >= 0 && index < MAX_TARGET_COUNT)
 228         {
 229                 manager.target[index].pid = -1;
 230                 manager.target[index].recv_thread = -1;
 231                 manager.target[index].allocmem = 0;
 232                 manager.target[index].starttime = 0;
 233                 manager.target[index].initial_log = 0;
 234                 if(manager.target[index].event_fd != -1)
 235                         close(manager.target[index].event_fd);
 236                 manager.target[index].event_fd = -1;
 237                 if(manager.target[index].socket != -1)
 238                         close(manager.target[index].socket);
 239                 manager.target[index].socket = -1;
 240         }
 241 }
 242
 243 // ======================================================================================
 244 // send functions to host
 245 // ======================================================================================
 246
 247 //static
 248 int sendACKCodeToHost(enum HostMessageType resp, int msgcode)
 249 {
 250         // FIXME:
 251         //disabled string protocol
 252         return 0;
 253         if (manager.host.control_socket != -1)
 254         {
 255                 char codestr[16];
 256                 char logstr[DA_MSG_MAX];
 257                 int loglen, codelen;
 258
 259                 codelen = sprintf(codestr, "%d", msgcode);
 260                 loglen = sprintf(logstr, "%d|%d|%s", (int)resp, codelen, codestr);
 261
 262                 send(manager.host.control_socket, logstr, loglen, MSG_NOSIGNAL);
 263                 return 0;
 264         }
 265         else
 266                 return 1;
 267 }
 268
 269 // ========================================================================================
 270 // start and terminate control functions
 271 // ========================================================================================
 272
 273 int startProfiling(long launchflag)
 274 {
 275         const struct app_info_t *app_info = &prof_session.app_info;
 276
 277         // remove previous screen capture files
 278         remove_indir(SCREENSHOT_DIR);
 279         mkdir(SCREENSHOT_DIR, 0777);
 280 #ifndef LOCALTEST
 281         smack_lsetlabel(SCREENSHOT_DIR, "*", SMACK_LABEL_ACCESS);
 282 #endif
 283         manager.config_flag = launchflag;
 284
 285         if (samplingStart() < 0)
 286                 return -1;
 287
 288         switch (app_info->app_type) {
 289         case APP_TYPE_TIZEN:
 290                 kill_app(app_info->exe_path);
 291                 if (exec_app_tizen(app_info->app_id, app_info->exe_path)) {
 292                         LOGE("Cannot exec tizen app %s\n", app_info->app_id);
 293                         samplingStop();
 294                         return -1;
 295                 }
 296                 break;
 297         case APP_TYPE_RUNNING:
 298                 // TODO: nothing, it's running
 299                 break;
 300         case APP_TYPE_COMMON:
 301                 kill_app(app_info->exe_path);
 302                 if (exec_app_common(app_info->exe_path)) {
 303                         LOGE("Cannot exec common app %s\n", app_info->exe_path);
 304                         samplingStop();
 305                         return -1;
 306                 }
 307                 break;
 308         default:
 309                 LOGE("Unknown app type %d\n", app_info->app_type);
 310                 samplingStop();
 311                 return -1;
 312                 break;
 313         }
 314
 315         return 0;
 316 }
 317
 318 // just send stop message to all target process
 319 static void terminate_all_target()
 320 {
 321         int i;
 322         ssize_t sendlen;
 323         msg_t sendlog;
 324
 325         sendlog.type = MSG_STOP;
 326         sendlog.length = 0;
 327
 328         for (i = 0; i < MAX_TARGET_COUNT; i++)
 329         {
 330                 if(manager.target[i].socket != -1)
 331                 {
 332                         sendlen = send(manager.target[i].socket, &sendlog, sizeof(sendlog.type) + sizeof(sendlog.length), MSG_NOSIGNAL);
 333                         if(sendlen != -1)
 334                         {
 335                                 LOGI("TERMINATE send exit msg (socket %d) by terminate_all_target()\n", manager.target[i].socket);
 336                         }
 337                 }
 338         }
 339 }
 340
 341 // terminate all target and wait for threads
 342 void terminate_all()
 343 {
 344         int i;
 345
 346         terminate_all_target();
 347         samplingStop();
 348
 349         // wait for all other thread exit
 350         for(i = 0; i < MAX_TARGET_COUNT; i++)
 351         {
 352                 if(manager.target[i].recv_thread != -1)
 353                 {
 354                         pthread_join(manager.target[i].recv_thread, NULL);
 355                 }
 356         }
 357 }
 358
 359 // terminate all profiling by critical error
 360 // TODO: don't send data to host
 361 static void terminate_error(char* errstr, int sendtohost)
 362 {
 363         terminate_all();
 364 }
 365
 366 #define MAX_EVENTS_NUM 10
 367 static int deviceEventHandler(input_dev* dev, int input_type)
 368 {
 369         int ret = 0;
 370         ssize_t size = 0;
 371         int count = 0;
 372         struct input_event in_ev[MAX_EVENTS_NUM];
 373         struct msg_data_t *log;
 374
 375         if(input_type == INPUT_ID_TOUCH || input_type == INPUT_ID_KEY)
 376         {
 377                 do {
 378                         size = read(dev->fd, &in_ev[count], sizeof(*in_ev) );
 379                         if (size >0)
 380                                 count++;
 381                 } while (count < MAX_EVENTS_NUM && size > 0);
 382
 383                 if (count) {
 384                         LOGI("read %d %s events\n",
 385                              count,
 386                              input_type == INPUT_ID_KEY ? STR_KEY : STR_TOUCH);
 387                         log = gen_message_event(in_ev, count, input_type);
 388                         printBuf((char *)log, MSG_DATA_HDR_LEN + log->len);
 389                         write_to_buf(log);
 390                         reset_data_msg(log);
 391                 }
 392         }
 393         else
 394         {
 395                 LOGW("unknown input_type\n");
 396                 ret = 1;
 397         }
 398         return ret;
 399 }
 400
 401 // return 0 if normal case
 402 // return plus value if non critical error occur
 403 // return minus value if critical error occur
 404 // return -11 if all target process closed
 405 static int targetEventHandler(int epollfd, int index, uint64_t msg)
 406 {
 407         if(msg & EVENT_PID)
 408         {
 409                 if (index == 0) { // main application
 410                         if (start_replay() != 0) {
 411                                 LOGE("Cannot start replay thread\n");
 412                                 return -1;
 413                         }
 414                 }
 415                 manager.target[index].initial_log = 1;
 416         }
 417
 418         if(msg & EVENT_STOP || msg & EVENT_ERROR)
 419         {
 420                 LOGI("target close, socket(%d), pid(%d) : (remaining %d target)\n",
 421                      manager.target[index].socket,
 422                      manager.target[index].pid,
 423                      manager.target_count - 1);
 424                 if (index == 0) { // main application
 425                         stop_replay();
 426                 }
 427                 epoll_ctl(epollfd, EPOLL_CTL_DEL, manager.target[index].event_fd, NULL);
 428                 setEmptyTargetSlot(index);
 429                 if (0 == __sync_sub_and_fetch(&manager.target_count, 1)) // all target client are closed
 430                         return -11;
 431         }
 432
 433         return 0;
 434 }
 435
 436 // return 0 if normal case
 437 // return plus value if non critical error occur
 438 // return minus value if critical error occur
 439 static int targetServerHandler(int efd)
 440 {
 441         msg_t log;
 442         struct epoll_event ev;
 443
 444         int index = getEmptyTargetSlot();
 445         if(index == MAX_TARGET_COUNT)
 446         {
 447                 LOGW("Max target number(8) reached, no more target can connected\n");
 448                 return 1;
 449         }
 450
 451         manager.target[index].socket = accept(manager.target_server_socket, NULL, NULL);
 452
 453         if(manager.target[index].socket >= 0)   // accept succeed
 454         {
 455 #ifndef LOCALTEST
 456                 // set smack attribute for certification
 457                 fsetxattr(manager.target[index].socket, "security.SMACK64IPIN", "*", 1, 0);
 458                 fsetxattr(manager.target[index].socket, "security.SMACK64IPOUT", "*", 1, 0);
 459 #endif /* LOCALTEST */
 460
 461                 // send config message to target process
 462                 log.type = MSG_OPTION;
 463                 log.length = sprintf(log.data, "%u", manager.config_flag);
 464                 send(manager.target[index].socket, &log, sizeof(log.type) + sizeof(log.length) + log.length, MSG_NOSIGNAL);
 465
 466                 // make event fd
 467                 manager.target[index].event_fd = eventfd(0, EFD_NONBLOCK);
 468                 if(manager.target[index].event_fd == -1)
 469                 {
 470                         // fail to make event fd
 471                         LOGE("fail to make event fd for socket (%d)\n", manager.target[index].socket);
 472                         goto TARGET_CONNECT_FAIL;
 473                 }
 474
 475                 // add event fd to epoll list
 476                 ev.events = EPOLLIN;
 477                 ev.data.fd = manager.target[index].event_fd;
 478                 if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.target[index].event_fd, &ev) < 0)
 479                 {
 480                         // fail to add event fd
 481                         LOGE("fail to add event fd to epoll list for socket (%d)\n", manager.target[index].socket);
 482                         goto TARGET_CONNECT_FAIL;
 483                 }
 484
 485                 // make recv thread for target
 486                 if(makeRecvThread(index) != 0)
 487                 {
 488                         // fail to make recv thread
 489                         LOGE("fail to make recv thread for socket (%d)\n", manager.target[index].socket);
 490                         epoll_ctl(efd, EPOLL_CTL_DEL, manager.target[index].event_fd, NULL);
 491                         goto TARGET_CONNECT_FAIL;
 492                 }
 493
 494                 if(manager.app_launch_timerfd >= 0)
 495                 {
 496                         epoll_ctl(efd, EPOLL_CTL_DEL, manager.app_launch_timerfd, NULL);
 497                         close(manager.app_launch_timerfd);
 498                         manager.app_launch_timerfd = -1;
 499                 }
 500
 501                 LOGI("target connected = %d(running %d target)\n",
 502                                 manager.target[index].socket, manager.target_count + 1);
 503
 504                 manager.target_count++;
 505                 return 0;
 506         }
 507         else    // accept error
 508         {
 509                 LOGE("Failed to accept at target server socket\n");
 510         }
 511
 512 TARGET_CONNECT_FAIL:
 513         if(manager.target_count == 0)   // if this connection is main connection
 514         {
 515                 return -1;
 516         }
 517         else    // if this connection is not main connection then ignore process by error
 518         {
 519                 setEmptyTargetSlot(index);
 520                 return 1;
 521         }
 522 }
 523
 524 // return 0 if normal case
 525 // return plus value if non critical error occur
 526 // return minus value if critical error occur
 527 static int hostServerHandler(int efd)
 528 {
 529         static int hostserverorder = 0;
 530         int csocket;
 531         struct epoll_event ev;
 532
 533         if(hostserverorder > 1) // control and data socket connected already
 534                 return 1;                       // ignore
 535
 536         csocket = accept(manager.host_server_socket, NULL, NULL);
 537
 538         if(csocket >= 0)                // accept succeed
 539         {
 540                 ev.events = EPOLLIN;
 541                 ev.data.fd = csocket;
 542                 if(epoll_ctl(efd, EPOLL_CTL_ADD, csocket, &ev) < 0)
 543                 {
 544                         // consider as accept fail
 545                         LOGE("Failed to add socket fd to epoll list\n");
 546                         close(csocket);
 547                         return -1;
 548                 }
 549
 550                 if(hostserverorder == 0)
 551                 {
 552                         manager.host.control_socket = csocket;
 553                         unlink_portfile();
 554                         LOGI("host control socket connected = %d\n", csocket);
 555                 }
 556                 else
 557                 {
 558                         manager.host.data_socket = csocket;
 559                         LOGI("host data socket connected = %d\n", csocket);
 560                 }
 561
 562                 hostserverorder++;
 563                 return 0;
 564         }
 565         else    // accept error
 566         {
 567                 LOGE("Failed to accept from host server socket\n");
 568                 return -1;
 569         }
 570 }
 571
 572 #ifdef DEB_PRINTBUF
 573 //TODO del it or move to debug section
 574 void printBuf (char * buf, int len)
 575 {
 576
 577         int i,j;
 578         char local_buf[3*16 + 2*16 + 1];
 579         char * p1, * p2;
 580         LOGI("BUFFER:\n");
 581         for ( i = 0; i < len/16 + 1; i++)
 582         {
 583                 memset(local_buf, ' ', 5*16);
 584                 p1 = local_buf;
 585                 p2 = local_buf + 3*17;
 586                 for ( j = 0; j < 16; j++)
 587                         if (i*16+j < len )
 588                         {
 589                                 sprintf(p1, "%02X ",(unsigned char) *buf);
 590                                 p1+=3;
 591                                 if (isprint( *buf)){
 592                                         sprintf(p2, "%c ",(int)*buf);
 593                                 }else{
 594                                         sprintf(p2,". ");
 595                                 }
 596                                 p2+=2;
 597                                 buf++;
 598                         }
 599                 *p1 = ' ';
 600                 *p2 = '\0';
 601                 LOGI("%s\n",local_buf);
 602         }
 603 }
 604 #else
 605
 606 #endif
 607 // return 0 if normal case
 608 // return plus value if non critical error occur
 609 // return minus value if critical error occur
 610 // return -11 if socket closed
 611
 612 static int controlSocketHandler(int efd)
 613 {
 614         ssize_t recv_len;
 615         struct msg_t msg;
 616         int res = 0;
 617
 618         // Receive header
 619         recv_len = recv(manager.host.control_socket,
 620                        &msg,
 621                        MSG_CMD_HDR_LEN, 0);
 622         // error or close request from host
 623         if (recv_len == -1 || recv_len == 0)
 624                 return -11;
 625         else {
 626                 if (msg.len > 0) {
 627                         msg.payload = malloc(msg.len);
 628                         if (!msg.payload) {
 629                                 LOGE("Cannot alloc msg payload\n");
 630                                 sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_FORMAT);
 631                                 return -1;
 632                         }
 633                         // Receive payload (if exists)
 634                         recv_len = recv(manager.host.control_socket,
 635                                         msg.payload,
 636                                         msg.len, MSG_WAITALL);
 637                 }
 638                 res = host_message_handler(&msg);
 639                 reset_msg(&msg);
 640         }
 641
 642         return res;
 643 }
 644
 645 // return 0 for normal case
 646 int daemonLoop()
 647 {
 648         int                     ret = 0;                                // return value
 649         int                     i, k;
 650         ssize_t         recvLen;
 651
 652         struct epoll_event ev, *events;
 653         int efd;                // epoll fd
 654         int numevent;   // number of occured events
 655
 656         _get_fds(g_key_dev, INPUT_ID_KEY);
 657         _get_fds(g_touch_dev, INPUT_ID_TOUCH);
 658
 659         // initialize epoll event pool
 660         events = (struct epoll_event*) malloc(sizeof(struct epoll_event) * EPOLL_SIZE);
 661         if(events == NULL)
 662         {
 663                 LOGE("Out of memory when allocate epoll event pool\n");
 664                 ret = -1;
 665                 goto END_RETURN;
 666         }
 667         if((efd = epoll_create(MAX_CONNECT_SIZE)) < 0)
 668         {
 669                 LOGE("epoll creation error\n");
 670                 ret = -1;
 671                 goto END_EVENT;
 672         }
 673
 674         // add server sockets to epoll event pool
 675         ev.events = EPOLLIN;
 676         ev.data.fd = manager.host_server_socket;
 677         if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.host_server_socket, &ev) < 0)
 678         {
 679                 LOGE("Host server socket epoll_ctl error\n");
 680                 ret = -1;
 681                 goto END_EFD;
 682         }
 683         ev.events = EPOLLIN;
 684         ev.data.fd = manager.target_server_socket;
 685         if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.target_server_socket, &ev) < 0)
 686         {
 687                 LOGE("Target server socket epoll_ctl error\n");
 688                 ret = -1;
 689                 goto END_EFD;
 690         }
 691
 692         // add device fds to epoll event pool
 693         ev.events = EPOLLIN;
 694         for(i = 0; g_key_dev[i].fd != ARRAY_END; i++)
 695         {
 696                 if(g_key_dev[i].fd >= 0)
 697                 {
 698                         ev.data.fd = g_key_dev[i].fd;
 699                         if(epoll_ctl(efd, EPOLL_CTL_ADD, g_key_dev[i].fd, &ev) < 0)
 700                         {
 701                                 LOGE("keyboard device file epoll_ctl error\n");
 702                         }
 703                 }
 704         }
 705
 706         ev.events = EPOLLIN;
 707         for(i = 0; g_touch_dev[i].fd != ARRAY_END; i++)
 708         {
 709                 if(g_touch_dev[i].fd >= 0)
 710                 {
 711                         ev.data.fd = g_touch_dev[i].fd;
 712                         if(epoll_ctl(efd, EPOLL_CTL_ADD, g_touch_dev[i].fd, &ev) < 0)
 713                         {
 714                                 LOGE("touch device file epoll_ctl error\n");
 715                         }
 716                 }
 717         }
 718
 719         // handler loop
 720         while (1)
 721         {
 722                 numevent = epoll_wait(efd, events, EPOLL_SIZE, -1);
 723                 if(numevent <= 0)
 724                 {
 725                         LOGE("Failed to epoll_wait : num of event(%d), errno(%d)\n", numevent, errno);
 726                         continue;
 727                 }
 728
 729                 for(i = 0; i < numevent; i++)
 730                 {
 731                         // check for request from event fd
 732                         for(k = 0; k < MAX_TARGET_COUNT; k++)
 733                         {
 734                                 if(manager.target[k].socket != -1 &&
 735                                                 events[i].data.fd == manager.target[k].event_fd)
 736                                 {
 737                                         uint64_t u;
 738                                         recvLen = read(manager.target[k].event_fd, &u, sizeof(uint64_t));
 739                                         if(recvLen != sizeof(uint64_t))
 740                                         {
 741                                                 // maybe closed, but ignoring is more safe then removing fd from epoll list
 742                                         }
 743                                         else
 744                                         {
 745                                                 if(-11 == targetEventHandler(efd, k, u))
 746                                                 {
 747                                                         LOGI("all target process is closed\n");
 748                                                         continue;
 749                                                 }
 750                                         }
 751                                         break;
 752                                 }
 753                         }
 754
 755                         if(k != MAX_TARGET_COUNT)
 756                                 continue;
 757
 758                         // check for request from device fd
 759                         for(k = 0; g_touch_dev[k].fd != ARRAY_END; k++)
 760                         {
 761                                 if(g_touch_dev[k].fd >= 0 &&
 762                                                 events[i].data.fd == g_touch_dev[k].fd)
 763                                 {
 764                                         if(deviceEventHandler(&g_touch_dev[k], INPUT_ID_TOUCH) < 0)
 765                                         {
 766                                                 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 767                                                 ret = -1;
 768                                                 goto END_EFD;
 769                                         }
 770                                         break;
 771                                 }
 772                         }
 773
 774                         if(g_touch_dev[k].fd != ARRAY_END)
 775                                 continue;
 776
 777                         for(k = 0; g_key_dev[k].fd != ARRAY_END; k++)
 778                         {
 779                                 if(g_key_dev[k].fd >= 0 &&
 780                                                 events[i].data.fd == g_key_dev[k].fd)
 781                                 {
 782                                         if(deviceEventHandler(&g_key_dev[k], INPUT_ID_KEY) < 0)
 783                                         {
 784                                                 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 785                                                 ret = -1;
 786                                                 goto END_EFD;
 787                                         }
 788                                         break;
 789                                 }
 790                         }
 791
 792                         if(g_key_dev[k].fd != ARRAY_END)
 793                                 continue;
 794
 795                         // connect request from target
 796                         if(events[i].data.fd == manager.target_server_socket)
 797                         {
 798                                 if(targetServerHandler(efd) < 0)        // critical error
 799                                 {
 800                                         terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 801                                         ret = -1;
 802                                         goto END_EFD;
 803                                 }
 804                         }
 805                         // connect request from host
 806                         else if(events[i].data.fd == manager.host_server_socket)
 807                         {
 808                                 int result = hostServerHandler(efd);
 809                                 if(result < 0)
 810                                 {
 811                                         terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 812                                         ret = -1;
 813                                         goto END_EFD;
 814                                 }
 815                         }
 816                         // control message from host
 817                         else if(events[i].data.fd == manager.host.control_socket)
 818                         {
 819                                 int result = controlSocketHandler(efd);
 820                                 if(result == -11)       // socket close
 821                                 {
 822                                         // close target and host socket and quit
 823                                         LOGI("host close = %d\n", manager.host.control_socket);
 824                                         ret = 0;
 825                                         goto END_EFD;
 826                                 }
 827                                 else if(result < 0)
 828                                 {
 829                                         terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 830                                         ret = -1;
 831                                         goto END_EFD;
 832                                 }
 833                         }
 834                         else if(events[i].data.fd == manager.host.data_socket)
 835                         {
 836                                 char recvBuf[32];
 837                                 recvLen = recv(manager.host.data_socket, recvBuf, 32, MSG_DONTWAIT);
 838                                 if(recvLen == 0)
 839                                 {       // close data socket
 840                                         epoll_ctl(efd, EPOLL_CTL_DEL, manager.host.data_socket, NULL);
 841                                         close(manager.host.data_socket);
 842                                         manager.host.data_socket = -1;
 843                                         // TODO: finish transfer thread
 844                                 }
 845
 846                                 LOGW("host message from data socket %d\n", recvLen);
 847                         }
 848                         // check for application launch timerfd
 849                         else if(events[i].data.fd == manager.app_launch_timerfd)
 850                         {
 851                                 // send to host timeout error message for launching application
 852                                 terminate_error("Failed to launch application", 1);
 853                                 epoll_ctl(efd, EPOLL_CTL_DEL, manager.app_launch_timerfd, NULL);
 854                                 close(manager.app_launch_timerfd);
 855                                 manager.app_launch_timerfd = -1;
 856                                 ret = -1;
 857                                 goto END_EFD;
 858                         }
 859                         // unknown socket
 860                         else
 861                         {
 862                                 // never happened
 863                                 LOGW("Unknown socket fd (%d)\n", events[i].data.fd);
 864                         }
 865                 }
 866         }
 867
 868 END_EFD:
 869         close(efd);
 870 END_EVENT:
 871         free(events);
 872 END_RETURN:
 873         return ret;
 874 }