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",dev[i].fd, (int)in_ev, sizeof(struct input_event));
 201                 }
 202         }
 203 }
 204
 205 long long get_total_alloc_size()
 206 {
 207         int i;
 208         long long allocsize = 0;
 209
 210         for(i = 0; i < MAX_TARGET_COUNT; i++)
 211         {
 212                 if(manager.target[i].socket != -1 && manager.target[i].allocmem > 0)
 213                         allocsize += manager.target[i].allocmem;
 214         }
 215         return allocsize;
 216 }
 217
 218 static int getEmptyTargetSlot()
 219 {
 220         int i;
 221         for(i = 0; i < MAX_TARGET_COUNT; i++)
 222         {
 223                 if(manager.target[i].socket == -1)
 224                         break;
 225         }
 226
 227         return i;
 228 }
 229
 230 static void setEmptyTargetSlot(int index)
 231 {
 232         if(index >= 0 && index < MAX_TARGET_COUNT)
 233         {
 234                 manager.target[index].pid = -1;
 235                 manager.target[index].recv_thread = -1;
 236                 manager.target[index].allocmem = 0;
 237                 manager.target[index].starttime = 0;
 238                 manager.target[index].initial_log = 0;
 239                 if(manager.target[index].event_fd != -1)
 240                         close(manager.target[index].event_fd);
 241                 manager.target[index].event_fd = -1;
 242                 if(manager.target[index].socket != -1)
 243                         close(manager.target[index].socket);
 244                 manager.target[index].socket = -1;
 245         }
 246 }
 247
 248 // ======================================================================================
 249 // send functions to host
 250 // ======================================================================================
 251
 252 //static
 253 int sendACKCodeToHost(enum HostMessageType resp, int msgcode)
 254 {
 255         // FIXME:
 256         //disabled string protocol
 257         return 0;
 258         if (manager.host.control_socket != -1)
 259         {
 260                 char codestr[16];
 261                 char logstr[DA_MSG_MAX];
 262                 int loglen, codelen;
 263
 264                 codelen = sprintf(codestr, "%d", msgcode);
 265                 loglen = sprintf(logstr, "%d|%d|%s", (int)resp, codelen, codestr);
 266
 267                 send(manager.host.control_socket, logstr, loglen, MSG_NOSIGNAL);
 268                 return 0;
 269         }
 270         else
 271                 return 1;
 272 }
 273
 274 // ========================================================================================
 275 // start and terminate control functions
 276 // ========================================================================================
 277
 278 static int exec_app(const struct app_info_t *app_info)
 279 {
 280         int res = 0;
 281         static struct epoll_event ev;
 282
 283
 284         switch (app_info->app_type) {
 285         case APP_TYPE_TIZEN:
 286                 kill_app(app_info->exe_path);
 287                 if (exec_app_tizen(app_info->app_id, app_info->exe_path)) {
 288                         LOGE("Cannot exec tizen app %s\n", app_info->app_id);
 289                         res = -1;
 290                 }
 291                 break;
 292         case APP_TYPE_RUNNING:
 293                 // TODO: nothing, it's running
 294                 LOGI("already started\n");
 295                 write_process_info(atoi(app_info->app_id), 0);
 296                 break;
 297         case APP_TYPE_COMMON:
 298                 kill_app(app_info->exe_path);
 299                 if (exec_app_common(app_info->exe_path)) {
 300                         LOGE("Cannot exec common app %s\n", app_info->exe_path);
 301                         res = -1;
 302                 }
 303                 break;
 304         default:
 305                 LOGE("Unknown app type %d\n", app_info->app_type);
 306                 res = -1;
 307                 break;
 308         }
 309
 310         if (res == 0 && app_info->app_type != APP_TYPE_RUNNING) {
 311                 manager.app_launch_timerfd = timerfd_create(CLOCK_REALTIME, TFD_CLOEXEC);
 312                 if(manager.app_launch_timerfd > 0)
 313                 {
 314                         struct itimerspec ctime;
 315                         ctime.it_value.tv_sec = MAX_APP_LAUNCH_TIME;
 316                         ctime.it_value.tv_nsec = 0;
 317                         ctime.it_interval.tv_sec = 0;
 318                         ctime.it_interval.tv_nsec = 0;
 319                         if (timerfd_settime(manager.app_launch_timerfd, 0, &ctime, NULL) < 0)
 320                         {
 321                                 LOGE("fail to set app launch timer\n");
 322                                 close(manager.app_launch_timerfd);
 323                                 manager.app_launch_timerfd = -1;
 324                         }
 325                         else
 326                         {
 327                                 // add event fd to epoll list
 328                                 ev.events = EPOLLIN;
 329                                 ev.data.fd = manager.app_launch_timerfd;
 330                                 if(epoll_ctl(manager.efd, EPOLL_CTL_ADD, manager.app_launch_timerfd, &ev) < 0)
 331                                 {
 332                                         // fail to add event fd
 333                                         LOGE("fail to add app launch timer fd to epoll list\n");
 334                                         close(manager.app_launch_timerfd);
 335                                         manager.app_launch_timerfd = -1;
 336                                 } else {
 337                                         LOGI("application launch time started\n");
 338                                 }
 339                         }
 340                 } else {
 341                         LOGE("cannot create launch timer\n");
 342                 }
 343         }
 344
 345         LOGI("ret=%d\n", res);
 346         return res;
 347 }
 348
 349 static void epoll_add_input_events();
 350 static void epoll_del_input_events();
 351
 352 int start_profiling()
 353 {
 354         const struct app_info_t *app_info = &prof_session.app_info;
 355         int res = 0;
 356
 357         // remove previous screen capture files
 358         remove_indir(SCREENSHOT_DIR);
 359         mkdir(SCREENSHOT_DIR, 0777);
 360 #ifndef LOCALTEST
 361         smack_lsetlabel(SCREENSHOT_DIR, "*", SMACK_LABEL_ACCESS);
 362 #endif
 363
 364         if (IS_OPT_SET(FL_CPU | FL_MEMORY)) {
 365                 if (samplingStart() < 0) {
 366                         LOGE("Cannot start sampling\n");
 367                         res = -1;
 368                         goto exit;
 369                 }
 370         }
 371
 372         if (IS_OPT_SET(FL_RECORDING))
 373                 epoll_add_input_events();
 374
 375         if (exec_app(app_info)) {
 376                 LOGE("Cannot exec app\n");
 377                 res = -1;
 378                 goto recording_stop;
 379         }
 380
 381         goto exit;
 382
 383 recording_stop:
 384         if (IS_OPT_SET(FL_RECORDING))
 385                 epoll_del_input_events();
 386         if (IS_OPT_SET(FL_CPU | FL_MEMORY))
 387                 samplingStop();
 388
 389 exit:
 390         LOGI("return %d\n", res);
 391         return res;
 392 }
 393
 394 void stop_profiling(void)
 395 {
 396         if (IS_OPT_SET(FL_RECORDING))
 397                 epoll_del_input_events();
 398         if (IS_OPT_SET(FL_CPU | FL_MEMORY))
 399                 samplingStop();
 400 }
 401
 402 static void reconfigure_recording(struct conf_t conf)
 403 {
 404         uint64_t old_features = prof_session.conf.use_features;
 405         uint64_t new_features = conf.use_features;
 406         uint64_t to_enable = (new_features ^ old_features) & new_features;
 407         uint64_t to_disable = (new_features ^ old_features) & old_features;
 408
 409         if (IS_OPT_SET_IN(FL_RECORDING, to_disable)) {
 410                 epoll_del_input_events();
 411                 prof_session.conf.use_features &= ~FL_RECORDING;
 412         }
 413
 414         if (IS_OPT_SET_IN(FL_RECORDING, to_enable)) {
 415                 epoll_add_input_events();
 416                 prof_session.conf.use_features |= FL_RECORDING;
 417         }
 418
 419 }
 420
 421 static int reconfigure_cpu_and_memory(struct conf_t conf)
 422 {
 423         uint64_t old_features = prof_session.conf.use_features;
 424         uint64_t new_features = conf.use_features;
 425         uint64_t to_enable = (new_features ^ old_features) & new_features;
 426         uint64_t to_disable = (new_features ^ old_features) & old_features;
 427
 428         prof_session.conf.system_trace_period = conf.system_trace_period;
 429
 430         if (IS_OPT_SET(FL_CPU | FL_MEMORY))
 431                 samplingStop();
 432
 433         if (IS_OPT_SET_IN(FL_CPU | FL_MEMORY, to_disable)) {
 434                 prof_session.conf.use_features &= ~(FL_CPU | FL_MEMORY);
 435                 return 0;
 436         }
 437
 438         if (IS_OPT_SET_IN(FL_CPU | FL_MEMORY, to_enable)) {
 439                 if (samplingStart() < 0) {
 440                         LOGE("Cannot start sampling\n");
 441                         return -1;
 442                 }
 443                 prof_session.conf.use_features |= (FL_CPU | FL_MEMORY);
 444         }
 445
 446         return 0;
 447 }
 448
 449 int reconfigure(struct conf_t conf)
 450 {
 451         reconfigure_recording(conf);
 452         if (reconfigure_cpu_and_memory(conf)) {
 453                 LOGE("Cannot reconf cpu and memory\n");
 454                 return -1;
 455         }
 456
 457         return 0;
 458 }
 459
 460 // just send stop message to all target process
 461 static void terminate_all_target()
 462 {
 463         int i;
 464         ssize_t sendlen;
 465         msg_target_t sendlog;
 466
 467         sendlog.type = MSG_STOP;
 468         sendlog.length = 0;
 469
 470         for (i = 0; i < MAX_TARGET_COUNT; i++)
 471         {
 472                 if(manager.target[i].socket != -1)
 473                 {
 474                         sendlen = send(manager.target[i].socket, &sendlog, sizeof(sendlog.type) + sizeof(sendlog.length), MSG_NOSIGNAL);
 475                         if(sendlen != -1)
 476                         {
 477                                 LOGI("TERMINATE send exit msg (socket %d) by terminate_all_target()\n", manager.target[i].socket);
 478                         }
 479                 }
 480         }
 481 }
 482
 483 // terminate all target and wait for threads
 484 void terminate_all()
 485 {
 486         int i;
 487         terminate_all_target();
 488
 489         // wait for all other thread exit
 490         for(i = 0; i < MAX_TARGET_COUNT; i++)
 491         {
 492                 if(manager.target[i].recv_thread != -1)
 493                 {
 494                         pthread_join(manager.target[i].recv_thread, NULL);
 495                 }
 496         }
 497 }
 498
 499 // terminate all profiling by critical error
 500 // TODO: don't send data to host
 501 static void terminate_error(char* errstr, int send_to_host)
 502 {
 503         LOGE("termination all with err '%s'\n", errstr);
 504         struct msg_data_t *msg = NULL;
 505         if (send_to_host != 0){
 506                 msg = gen_message_error(errstr);
 507                 if (msg) {
 508                         write_to_buf(msg);
 509                         free_msg_data(msg);
 510                 } else {
 511                         LOGI("cannot generate error message\n");
 512                 }
 513         }
 514         terminate_all();
 515 }
 516
 517 #define MAX_EVENTS_NUM 10
 518 static int deviceEventHandler(input_dev* dev, int input_type)
 519 {
 520         int ret = 0;
 521         ssize_t size = 0;
 522         int count = 0;
 523         struct input_event in_ev[MAX_EVENTS_NUM];
 524         struct msg_data_t *log;
 525
 526         if(input_type == INPUT_ID_TOUCH || input_type == INPUT_ID_KEY)
 527         {
 528                 do {
 529                         size = read(dev->fd, &in_ev[count], sizeof(*in_ev) );
 530                         if (size >0)
 531                                 count++;
 532                 } while (count < MAX_EVENTS_NUM && size > 0);
 533
 534                 if (count) {
 535                         LOGI("read %d %s events\n",
 536                              count,
 537                              input_type == INPUT_ID_KEY ? STR_KEY : STR_TOUCH);
 538                         log = gen_message_event(in_ev, count, input_type);
 539                         printBuf((char *)log, MSG_DATA_HDR_LEN + log->len);
 540                         write_to_buf(log);
 541                         free_msg_data(log);
 542                 }
 543         }
 544         else
 545         {
 546                 LOGW("unknown input_type\n");
 547                 ret = 1;
 548         }
 549         return ret;
 550 }
 551
 552 // return 0 if normal case
 553 // return plus value if non critical error occur
 554 // return minus value if critical error occur
 555 // return -11 if all target process closed
 556 static int targetEventHandler(int epollfd, int index, uint64_t msg)
 557 {
 558         if(msg & EVENT_PID)
 559         {
 560                 if (index == 0) { // main application
 561                         if (start_replay() != 0) {
 562                                 LOGE("Cannot start replay thread\n");
 563                                 return -1;
 564                         }
 565                 }
 566                 manager.target[index].initial_log = 1;
 567         }
 568
 569         if(msg & EVENT_STOP || msg & EVENT_ERROR)
 570         {
 571                 LOGI("target close, socket(%d), pid(%d) : (remaining %d target)\n",
 572                      manager.target[index].socket,
 573                      manager.target[index].pid,
 574                      manager.target_count - 1);
 575                 if (index == 0) { // main application
 576                         stop_replay();
 577                 }
 578                 epoll_ctl(epollfd, EPOLL_CTL_DEL, manager.target[index].event_fd, NULL);
 579                 setEmptyTargetSlot(index);
 580                 if (0 == __sync_sub_and_fetch(&manager.target_count, 1)) // all target client are closed
 581                         return -11;
 582         }
 583
 584         return 0;
 585 }
 586
 587 // return 0 if normal case
 588 // return plus value if non critical error occur
 589 // return minus value if critical error occur
 590 static int targetServerHandler(int efd)
 591 {
 592         msg_target_t log;
 593         struct epoll_event ev;
 594
 595         int index = getEmptyTargetSlot();
 596         if(index == MAX_TARGET_COUNT)
 597         {
 598                 LOGW("Max target number(8) reached, no more target can connected\n");
 599                 return 1;
 600         }
 601
 602         manager.target[index].socket = accept(manager.target_server_socket, NULL, NULL);
 603
 604         if(manager.target[index].socket >= 0)   // accept succeed
 605         {
 606 #ifndef LOCALTEST
 607                 // set smack attribute for certification
 608                 fsetxattr(manager.target[index].socket, "security.SMACK64IPIN", "*", 1, 0);
 609                 fsetxattr(manager.target[index].socket, "security.SMACK64IPOUT", "*", 1, 0);
 610 #endif /* LOCALTEST */
 611
 612                 // send config message to target process
 613                 log.type = MSG_OPTION;
 614                 log.length = sprintf(log.data, "%u",
 615                                      prof_session.conf.use_features);
 616                 send(manager.target[index].socket, &log,
 617                      sizeof(log.type) + sizeof(log.length) + log.length,
 618                      MSG_NOSIGNAL);
 619
 620                 // make event fd
 621                 manager.target[index].event_fd = eventfd(0, EFD_NONBLOCK);
 622                 if(manager.target[index].event_fd == -1)
 623                 {
 624                         // fail to make event fd
 625                         LOGE("fail to make event fd for socket (%d)\n", manager.target[index].socket);
 626                         goto TARGET_CONNECT_FAIL;
 627                 }
 628
 629                 // add event fd to epoll list
 630                 ev.events = EPOLLIN;
 631                 ev.data.fd = manager.target[index].event_fd;
 632                 if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.target[index].event_fd, &ev) < 0)
 633                 {
 634                         // fail to add event fd
 635                         LOGE("fail to add event fd to epoll list for socket (%d)\n", manager.target[index].socket);
 636                         goto TARGET_CONNECT_FAIL;
 637                 }
 638
 639                 // make recv thread for target
 640                 if(makeRecvThread(index) != 0)
 641                 {
 642                         // fail to make recv thread
 643                         LOGE("fail to make recv thread for socket (%d)\n", manager.target[index].socket);
 644                         epoll_ctl(efd, EPOLL_CTL_DEL, manager.target[index].event_fd, NULL);
 645                         goto TARGET_CONNECT_FAIL;
 646                 }
 647
 648                 if(manager.app_launch_timerfd >= 0)
 649                 {
 650                         LOGI("release launch timer\n");
 651                         epoll_ctl(efd, EPOLL_CTL_DEL, manager.app_launch_timerfd, NULL);
 652                         close(manager.app_launch_timerfd);
 653                         manager.app_launch_timerfd = -1;
 654                 }
 655
 656                 LOGI("target connected = %d(running %d target)\n",
 657                                 manager.target[index].socket, manager.target_count + 1);
 658
 659                 manager.target_count++;
 660                 return 0;
 661         }
 662         else    // accept error
 663         {
 664                 LOGE("Failed to accept at target server socket\n");
 665         }
 666
 667 TARGET_CONNECT_FAIL:
 668         if(manager.target_count == 0)   // if this connection is main connection
 669         {
 670                 return -1;
 671         }
 672         else    // if this connection is not main connection then ignore process by error
 673         {
 674                 setEmptyTargetSlot(index);
 675                 return 1;
 676         }
 677 }
 678
 679 // return 0 if normal case
 680 // return plus value if non critical error occur
 681 // return minus value if critical error occur
 682 static int hostServerHandler(int efd)
 683 {
 684         static int hostserverorder = 0;
 685         int csocket;
 686         struct epoll_event ev;
 687
 688         if(hostserverorder > 1) // control and data socket connected already
 689                 return 1;                       // ignore
 690
 691         csocket = accept(manager.host_server_socket, NULL, NULL);
 692
 693         if(csocket >= 0)                // accept succeed
 694         {
 695                 ev.events = EPOLLIN;
 696                 ev.data.fd = csocket;
 697                 if(epoll_ctl(efd, EPOLL_CTL_ADD, csocket, &ev) < 0)
 698                 {
 699                         // consider as accept fail
 700                         LOGE("Failed to add socket fd to epoll list\n");
 701                         close(csocket);
 702                         return -1;
 703                 }
 704
 705                 if(hostserverorder == 0)
 706                 {
 707                         manager.host.control_socket = csocket;
 708                         unlink_portfile();
 709                         LOGI("host control socket connected = %d\n", csocket);
 710                 }
 711                 else
 712                 {
 713                         manager.host.data_socket = csocket;
 714                         LOGI("host data socket connected = %d\n", csocket);
 715                 }
 716
 717                 hostserverorder++;
 718                 return 0;
 719         }
 720         else    // accept error
 721         {
 722                 LOGE("Failed to accept from host server socket\n");
 723                 return -1;
 724         }
 725 }
 726
 727
 728 // return 0 if normal case
 729 // return plus value if non critical error occur
 730 // return minus value if critical error occur
 731 // return -11 if socket closed
 732
 733 static int controlSocketHandler(int efd)
 734 {
 735         ssize_t recv_len;
 736         struct msg_t msg_head;
 737         struct msg_t *msg;
 738         int res = 0;
 739
 740         // Receive header
 741         recv_len = recv(manager.host.control_socket,
 742                        &msg_head,
 743                        MSG_CMD_HDR_LEN, 0);
 744         // error or close request from host
 745         if (recv_len == -1 || recv_len == 0)
 746                 return -11;
 747         else {
 748                 msg = malloc(MSG_CMD_HDR_LEN + msg_head.len);
 749                 if (!msg) {
 750                         LOGE("Cannot alloc msg\n");
 751                         sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_FORMAT);
 752                         return -1;
 753                 }
 754                 msg->id = msg_head.id;
 755                 msg->len = msg_head.len;
 756                 if (msg->len > 0) {
 757                         // Receive payload (if exists)
 758                         recv_len = recv(manager.host.control_socket,
 759                                         msg->payload,
 760                                         msg->len, MSG_WAITALL);
 761                         if (recv_len == -1)
 762                                 return -11;
 763                 }
 764                 res = host_message_handler(msg);
 765                 free(msg);
 766         }
 767
 768         return res;
 769 }
 770
 771 static void epoll_add_input_events()
 772 {
 773         struct epoll_event ev;
 774         int i;
 775
 776         // add device fds to epoll event pool
 777         ev.events = EPOLLIN;
 778         for (i = 0; g_key_dev[i].fd != ARRAY_END; i++) {
 779                 if (g_key_dev[i].fd >= 0) {
 780                         ev.data.fd = g_key_dev[i].fd;
 781                         if (epoll_ctl(manager.efd,
 782                                       EPOLL_CTL_ADD,
 783                                       g_key_dev[i].fd, &ev) < 0)
 784                                 LOGE("keyboard device file epoll_ctl error\n");
 785                 }
 786         }
 787
 788         ev.events = EPOLLIN;
 789         for (i = 0; g_touch_dev[i].fd != ARRAY_END; i++) {
 790                 if (g_touch_dev[i].fd >= 0) {
 791                         ev.data.fd = g_touch_dev[i].fd;
 792                         if (epoll_ctl(manager.efd,
 793                                       EPOLL_CTL_ADD,
 794                                       g_touch_dev[i].fd, &ev) < 0)
 795                                 LOGE("touch device file epoll_ctl error\n");
 796                 }
 797         }
 798 }
 799
 800 static void epoll_del_input_events()
 801 {
 802         int i;
 803
 804         // remove device fds from epoll event pool
 805         for (i = 0; g_key_dev[i].fd != ARRAY_END; i++)
 806                 if (g_key_dev[i].fd >= 0)
 807                         if (epoll_ctl(manager.efd,
 808                                       EPOLL_CTL_DEL,
 809                                       g_key_dev[i].fd, NULL) < 0)
 810                                 LOGE("keyboard device file epoll_ctl error\n");
 811
 812         for (i = 0; g_touch_dev[i].fd != ARRAY_END; i++)
 813                 if (g_touch_dev[i].fd >= 0)
 814                         if (epoll_ctl(manager.efd,
 815                                       EPOLL_CTL_DEL,
 816                                       g_touch_dev[i].fd, NULL) < 0)
 817                                 LOGE("touch device file epoll_ctl error\n");
 818 }
 819
 820 // return 0 for normal case
 821 int daemonLoop()
 822 {
 823         int                     ret = 0;                                // return value
 824         int                     i, k;
 825         ssize_t         recvLen;
 826
 827         struct epoll_event ev, *events;
 828         int numevent;   // number of occured events
 829
 830         _get_fds(g_key_dev, INPUT_ID_KEY);
 831         _get_fds(g_touch_dev, INPUT_ID_TOUCH);
 832
 833         // initialize epoll event pool
 834         events = (struct epoll_event*) malloc(sizeof(struct epoll_event) * EPOLL_SIZE);
 835         if(events == NULL)
 836         {
 837                 LOGE("Out of memory when allocate epoll event pool\n");
 838                 ret = -1;
 839                 goto END_RETURN;
 840         }
 841         if((manager.efd = epoll_create(MAX_CONNECT_SIZE)) < 0)
 842         {
 843                 LOGE("epoll creation error\n");
 844                 ret = -1;
 845                 goto END_EVENT;
 846         }
 847
 848         // add server sockets to epoll event pool
 849         ev.events = EPOLLIN;
 850         ev.data.fd = manager.host_server_socket;
 851         if (epoll_ctl(manager.efd, EPOLL_CTL_ADD,
 852                      manager.host_server_socket, &ev) < 0)
 853         {
 854                 LOGE("Host server socket epoll_ctl error\n");
 855                 ret = -1;
 856                 goto END_EFD;
 857         }
 858         ev.events = EPOLLIN;
 859         ev.data.fd = manager.target_server_socket;
 860         if (epoll_ctl(manager.efd, EPOLL_CTL_ADD,
 861                       manager.target_server_socket, &ev) < 0)
 862         {
 863                 LOGE("Target server socket epoll_ctl error\n");
 864                 ret = -1;
 865                 goto END_EFD;
 866         }
 867
 868         // handler loop
 869         while (1)
 870         {
 871                 numevent = epoll_wait(manager.efd, events, EPOLL_SIZE, -1);
 872                 if(numevent <= 0)
 873                 {
 874                         LOGE("Failed to epoll_wait : num of event(%d), errno(%d)\n", numevent, errno);
 875                         continue;
 876                 }
 877
 878                 for(i = 0; i < numevent; i++)
 879                 {
 880                         // check for request from event fd
 881                         for(k = 0; k < MAX_TARGET_COUNT; k++)
 882                         {
 883                                 if(manager.target[k].socket != -1 &&
 884                                                 events[i].data.fd == manager.target[k].event_fd)
 885                                 {
 886                                         uint64_t u;
 887                                         recvLen = read(manager.target[k].event_fd, &u, sizeof(uint64_t));
 888                                         if(recvLen != sizeof(uint64_t))
 889                                         {
 890                                                 // maybe closed, but ignoring is more safe then removing fd from epoll list
 891                                         }
 892                                         else
 893                                         {
 894                                                 if(-11 == targetEventHandler(manager.efd, k, u))
 895                                                 {
 896                                                         LOGI("all target process is closed\n");
 897                                                         continue;
 898                                                 }
 899                                         }
 900                                         break;
 901                                 }
 902                         }
 903
 904                         if(k != MAX_TARGET_COUNT)
 905                                 continue;
 906
 907                         // check for request from device fd
 908                         for(k = 0; g_touch_dev[k].fd != ARRAY_END; k++)
 909                         {
 910                                 if(g_touch_dev[k].fd >= 0 &&
 911                                                 events[i].data.fd == g_touch_dev[k].fd)
 912                                 {
 913                                         if(deviceEventHandler(&g_touch_dev[k], INPUT_ID_TOUCH) < 0)
 914                                         {
 915                                                 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 916                                                 ret = -1;
 917                                                 goto END_EFD;
 918                                         }
 919                                         break;
 920                                 }
 921                         }
 922
 923                         if(g_touch_dev[k].fd != ARRAY_END)
 924                                 continue;
 925
 926                         for(k = 0; g_key_dev[k].fd != ARRAY_END; k++)
 927                         {
 928                                 if(g_key_dev[k].fd >= 0 &&
 929                                                 events[i].data.fd == g_key_dev[k].fd)
 930                                 {
 931                                         if(deviceEventHandler(&g_key_dev[k], INPUT_ID_KEY) < 0)
 932                                         {
 933                                                 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 934                                                 ret = -1;
 935                                                 goto END_EFD;
 936                                         }
 937                                         break;
 938                                 }
 939                         }
 940
 941                         if(g_key_dev[k].fd != ARRAY_END)
 942                                 continue;
 943
 944                         // connect request from target
 945                         if(events[i].data.fd == manager.target_server_socket)
 946                         {
 947                                 if(targetServerHandler(manager.efd) < 0)        // critical error
 948                                 {
 949                                         terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 950                                         ret = -1;
 951                                         goto END_EFD;
 952                                 }
 953                         }
 954                         // connect request from host
 955                         else if(events[i].data.fd == manager.host_server_socket)
 956                         {
 957                                 int result = hostServerHandler(manager.efd);
 958                                 if(result < 0)
 959                                 {
 960                                         terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 961                                         ret = -1;
 962                                         goto END_EFD;
 963                                 }
 964                         }
 965                         // control message from host
 966                         else if(events[i].data.fd == manager.host.control_socket)
 967                         {
 968                                 int result = controlSocketHandler(manager.efd);
 969                                 if(result == -11)       // socket close
 970                                 {
 971                                         // close target and host socket and quit
 972                                         LOGI("host close = %d\n", manager.host.control_socket);
 973                                         ret = 0;
 974                                         goto END_EFD;
 975                                 }
 976                                 else if(result < 0)
 977                                 {
 978                                         terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
 979                                         ret = -1;
 980                                         goto END_EFD;
 981                                 }
 982                         }
 983                         else if(events[i].data.fd == manager.host.data_socket)
 984                         {
 985                                 char recvBuf[32];
 986                                 recvLen = recv(manager.host.data_socket, recvBuf, 32, MSG_DONTWAIT);
 987                                 if(recvLen == 0)
 988                                 {       // close data socket
 989                                         epoll_ctl(manager.efd, EPOLL_CTL_DEL,
 990                                                   manager.host.data_socket,
 991                                                   NULL);
 992                                         close(manager.host.data_socket);
 993                                         manager.host.data_socket = -1;
 994                                         // TODO: finish transfer thread
 995                                 }
 996
 997                                 LOGI("host message from data socket %d\n", recvLen);
 998                         }
 999                         // check for application launch timerfd
1000                         else if(events[i].data.fd == manager.app_launch_timerfd)
1001                         {
1002                                 // send to host timeout error message for launching application
1003                                 terminate_error("Failed to launch application", 1);
1004                                 epoll_ctl(manager.efd, EPOLL_CTL_DEL,
1005                                           manager.app_launch_timerfd, NULL);
1006                                 close(manager.app_launch_timerfd);
1007                                 manager.app_launch_timerfd = -1;
1008                                 ret = -1;
1009                                 goto END_EFD;
1010                         }
1011                         // unknown socket
1012                         else
1013                         {
1014                                 // never happened
1015                                 LOGW("Unknown socket fd (%d)\n", events[i].data.fd);
1016                         }
1017                 }
1018         }
1019
1020 END_EFD:
1021         LOGI("close efd\n");
1022         close(manager.efd);
1023 END_EVENT:
1024         free(events);
1025 END_RETURN:
1026         return ret;
1027 }