}
int ecs_write(int fd, const uint8_t *buf, int len) {
- TRACE("write buflen : %d, buf : %s", len, (char*)buf);
+ TRACE("write buflen : %d, buf : %s\n", len, (char*)buf);
if (fd < 0) {
return -1;
}
pthread_mutex_lock(&mutex_clilist);
if (clii->client_fd > 0) {
- INFO("ecs client closed with fd: %d", clii->client_fd);
+ INFO("ecs client closed with fd: %d\n", clii->client_fd);
closesocket(clii->client_fd);
#ifndef CONFIG_LINUX
FD_CLR(clii->client_fd, &clii->cs->reads);
}
bool send_to_all_client(const char* data, const int len) {
- TRACE("data len: %d, data: %s", len, data);
+ TRACE("data len: %d, data: %s\n", len, data);
pthread_mutex_lock(&mutex_clilist);
ECS_Client *clii;
mon = g_malloc0(sizeof(*mon));
if (NULL == mon) {
- ERR("monitor allocation failed.");
+ ERR("monitor allocation failed.\n");
return NULL;
}
static void ecs_close(ECS_State *cs) {
ECS_Client *clii;
- INFO("### Good bye! ECS ###");
+ INFO("### Good bye! ECS ###\n");
if (cs == NULL)
return;
if (0 <= cs->listen_fd) {
- INFO("close listen_fd: %d", cs->listen_fd);
+ INFO("close listen_fd: %d\n", cs->listen_fd);
closesocket(cs->listen_fd);
cs->listen_fd = -1;
}
if (cli == NULL)
{
- ERR("client is null.");
+ ERR("client is null.\n");
return;
}
#ifndef __WIN32
if (ioctl(cli->client_fd, FIONREAD, &to_read_bytes) < 0)
{
- ERR("ioctl failed");
+ ERR("ioctl failed\n");
return;
}
#else
unsigned long to_read_bytes_long = 0;
if (ioctlsocket(cli->client_fd, FIONREAD, &to_read_bytes_long) < 0)
{
- ERR("ioctl failed");
+ ERR("ioctl failed\n");
return;
}
to_read_bytes = (int)to_read_bytes_long;
#endif
if (to_read_bytes == 0) {
- ERR("ioctl FIONREAD: 0\n");
+ TRACE("ioctl FIONREAD: 0\n");
goto fail;
}
{
if (to_read_bytes < 4)
{
- //LOG("insufficient data size to read");
+ //LOG("insufficient data size to read\n");
return;
}
if (read < 4)
{
- ERR("insufficient header size");
+ ERR("insufficient header size\n");
goto fail;
}
events.data.fd = fd;
if (epoll_ctl(cs->epoll_fd, EPOLL_CTL_ADD, fd, &events) < 0) {
- ERR("Epoll control fails.in epoll_cli_add.");
+ ERR("Epoll control fails.in epoll_cli_add.\n");
}
}
#endif
ECS_Client *clii = g_malloc0(sizeof(ECS_Client));
if (NULL == clii) {
- ERR("ECS_Client allocation failed.");
+ ERR("ECS_Client allocation failed.\n");
return -1;
}
QTAILQ_INSERT_TAIL(&clients, clii, next);
- INFO("Add an ecs client. fd: %d", fd);
+ TRACE("Add an ecs client. fd: %d\n", fd);
pthread_mutex_unlock(&mutex_clilist);
}
}
if (0 > ecs_add_client(cs, fd)) {
- ERR("failed to add client.");
+ ERR("failed to add client.\n");
}
}
keepalive_buf = g_malloc(len_pack + 4);
if (!keepalive_buf) {
- ERR("keep alive message creation is failed.");
+ ERR("keep alive message creation is failed.\n");
return;
}
QTAILQ_FOREACH(clii, &clients, next)
{
if (1 == clii->keep_alive) {
- INFO("get client fd %d - keep alive fail", clii->client_fd);
+ INFO("get client fd %d - keep alive fail\n", clii->client_fd);
ecs_client_close(clii);
continue;
}
- TRACE("set client fd %d - keep alive 1", clii->client_fd);
+ TRACE("set client fd %d - keep alive 1\n", clii->client_fd);
clii->keep_alive = 1;
send_keep_alive_msg(clii);
}
if (current_ecs == NULL) {
- ERR("alive checking is failed because current ecs is null.");
+ ERR("alive checking is failed because current ecs is null.\n");
return;
}
return -1;
}
- INFO("Listen fd is %d", fd);
+ INFO("Listen fd is %d\n", fd);
qemu_set_nonblock(fd);
timeout.tv_usec = 0;
if (select(0, &temps, 0, 0, &timeout) < 0) {
- ERR("select error.");
+ ERR("select error.\n");
return -1;
}
timeout.tv_usec = 0;
if ((res = select(MAX_FD_NUM + 1, &temps, NULL, NULL, &timeout)) < 0) {
- ERR("select failed..");
+ ERR("select failed..\n");
return -1;
}
char host_port[16];
int port = 0;
- INFO("ecs starts initializing.");
+ INFO("ecs starts initializing.\n");
opts = qemu_opts_create(qemu_find_opts(ECS_OPTS_NAME), ECS_OPTS_NAME, 1, &local_err);
if (error_is_set(&local_err)) {
cs = g_malloc0(sizeof(ECS_State));
if (NULL == cs) {
- ERR("ECS_State allocation failed.");
+ ERR("ECS_State allocation failed.\n");
return NULL;
}
port = get_emul_ecs_port();
- INFO("ecs port: %d", port);
+ INFO("ecs port: %d\n", port);
sprintf(host_port, "%d", port);
qemu_opt_set(opts, "port", host_port);
ret = socket_initialize(cs, opts);
if (ret < 0) {
- ERR("Socket initialization is failed.");
+ ERR("Socket initialization is failed.\n");
ecs_close(cs);
return NULL;
}
mon = monitor_create();
if (NULL == mon) {
- ERR("monitor initialization failed.");
+ ERR("monitor initialization failed.\n");
ecs_close(cs);
return NULL;
}
current_ecs = cs;
cs->ecs_running = 1;
- TRACE("ecs_loop entered.");
+ TRACE("ecs_loop entered.\n");
while (cs->ecs_running) {
ret = ecs_loop(cs);
if (0 > ret) {
break;
}
}
- TRACE("ecs_loop exited.");
+ TRACE("ecs_loop exited.\n");
return NULL;
}
int stop_ecs(void) {
- INFO("ecs is closing.");
+ INFO("ecs is closing.\n");
if (NULL != current_ecs) {
current_ecs->ecs_running = 0;
ecs_close(current_ecs);
pthread_t thread_id;
if (0 != pthread_create(&thread_id, NULL, ecs_initialize, NULL)) {
- ERR("pthread creation failed.");
+ ERR("pthread creation failed.\n");
return -1;
}
return 0;
QTAILQ_INSERT_TAIL(&clients, cli, next);
}
else {
- ERR("unsupported category is found: %s", msg->category);
+ ERR("unsupported category is found: %s\n", msg->category);
pthread_mutex_unlock(&mutex_clilist);
goto fail;
}
ecs__master__free_unpacked(master, NULL);
return true;
fail:
- ERR("invalid message type : %d", master->type);
+ ERR("invalid message type : %d\n", master->type);
ecs__master__free_unpacked(master, NULL);
return false;
}
#define ECS_VERSION "1.0"
-#define ECS_DEBUG 1
-
-#ifdef ECS_DEBUG
-#define LOG(fmt, arg...) \
- do { \
- fprintf(stdout,"[%s-%s:%d] "fmt"\n", get_timeofday(), __FUNCTION__, __LINE__, ##arg); \
- } while (0)
-#else
-#define LOG(fmt, arg...)
-#endif
-
#define ECS_OPTS_NAME "ecs"
#define HOST_LISTEN_ADDR "127.0.0.1"
#define HOST_LISTEN_PORT 0
ECS__Master master = ECS__MASTER__INIT;
ECS__MonitorNtf ntf = ECS__MONITOR_NTF__INIT;
- TRACE("data size : %d, data : %s", size, data);
+ TRACE("data size : %d, data : %s\n", size, data);
ntf.command = (char*) g_malloc(size + 1);
memcpy(ntf.command, data, size);
QDict *qmp;
QObject *obj;
- TRACE("ecs_protocol_emitter called.");
+ TRACE("ecs_protocol_emitter called.\n");
//trace_monitor_protocol_emitter(clii->cs->mon);
if (!monitor_has_error(clii->cs->mon)) {
bool msgproc_monitor_req(ECS_Client *ccli, ECS__MonitorReq* msg)
{
- TRACE(">> monitor req: data = %s", msg->command);
+ TRACE(">> monitor req: data = %s\n", msg->command);
ecs_json_message_parser_feed(&(ccli->parser), (const char *) msg->command, strlen(msg->command));
return true;
}
#include "skin/maruskin_operation.h"
#include "skin/maruskin_server.h"
#include "emulator.h"
+#include "emul_state.h"
#include "debug_ch.h"
MULTI_DEBUG_CHANNEL(qemu, ecs);
-
#define MAX_BUF_SIZE 255
// utility functions
{
int len_pack = ecs__master__get_packed_size(master);
*payloadsize = len_pack + 4;
- TRACE("pack size=%d", len_pack);
+ TRACE("pack size=%d\n", len_pack);
void* buf = g_malloc(len_pack + 4);
if (!buf)
return NULL;
void* buf = build_master(master, &payloadsize);
if (!buf)
{
- ERR("invalid buf");
+ ERR("invalid buf\n");
return false;
}
void* buf = build_master(master, &payloadsize);
if (!buf)
{
- ERR("invalid buf");
+ ERR("invalid buf\n");
return false;
}
void* buf = build_master(master, &payloadsize);
if (!buf)
{
- ERR("invalid buf");
+ ERR("invalid buf\n");
return false;
}
ECS__Master master = ECS__MASTER__INIT;
ECS__InjectorAns ans = ECS__INJECTOR_ANS__INIT;
- TRACE("injector ans - category : %s, succed : %d", category, succeed);
+ TRACE("injector ans - category : %s, succed : %d\n", category, succeed);
catlen = strlen(category);
ans.category = (char*) g_malloc0(catlen + 1);
g_free(ans.category);
}
-static void msgproc_device_ans(ECS_Client* ccli, const char* category, bool succeed)
+static void msgproc_device_ans(ECS_Client* ccli, const char* category, bool succeed, char* data)
{
if (ccli == NULL) {
return;
ECS__Master master = ECS__MASTER__INIT;
ECS__DeviceAns ans = ECS__DEVICE_ANS__INIT;
- TRACE("device ans - category : %s, succed : %d", category, succeed);
+ TRACE("device ans - category : %s, succed : %d\n", category, succeed);
catlen = strlen(category);
ans.category = (char*) g_malloc0(catlen + 1);
memcpy(ans.category, category, catlen);
ans.errcode = !succeed;
+
+ if (data != NULL) {
+ ans.length = strlen(data);
+
+ if (ans.length > 0) {
+ ans.has_data = 1;
+ ans.data.data = g_malloc(ans.length);
+ ans.data.len = ans.length;
+ memcpy(ans.data.data, data, ans.length);
+ TRACE("data = %s, length = %hu\n", data, ans.length);
+ }
+ }
+
master.type = ECS__MASTER__TYPE__DEVICE_ANS;
master.device_ans = &ans;
{
datalen = msg->data.len;
}
- //LOG(">> count= %d", ++ijcount);
+ //TRACE(">> count= %d", ++ijcount);
- TRACE(">> header = cmd = %s, length = %d, action=%d, group=%d", cmd, length,
+ TRACE(">> header = cmd = %s, length = %d, action=%d, group=%d\n", cmd, length,
action, group);
/*SD CARD msg process*/
if (!strncmp(cmd, MSG_TYPE_SDCARD, strlen(MSG_TYPE_SDCARD))) {
if (msg->has_data) {
- TRACE("msg(%zu) : %s", msg->data.len, msg->data.data);
+ TRACE("msg(%zu) : %s\n", msg->data.len, msg->data.data);
handle_sdcard((char*) msg->data.data, msg->data.len);
} else {
- ERR("has no msg");
+ ERR("has no msg\n");
}
} else if (!strncmp(cmd, MSG_TYPE_SENSOR, sizeof(MSG_TYPE_SENSOR))) {
{
const char* data = (const char*)msg->data.data;
memcpy(sndbuf + 14, data, datalen);
- TRACE(">> print len = %zd, data\" %s\"", strlen(data), data);
+ TRACE(">> print len = %zd, data\" %s\"\n", strlen(data), data);
}
}
ans.data.len = length;
memcpy(ans.data.data, tizen_target_img_path, length);
- TRACE("data = %s, length = %hu", tizen_target_img_path, length);
+ TRACE("data = %s, length = %hu\n", tizen_target_img_path, length);
}
master.type = ECS__MASTER__TYPE__DEVICE_ANS;
memcpy(data, msg->data.data, msg->data.len);
}
- TRACE(">> header = cmd = %s, length = %d, action=%d, group=%d", cmd, length,
+ TRACE(">> header = cmd = %s, length = %d, action=%d, group=%d\n", cmd, length,
action, group);
if (!strncmp(cmd, MSG_TYPE_SENSOR, 6)) {
if (data != NULL) {
set_injector_data(data);
} else {
- ERR("sensor set data is null");
+ ERR("sensor set data is null\n");
}
}
- msgproc_device_ans(ccli, cmd, true);
+ msgproc_device_ans(ccli, cmd, true, NULL);
} else if (!strncmp(cmd, "Network", 7)) {
if (data != NULL) {
- TRACE(">>> Network msg: '%s'", data);
+ TRACE(">>> Network msg: '%s'\n", data);
if(net_slirp_redir(data) < 0) {
- ERR( "redirect [%s] fail", data);
+ ERR( "redirect [%s] fail\n", data);
} else {
- TRACE("redirect [%s] success", data);
+ TRACE("redirect [%s] success\n", data);
}
} else {
- ERR("Network redirection data is null.");
+ ERR("Network redirection data is null.\n");
}
} else if (!strncmp(cmd, "HKeyboard", 8)) {
if (group == MSG_GROUP_STATUS) {
send_host_keyboard_ntf(mloop_evcmd_get_hostkbd_status());
} else {
if (data == NULL) {
- ERR("HKeyboard data is NULL");
+ ERR("HKeyboard data is NULL\n");
return false;
}
#endif
if (data == NULL) {
- ERR("gesture data is NULL");
+ ERR("gesture data is NULL\n");
return false;
}
}
} else if (!strncmp(cmd, "info", 4)) {
// check to emulator target image path
- TRACE("receive info message %s", tizen_target_img_path);
+ TRACE("receive info message %s\n", tizen_target_img_path);
send_target_image_information(ccli);
+
+ } else if (!strncmp(cmd, "input", strlen("input"))) {
+ // cli input
+ TRACE("receive input message [%s]\n", data);
+
+ if (group == 0) {
+
+ TRACE("input keycode data : [%s]\n", data);
+
+ char token[] = " ";
+ char *section = strtok(data, token);
+ int keycode = atoi(section);
+ if (action == 1) {
+ //action 1 press
+ do_hw_key_event(KEY_PRESSED, keycode);
+
+ } else if (action == 2) {
+ //action 2 released
+ do_hw_key_event(KEY_RELEASED, keycode);
+
+ } else {
+ ERR("unknown action : [%d]\n", (int)action);
+ }
+ } else if (group == 1) {
+ //spec out
+ TRACE("input category's group 1 is spec out\n");
+ } else {
+ ERR("unknown group [%d]\n", (int)group);
+ }
+ msgproc_device_ans(ccli, cmd, true, NULL);
+
+ } else if (!strncmp(cmd, "vmname", strlen("vmname"))) {
+ char* vmname = get_emul_vm_name();
+ msgproc_device_ans(ccli, cmd, true, vmname);
+ } else{
+ ERR("unknown cmd [%s]\n", cmd);
}
if (data) {
int datalen = msg->data.len;
void* data = (void*)g_malloc(datalen);
if(!data) {
- ERR("g_malloc failed!");
+ ERR("g_malloc failed!\n");
return false;
}
TRACE("header category = %s", cat);
}
else {
- ERR("cannot find client!");
+ ERR("cannot find client!\n");
}
ECS__Master master = ECS__MASTER__INIT;
void send_tethering_sensor_status_ecp(void)
{
- INFO(">> send tethering_event_status to ecp");
+ INFO(">> send tethering_event_status to ecp\n");
send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP,
ECS_TETHERING_MSG_ACTION_SENSOR_STATUS);
}
void send_tethering_connection_status_ecp(void)
{
- INFO(">> send tethering_connection_status to ecp");
+ INFO(">> send tethering_connection_status to ecp\n");
send_tethering_status_ntf(ECS_TETHERING_MSG_GROUP_ECP,
ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS);
}
return;
}
- TRACE(">> send port_num: %d", tethering_port);
+ TRACE(">> send port_num: %d\n", tethering_port);
g_snprintf(data, sizeof(data) - 1, "%d", tethering_port);
length = strlen(data);
memcpy(msg + 13, &action, sizeof(unsigned char));
memcpy(msg + 14, data, length);
- TRACE(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s",
+ TRACE(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s\n",
action, group, data);
// send_tethering_ntf((const char *)msg, MSG_BUF_SIZE);
memcpy(msg + 13, &action, sizeof(unsigned char));
memcpy(msg + 14, data, 1);
- TRACE(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s",
+ TRACE(">> send tethering_ntf to ecp. action=%d, group=%d, data=%s\n",
action, group, data);
// send_tethering_ntf((const char *)msg, MSG_BUF_SIZE);
const char* ijdata = (data + catsize + 2 + 1 + 1);
- TRACE("<< header cat = %s, length = %d, action=%d, group=%d", cat, length,action, group);
+ TRACE("<< header cat = %s, length = %d, action=%d, group=%d\n", cat, length,action, group);
ECS__Master master = ECS__MASTER__INIT;
ECS__TetheringNtf ntf = ECS__TETHERING_NTF__INIT;
ntf.data.len = length;
memcpy(ntf.data.data, ijdata, length);
- TRACE("data = %s, length = %hu", ijdata, length);
+ TRACE("data = %s, length = %hu\n", ijdata, length);
}
master.type = ECS__MASTER__TYPE__TETHERING_NTF;
type_group group = (type_group) (msg->group & 0xff);
type_action action = (type_action) (msg->action & 0xff);
- TRACE(">> header = cmd = %s, length = %d, action=%d, group=%d",
+ TRACE(">> header = cmd = %s, length = %d, action=%d, group=%d\n",
cmd, length, action, group);
if (group == ECS_TETHERING_MSG_GROUP_ECP) {
port = g_ascii_strtoull(data, NULL, 10);
- TRACE(">> MSG_ACTION_CONNECT");
- TRACE(">> len = %zd, data\" %s\"", strlen(data), data);
+ TRACE(">> MSG_ACTION_CONNECT\n");
+ TRACE(">> len = %zd, data\" %s\"\n", strlen(data), data);
connect_tethering_app(port);
tethering_port = port;
- TRACE(">> port_num: %d, %d", port, tethering_port);
+ TRACE(">> port_num: %d, %d\n", port, tethering_port);
}
}
break;
case ECS_TETHERING_MSG_ACTION_DISCONNECT:
- INFO(">> MSG_ACTION_DISCONNECT");
+ INFO(">> MSG_ACTION_DISCONNECT\n");
disconnect_tethering_app();
tethering_port = 0;
break;
case ECS_TETHERING_MSG_ACTION_CONNECTION_STATUS:
case ECS_TETHERING_MSG_ACTION_SENSOR_STATUS:
case ECS_TETHERING_MSG_ACTION_TOUCH_STATUS:
- TRACE(">> get_status_action");
+ TRACE(">> get_status_action\n");
send_tethering_status_ntf(group, action);
break;
default: