daemon/daemon.c

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