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