4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
8 * Jaewon Lim <jaewon81.lim@samsung.com>
9 * Woojin Jung <woojin2.jung@samsung.com>
10 * Juyoung Kim <j0.kim@samsung.com>
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
16 * http://www.apache.org/licenses/LICENSE-2.0
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.
30 #include <stdlib.h> // for realpath
31 #include <string.h> // for strtok, strcpy, strncpy
32 #include <limits.h> // for realpath
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
46 #include <attr/xattr.h> // for fsetxattr
47 #include <sys/smack.h>
50 #include <linux/input.h>
56 #include "da_protocol.h"
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"
64 #define MAX_CONNECT_SIZE 12
65 #define MAX_APP_LAUNCH_TIME 6
68 #define MAX_FILENAME 128
70 #define ARRAY_END (-11)
72 input_dev g_key_dev[MAX_DEVICE];
73 input_dev g_touch_dev[MAX_DEVICE];
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)
81 if(fp != NULL && size > 0)
83 ret = fread((void*)buffer, sizeof(char), size, fp);
91 ret = 0; // error case
97 // get input id of given input device
98 static int get_input_id(char* inputname)
100 static int query_cmd_type = 0; // 1 if /lib/udev/input_id, 2 if udevadm
102 char buffer[BUF_SIZE];
103 char command[MAX_FILENAME];
106 // determine input_id query command
107 if(unlikely(query_cmd_type == 0))
109 if(access("/lib/udev/input_id", F_OK) == 0) // there is /lib/udev/input_id
113 else // there is not /lib/udev/input_id
119 // make command string
120 if(query_cmd_type == 1)
122 sprintf(command, "/lib/udev/input_id /class/input/%s", inputname);
126 sprintf(command, "udevadm info --name=input/%s --query=property", inputname);
130 cmd_fp = popen(command, "r");
131 _file_read(cmd_fp, buffer, BUF_SIZE);
133 // determine input id
134 if(strstr(buffer, INPUT_ID_STR_KEY)) // key
138 else if(strstr(buffer, INPUT_ID_STR_TOUCH)) // touch
140 ret = INPUT_ID_TOUCH;
142 else if(strstr(buffer, INPUT_ID_STR_KEYBOARD)) // keyboard
146 else if(strstr(buffer, INPUT_ID_STR_TABLET)) // touch (emulator)
148 ret = INPUT_ID_TOUCH;
156 // get filename and fd of given input type devices
157 static void _get_fds(input_dev *dev, int input_id)
163 dp = opendir("/sys/class/input");
167 while((d = readdir(dp)) != NULL)
169 if(!strncmp(d->d_name, "event", 5)) // start with "event"
172 if(input_id == get_input_id(d->d_name))
174 sprintf(dev[count].fileName, "/dev/input/%s", d->d_name);
175 dev[count].fd = open(dev[count].fileName, O_RDWR | O_NONBLOCK);
183 dev[count].fd = ARRAY_END; // end of input_dev array
187 void _device_write(input_dev *dev, struct input_event* in_ev)
190 for(i = 0; dev[i].fd != ARRAY_END; i++)
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));
200 long long get_total_alloc_size()
203 long long allocsize = 0;
205 for(i = 0; i < MAX_TARGET_COUNT; i++)
207 if(manager.target[i].socket != -1 && manager.target[i].allocmem > 0)
208 allocsize += manager.target[i].allocmem;
213 static int getEmptyTargetSlot()
216 for(i = 0; i < MAX_TARGET_COUNT; i++)
218 if(manager.target[i].socket == -1)
225 static void setEmptyTargetSlot(int index)
227 if(index >= 0 && index < MAX_TARGET_COUNT)
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;
243 // ======================================================================================
244 // send functions to host
245 // ======================================================================================
247 int pseudoSendDataToHost(struct msg_data_t* log)
250 printBuf((char *)log, MSG_DATA_HDR_LEN + log->len);
251 /* LOGI("try send to <%d><%s>\n", dev->fd, dev->fileName); */
258 int sendDataToHost(msg_t* log)
260 if (manager.host.data_socket != -1)
262 char logstr[DA_MSG_MAX];
266 loglen = sprintf(logstr, "%d|%d|%s\n", log->type, log->length + 1, log->data);
268 loglen = sprintf(logstr, "%d|%d|\n", log->type, log->length + 1);
270 // loglen = sprintf(logstr, "%d|%s\n", log->type, log->data);
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));
281 // msgstr can be NULL
283 static int sendACKStrToHost(enum HostMessageType resp, char* msgstr)
285 if (manager.host.control_socket != -1)
287 char logstr[DA_MSG_MAX];
291 loglen = sprintf(logstr, "%d|%d|%s", (int)resp, strlen(msgstr), msgstr);
293 loglen = sprintf(logstr, "%d|0|", (int)resp);
295 send(manager.host.control_socket, logstr, loglen, MSG_NOSIGNAL);
305 int sendACKCodeToHost(enum HostMessageType resp, int msgcode)
308 //disabled string protocol
310 if (manager.host.control_socket != -1)
313 char logstr[DA_MSG_MAX];
316 codelen = sprintf(codestr, "%d", msgcode);
317 loglen = sprintf(logstr, "%d|%d|%s", (int)resp, codelen, codestr);
319 send(manager.host.control_socket, logstr, loglen, MSG_NOSIGNAL);
326 // ========================================================================================
327 // start and terminate control functions
328 // ========================================================================================
330 int startProfiling(long launchflag)
332 const struct app_info_t *app_info = &prof_session.app_info;
334 // remove previous screen capture files
335 remove_indir(SCREENSHOT_DIR);
336 mkdir(SCREENSHOT_DIR, 0777);
338 smack_lsetlabel(SCREENSHOT_DIR, "*", SMACK_LABEL_ACCESS);
340 manager.config_flag = launchflag;
342 if (samplingStart() < 0)
345 switch (app_info->app_type) {
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);
353 case APP_TYPE_RUNNING:
354 // TODO: nothing, it's running
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);
364 LOGE("Unknown app type %d\n", app_info->app_type);
370 if (start_replay() != 0) {
371 LOGE("Cannot start replay thread\n");
378 // terminate single target
379 // just send stop message to target process
380 static void terminate_target(int index)
384 sendlog.type = MSG_STOP;
387 if(manager.target[index].socket != -1)
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);
393 LOGI("TERMINATE send exit msg (socket %d) by terminate_target()\n", manager.target[index].socket);
398 // just send stop message to all target process
399 static void terminate_all_target()
405 sendlog.type = MSG_STOP;
408 for (i = 0; i < MAX_TARGET_COUNT; i++)
410 if(manager.target[i].socket != -1)
412 sendlen = send(manager.target[i].socket, &sendlog, sizeof(sendlog.type) + sizeof(sendlog.length), MSG_NOSIGNAL);
415 LOGI("TERMINATE send exit msg (socket %d) by terminate_all_target()\n", manager.target[i].socket);
421 // terminate all target and wait for threads
426 terminate_all_target();
428 // wait for all other thread exit
429 for(i = 0; i < MAX_TARGET_COUNT; i++)
431 if(manager.target[i].recv_thread != -1)
433 pthread_join(manager.target[i].recv_thread, NULL);
438 // terminate all profiling by critical error
439 static void terminate_error(char* errstr, int sendtohost)
443 LOGE("TERMINATE ERROR: %s\n", errstr);
446 log.type = MSG_ERROR;
447 log.length = sprintf(log.data, "%s", errstr);
448 sendDataToHost(&log);
454 // ===========================================================================================
455 // message parsing and handling functions
456 // ===========================================================================================
458 static int parseDeviceMessage(msg_t* log)
460 char eventType[MAX_FILENAME];
461 struct input_event in_ev;
473 for(i = 0; i < log->length; i++)
475 if(log->data[i] == '\n')
478 if(log->data[i] == '`') // meet separate
485 if(index == 0) // parse eventType
487 eventType[i] = log->data[i];
488 eventType[i+1] = '\0';
490 else if(index == 1) // parse in_ev.type
492 in_ev.type = in_ev.type * 10 + (log->data[i] - '0');
494 else if(index == 2) // parse in_ev.code
496 in_ev.code = in_ev.code * 10 + (log->data[i] - '0');
498 else if(index == 3) // parse in_ev.value
500 in_ev.value = in_ev.value * 10 + (log->data[i] - '0');
505 return -1; // parse error
507 if(0 == strncmp(eventType, STR_TOUCH, strlen(STR_TOUCH)))
509 _device_write(g_touch_dev, &in_ev);
511 else if(0 == strncmp(eventType, STR_KEY, strlen(STR_KEY)))
513 _device_write(g_key_dev, &in_ev);
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) */
528 /* char *barloc, *tmploc; */
529 /* char execPath[PATH_MAX]; */
531 /* if (log == NULL) */
534 /* switch (log->type) */
536 /* case MSG_REPLAY: */
537 /* sendACKStrToHost(MSG_OK, NULL); */
538 /* parseDeviceMessage(log); */
540 /* case MSG_VERSION: */
541 /* if(strcmp(PROTOCOL_VERSION, log->data) != 0) */
543 /* sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_PROTOCOL_VERSION); */
547 /* sendACKStrToHost(MSG_OK, NULL); */
550 /* case MSG_START: */
551 /* LOGI("MSG_START handling : %s\n", log->data); */
552 /* if(log->length == 0) */
554 /* sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_DATA); */
555 /* return -1; // wrong message format */
558 /* // parsing for host start status */
559 /* tmploc = log->data; */
560 /* barloc = strchr(tmploc, '|'); */
561 /* if(barloc == NULL) */
563 /* sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_FORMAT); */
564 /* return -1; // wrong message format */
567 /* // parsing for target launch option flag */
568 /* tmploc = barloc + 1; */
569 /* barloc = strchr(tmploc, '|'); */
570 /* if(barloc != NULL) */
572 /* while(tmploc < barloc) */
574 /* flag = (flag * 10) + (*tmploc - '0'); */
580 /* sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_FORMAT); */
581 /* return -1; // wrong message format */
583 /* LOGI("launch flag : %lx\n", flag); */
585 /* // parsing for application package name */
586 /* tmploc = barloc + 1; */
587 /* strcpy(manager.appPath, tmploc); */
589 /* get_executable(manager.appPath, execPath, PATH_MAX); // get exact app executable file name */
590 /* LOGI("executable app path %s\n", manager.appPath); */
592 /* #ifdef RUN_APP_LOADER */
593 /* kill_app(manager.appPath); */
595 /* kill_app(execPath); */
599 /* char command[PATH_MAX]; */
600 /* struct epoll_event ev; */
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); */
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); */
616 /* if(startProfiling(flag) < 0) */
618 /* sendACKCodeToHost(MSG_NOTOK, ERR_CANNOT_START_PROFILING); */
622 /* manager.app_launch_timerfd = timerfd_create(CLOCK_REALTIME, TFD_CLOEXEC); */
623 /* if(manager.app_launch_timerfd > 0) */
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)) */
632 /* LOGE("fail to set app launch timer\n"); */
633 /* close(manager.app_launch_timerfd); */
634 /* manager.app_launch_timerfd = -1; */
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) */
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; */
651 /* sendACKStrToHost(MSG_OK, NULL); */
654 /* LOGI("MSG_STOP handling\n"); */
655 /* sendACKStrToHost(MSG_OK, NULL); */
656 /* terminate_all(); */
658 /* case MSG_OPTION: */
659 /* if(log->length > 0) */
663 /* manager.config_flag = atoi(log->data); */
664 /* sendACKStrToHost(MSG_OK, NULL); */
666 /* LOGI("MSG_OPTION : str(%s), flag(%x)\n", log->data, manager.config_flag); */
668 /* sendlog.type = MSG_OPTION; */
669 /* sendlog.length = sprintf(sendlog.data, "%u", manager.config_flag); */
671 /* for(i = 0; i < MAX_TARGET_COUNT; i++) */
673 /* if(manager.target[i].socket != -1) */
675 /* send(manager.target[i].socket, &sendlog, sizeof(sendlog.type) + sizeof(sendlog.length) + sendlog.length, MSG_NOSIGNAL); */
681 /* sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_DATA); */
685 /* case MSG_ISALIVE: */
686 /* sendACKStrToHost(MSG_OK, NULL); */
689 /* LOGW("Unknown msg\n"); */
690 /* sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_TYPE); */
697 // ========================================================================================
698 // socket and event_fd handling functions
699 // ========================================================================================
701 // return 0 if normal case
702 // return plus value if non critical error occur
703 // return minus value if critical error occur
705 static int deviceEventHandler(input_dev* dev, int input_type)
708 struct input_event in_ev;
711 if(input_type == INPUT_ID_TOUCH)
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);
721 else if(input_type == INPUT_ID_KEY)
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);
733 LOGW("unknown input_type\n");
741 #define MAX_EVENTS_NUM 10
742 static int deviceEventHandler(input_dev* dev, int input_type)
747 struct input_event in_ev[MAX_EVENTS_NUM];
748 struct msg_data_t *log;
750 if(input_type == INPUT_ID_TOUCH || input_type == INPUT_ID_KEY)
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);
758 } while (count < MAX_EVENTS_NUM && size > 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);
769 LOGW("unknown input_type\n");
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)
783 manager.target[index].initial_log = 1;
786 if(msg & EVENT_STOP || msg & EVENT_ERROR)
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);
791 epoll_ctl(epollfd, EPOLL_CTL_DEL, manager.target[index].event_fd, NULL);
792 setEmptyTargetSlot(index);
793 if (0 == __sync_sub_and_fetch(&manager.target_count, 1)) // all target client are closed
800 // return 0 if normal case
801 // return plus value if non critical error occur
802 // return minus value if critical error occur
803 static int targetServerHandler(int efd)
806 struct epoll_event ev;
808 int index = getEmptyTargetSlot();
809 if(index == MAX_TARGET_COUNT)
811 LOGW("Max target number(8) reached, no more target can connected\n");
815 manager.target[index].socket = accept(manager.target_server_socket, NULL, NULL);
817 if(manager.target[index].socket >= 0) // accept succeed
820 // set smack attribute for certification
821 fsetxattr(manager.target[index].socket, "security.SMACK64IPIN", "*", 1, 0);
822 fsetxattr(manager.target[index].socket, "security.SMACK64IPOUT", "*", 1, 0);
823 #endif /* LOCALTEST */
825 // send config message to target process
826 log.type = MSG_OPTION;
827 log.length = sprintf(log.data, "%u", manager.config_flag);
828 send(manager.target[index].socket, &log, sizeof(log.type) + sizeof(log.length) + log.length, MSG_NOSIGNAL);
831 manager.target[index].event_fd = eventfd(0, EFD_NONBLOCK);
832 if(manager.target[index].event_fd == -1)
834 // fail to make event fd
835 LOGE("fail to make event fd for socket (%d)\n", manager.target[index].socket);
836 goto TARGET_CONNECT_FAIL;
839 // add event fd to epoll list
841 ev.data.fd = manager.target[index].event_fd;
842 if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.target[index].event_fd, &ev) < 0)
844 // fail to add event fd
845 LOGE("fail to add event fd to epoll list for socket (%d)\n", manager.target[index].socket);
846 goto TARGET_CONNECT_FAIL;
849 // make recv thread for target
850 if(makeRecvThread(index) != 0)
852 // fail to make recv thread
853 LOGE("fail to make recv thread for socket (%d)\n", manager.target[index].socket);
854 epoll_ctl(efd, EPOLL_CTL_DEL, manager.target[index].event_fd, NULL);
855 goto TARGET_CONNECT_FAIL;
858 if(manager.app_launch_timerfd >= 0)
860 epoll_ctl(efd, EPOLL_CTL_DEL, manager.app_launch_timerfd, NULL);
861 close(manager.app_launch_timerfd);
862 manager.app_launch_timerfd = -1;
865 LOGI("target connected = %d(running %d target)\n",
866 manager.target[index].socket, manager.target_count + 1);
868 manager.target_count++;
873 LOGE("Failed to accept at target server socket\n");
877 if(manager.target_count == 0) // if this connection is main connection
881 else // if this connection is not main connection then ignore process by error
883 setEmptyTargetSlot(index);
888 // return 0 if normal case
889 // return plus value if non critical error occur
890 // return minus value if critical error occur
891 static int hostServerHandler(int efd)
893 static int hostserverorder = 0;
895 struct epoll_event ev;
897 if(hostserverorder > 1) // control and data socket connected already
900 csocket = accept(manager.host_server_socket, NULL, NULL);
902 if(csocket >= 0) // accept succeed
905 ev.data.fd = csocket;
906 if(epoll_ctl(efd, EPOLL_CTL_ADD, csocket, &ev) < 0)
908 // consider as accept fail
909 LOGE("Failed to add socket fd to epoll list\n");
914 if(hostserverorder == 0)
916 manager.host.control_socket = csocket;
918 LOGI("host control socket connected = %d\n", csocket);
922 manager.host.data_socket = csocket;
923 LOGI("host data socket connected = %d\n", csocket);
931 LOGE("Failed to accept from host server socket\n");
937 //TODO del it or move to debug section
938 void printBuf (char * buf, int len)
942 char local_buf[3*16 + 2*16 + 1];
945 for ( i = 0; i < len/16 + 1; i++)
947 memset(local_buf, ' ', 5*16);
949 p2 = local_buf + 3*17;
950 for ( j = 0; j < 16; j++)
953 sprintf(p1, "%02X ",(unsigned char) *buf);
956 sprintf(p2, "%c ",(int)*buf);
965 LOGI("%s\n",local_buf);
971 // return 0 if normal case
972 // return plus value if non critical error occur
973 // return minus value if critical error occur
974 // return -11 if socket closed
976 static int controlSocketHandler(int efd)
983 recv_len = recv(manager.host.control_socket,
986 // error or close request from host
987 if (recv_len == -1 || recv_len == 0)
991 msg.payload = malloc(msg.len);
993 LOGE("Cannot alloc msg payload\n");
994 sendACKCodeToHost(MSG_NOTOK, ERR_WRONG_MESSAGE_FORMAT);
997 // Receive payload (if exists)
998 recv_len = recv(manager.host.control_socket,
1000 msg.len, MSG_WAITALL);
1002 res = host_message_handler(&msg);
1009 // return 0 for normal case
1012 int ret = 0; // return value
1016 struct epoll_event ev, *events;
1017 int efd; // epoll fd
1018 int numevent; // number of occured events
1020 _get_fds(g_key_dev, INPUT_ID_KEY);
1021 _get_fds(g_touch_dev, INPUT_ID_TOUCH);
1023 // initialize epoll event pool
1024 events = (struct epoll_event*) malloc(sizeof(struct epoll_event) * EPOLL_SIZE);
1027 LOGE("Out of memory when allocate epoll event pool\n");
1031 if((efd = epoll_create(MAX_CONNECT_SIZE)) < 0)
1033 LOGE("epoll creation error\n");
1038 // add server sockets to epoll event pool
1039 ev.events = EPOLLIN;
1040 ev.data.fd = manager.host_server_socket;
1041 if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.host_server_socket, &ev) < 0)
1043 LOGE("Host server socket epoll_ctl error\n");
1047 ev.events = EPOLLIN;
1048 ev.data.fd = manager.target_server_socket;
1049 if(epoll_ctl(efd, EPOLL_CTL_ADD, manager.target_server_socket, &ev) < 0)
1051 LOGE("Target server socket epoll_ctl error\n");
1056 // add device fds to epoll event pool
1057 ev.events = EPOLLIN;
1058 for(i = 0; g_key_dev[i].fd != ARRAY_END; i++)
1060 if(g_key_dev[i].fd >= 0)
1062 ev.data.fd = g_key_dev[i].fd;
1063 if(epoll_ctl(efd, EPOLL_CTL_ADD, g_key_dev[i].fd, &ev) < 0)
1065 LOGE("keyboard device file epoll_ctl error\n");
1070 ev.events = EPOLLIN;
1071 for(i = 0; g_touch_dev[i].fd != ARRAY_END; i++)
1073 if(g_touch_dev[i].fd >= 0)
1075 ev.data.fd = g_touch_dev[i].fd;
1076 if(epoll_ctl(efd, EPOLL_CTL_ADD, g_touch_dev[i].fd, &ev) < 0)
1078 LOGE("touch device file epoll_ctl error\n");
1086 numevent = epoll_wait(efd, events, EPOLL_SIZE, -1);
1089 LOGE("Failed to epoll_wait : num of event(%d), errno(%d)\n", numevent, errno);
1093 for(i = 0; i < numevent; i++)
1095 // check for request from event fd
1096 for(k = 0; k < MAX_TARGET_COUNT; k++)
1098 if(manager.target[k].socket != -1 &&
1099 events[i].data.fd == manager.target[k].event_fd)
1102 recvLen = read(manager.target[k].event_fd, &u, sizeof(uint64_t));
1103 if(recvLen != sizeof(uint64_t))
1105 // maybe closed, but ignoring is more safe then removing fd from epoll list
1109 if(-11 == targetEventHandler(efd, k, u))
1111 LOGI("all target process is closed\n");
1119 if(k != MAX_TARGET_COUNT)
1122 // check for request from device fd
1123 for(k = 0; g_touch_dev[k].fd != ARRAY_END; k++)
1125 if(g_touch_dev[k].fd >= 0 &&
1126 events[i].data.fd == g_touch_dev[k].fd)
1128 if(deviceEventHandler(&g_touch_dev[k], INPUT_ID_TOUCH) < 0)
1130 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
1138 if(g_touch_dev[k].fd != ARRAY_END)
1141 for(k = 0; g_key_dev[k].fd != ARRAY_END; k++)
1143 if(g_key_dev[k].fd >= 0 &&
1144 events[i].data.fd == g_key_dev[k].fd)
1146 if(deviceEventHandler(&g_key_dev[k], INPUT_ID_KEY) < 0)
1148 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
1156 if(g_key_dev[k].fd != ARRAY_END)
1159 // connect request from target
1160 if(events[i].data.fd == manager.target_server_socket)
1162 if(targetServerHandler(efd) < 0) // critical error
1164 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
1169 // connect request from host
1170 else if(events[i].data.fd == manager.host_server_socket)
1172 int result = hostServerHandler(efd);
1175 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
1180 // control message from host
1181 else if(events[i].data.fd == manager.host.control_socket)
1183 int result = controlSocketHandler(efd);
1184 if(result == -11) // socket close
1186 // close target and host socket and quit
1187 LOGI("host close = %d\n", manager.host.control_socket);
1193 terminate_error("Internal DA framework error, Please re-run the profiling.", 1);
1198 else if(events[i].data.fd == manager.host.data_socket)
1201 recvLen = recv(manager.host.data_socket, recvBuf, 32, MSG_DONTWAIT);
1203 { // close data socket
1204 epoll_ctl(efd, EPOLL_CTL_DEL, manager.host.data_socket, NULL);
1205 close(manager.host.data_socket);
1206 manager.host.data_socket = -1;
1207 // TODO: finish transfer thread
1210 LOGW("host message from data socket %d\n", recvLen);
1212 // check for application launch timerfd
1213 else if(events[i].data.fd == manager.app_launch_timerfd)
1215 // send to host timeout error message for launching application
1216 terminate_error("Failed to launch application", 1);
1217 epoll_ctl(efd, EPOLL_CTL_DEL, manager.app_launch_timerfd, NULL);
1218 close(manager.app_launch_timerfd);
1219 manager.app_launch_timerfd = -1;
1227 LOGW("Unknown socket fd (%d)\n", events[i].data.fd);