daemon/daemon.c

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