src/server.c

   1 /*
   2  * Copyright 2013  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.1 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <unistd.h>
  19 #include <errno.h>
  20
  21 #include <dlog.h>
  22 #include <Evas.h>
  23 #include <Ecore_Evas.h> /* fb.h */
  24 #include <aul.h>
  25 #include <Ecore.h>
  26 #include <ail.h>
  27
  28 #include <packet.h>
  29 #include <com-core_packet.h>
  30 #include <livebox-errno.h>
  31 #include <livebox-service.h>
  32
  33 #include "critical_log.h"
  34 #include "conf.h"
  35 #include "debug.h"
  36 #include "server.h"
  37 #include "slave_life.h"
  38 #include "slave_rpc.h"
  39 #include "client_life.h"
  40 #include "instance.h"
  41 #include "client_rpc.h"
  42 #include "package.h"
  43 #include "script_handler.h"
  44 #include "buffer_handler.h"
  45 #include "util.h"
  46 #include "fault_manager.h"
  47 #include "fb.h" /* fb_type */
  48 #include "group.h"
  49 #include "xmonitor.h"
  50 #include "abi.h"
  51 #include "liveinfo.h"
  52 #include "io.h"
  53 #include "event.h"
  54
  55 static struct info {
  56         int info_fd;
  57         int client_fd;
  58         int service_fd;
  59         int slave_fd;
  60 } s_info = {
  61         .info_fd = -1,
  62         .client_fd = -1,
  63         .service_fd = -1,
  64         .slave_fd = -1,
  65 };
  66
  67 /* Share this with provider */
  68 enum target_type {
  69         TYPE_LB,
  70         TYPE_PD,
  71         TYPE_ERROR
  72 };
  73
  74 struct access_cbdata {
  75         int status;
  76         struct inst_info *inst;
  77 };
  78
  79 struct deleted_item {
  80         struct client_node *client;
  81         struct inst_info *inst;
  82 };
  83
  84 static Eina_Bool lazy_access_status_cb(void *data)
  85 {
  86         struct access_cbdata *cbdata = data;
  87
  88         if (instance_unref(cbdata->inst)) {
  89                 instance_send_access_status(cbdata->inst, cbdata->status);
  90         } else {
  91                 DbgPrint("Skip sending access status (%d)\n", cbdata->status);
  92         }
  93         /*!
  94          * If instance_unref returns NULL,
  95          * The instance is destroyed. it means, we don't need to send event to the viewer
  96          */
  97         DbgFree(cbdata);
  98         return ECORE_CALLBACK_CANCEL;
  99 }
 100
 101 static int event_lb_route_cb(enum event_state state, struct event_data *event_info, void *data)
 102 {
 103         struct inst_info *inst = data;
 104         const struct pkg_info *pkg;
 105         struct slave_node *slave;
 106         struct packet *packet;
 107         const char *cmdstr;
 108
 109         pkg = instance_package(inst);
 110         if (!pkg)
 111                 return LB_STATUS_ERROR_INVALID;
 112
 113         slave = package_slave(pkg);
 114         if (!slave)
 115                 return LB_STATUS_ERROR_INVALID;
 116
 117         switch (state) {
 118         case EVENT_STATE_ACTIVATE:
 119                 cmdstr = "lb_mouse_down";
 120                 break;
 121         case EVENT_STATE_ACTIVATED:
 122                 cmdstr = "lb_mouse_move";
 123                 break;
 124         case EVENT_STATE_DEACTIVATE:
 125                 cmdstr = "lb_mouse_up";
 126                 break;
 127         default:
 128                 return LB_STATUS_ERROR_INVALID;
 129         }
 130
 131         packet = packet_create_noack(cmdstr, "ssdii", package_name(pkg), instance_id(inst), util_timestamp(), event_info->x, event_info->y);
 132         if (!packet)
 133                 return LB_STATUS_ERROR_FAULT;
 134
 135         return slave_rpc_request_only(slave, package_name(pkg), packet, 0);
 136 }
 137
 138 static int event_lb_consume_cb(enum event_state state, struct event_data *event_info, void *data)
 139 {
 140         struct script_info *script;
 141         struct inst_info *inst = data;
 142         const struct pkg_info *pkg;
 143         double timestamp;
 144         Evas *e;
 145
 146         pkg = instance_package(inst);
 147         if (!pkg)
 148                 return 0;
 149
 150         script = instance_lb_script(inst);
 151         if (!script)
 152                 return LB_STATUS_ERROR_FAULT;
 153
 154         e = script_handler_evas(script);
 155         if (!e)
 156                 return LB_STATUS_ERROR_FAULT;
 157
 158         timestamp = util_timestamp();
 159
 160         switch (state) {
 161         case EVENT_STATE_ACTIVATE:
 162                 script_handler_update_pointer(script, event_info->x, event_info->y, 1);
 163                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_DOWN, timestamp);
 164                 break;
 165         case EVENT_STATE_ACTIVATED:
 166                 script_handler_update_pointer(script, event_info->x, event_info->y, -1);
 167                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_MOVE, timestamp);
 168                 break;
 169         case EVENT_STATE_DEACTIVATE:
 170                 script_handler_update_pointer(script, event_info->x, event_info->y, 0);
 171                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_UP, timestamp);
 172                 break;
 173         default:
 174                 break;
 175         }
 176
 177         return 0;
 178 }
 179
 180 static int event_pd_route_cb(enum event_state state, struct event_data *event_info, void *data)
 181 {
 182         struct inst_info *inst = data;
 183         const struct pkg_info *pkg;
 184         struct slave_node *slave;
 185         struct packet *packet;
 186         const char *cmdstr;
 187
 188         pkg = instance_package(inst);
 189         if (!pkg)
 190                 return LB_STATUS_ERROR_INVALID;
 191
 192         slave = package_slave(pkg);
 193         if (!slave)
 194                 return LB_STATUS_ERROR_INVALID;
 195
 196         switch (state) {
 197         case EVENT_STATE_ACTIVATE:
 198                 cmdstr = "pd_mouse_down";
 199                 break;
 200         case EVENT_STATE_ACTIVATED:
 201                 cmdstr = "pd_mouse_move";
 202                 break;
 203         case EVENT_STATE_DEACTIVATE:
 204                 cmdstr = "pd_mouse_up";
 205                 break;
 206         default:
 207                 return LB_STATUS_ERROR_INVALID;
 208         }
 209
 210         packet = packet_create_noack(cmdstr, "ssdii", package_name(pkg), instance_id(inst), util_timestamp(), event_info->x, event_info->y);
 211         if (!packet)
 212                 return LB_STATUS_ERROR_FAULT;
 213
 214         return slave_rpc_request_only(slave, package_name(pkg), packet, 0);
 215 }
 216
 217 static int event_pd_consume_cb(enum event_state state, struct event_data *event_info, void *data)
 218 {
 219         struct script_info *script;
 220         struct inst_info *inst = data;
 221         const struct pkg_info *pkg;
 222         double timestamp;
 223         Evas *e;
 224
 225         pkg = instance_package(inst);
 226         if (!pkg)
 227                 return 0;
 228
 229         script = instance_pd_script(inst);
 230         if (!script)
 231                 return LB_STATUS_ERROR_FAULT;
 232
 233         e = script_handler_evas(script);
 234         if (!e)
 235                 return LB_STATUS_ERROR_FAULT;
 236
 237         timestamp = util_timestamp();
 238
 239         switch (state) {
 240         case EVENT_STATE_ACTIVATE:
 241                 script_handler_update_pointer(script, event_info->x, event_info->y, 1);
 242                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_DOWN, timestamp);
 243                 break;
 244         case EVENT_STATE_ACTIVATED:
 245                 script_handler_update_pointer(script, event_info->x, event_info->y, -1);
 246                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_MOVE, timestamp);
 247                 break;
 248         case EVENT_STATE_DEACTIVATE:
 249                 script_handler_update_pointer(script, event_info->x, event_info->y, 0);
 250                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_UP, timestamp);
 251                 break;
 252         default:
 253                 break;
 254         }
 255         return 0;
 256 }
 257
 258 static struct packet *client_acquire(pid_t pid, int handle, const struct packet *packet) /*!< timestamp, ret */
 259 {
 260         struct client_node *client;
 261         struct packet *result;
 262         double timestamp;
 263         int ret;
 264
 265         client = client_find_by_pid(pid);
 266         if (client) {
 267                 ErrPrint("Client is already exists %d\n", pid);
 268                 ret = LB_STATUS_ERROR_EXIST;
 269                 goto out;
 270         }
 271
 272         if (packet_get(packet, "d", &timestamp) != 1) {
 273                 ErrPrint("Invalid arguemnt\n");
 274                 ret = LB_STATUS_ERROR_INVALID;
 275                 goto out;
 276         }
 277
 278         ret = 0;
 279         /*!
 280          * \note
 281          * client_create will invoke the client created callback
 282          */
 283         client = client_create(pid, handle);
 284         if (!client) {
 285                 ErrPrint("Failed to create a new client for %d\n", pid);
 286                 ret = LB_STATUS_ERROR_FAULT;
 287         }
 288
 289 out:
 290         result = packet_create_reply(packet, "i", ret);
 291         if (!result)
 292                 ErrPrint("Failed to create a packet\n");
 293
 294         return result;
 295 }
 296
 297 static struct packet *cilent_release(pid_t pid, int handle, const struct packet *packet) /*!< pid, ret */
 298 {
 299         struct client_node *client;
 300         struct packet *result;
 301         int ret;
 302
 303         client = client_find_by_pid(pid);
 304         if (!client) {
 305                 ErrPrint("Client %d is not exists\n", pid);
 306                 ret = LB_STATUS_ERROR_NOT_EXIST;
 307                 goto out;
 308         }
 309
 310         client_destroy(client);
 311         ret = 0;
 312
 313 out:
 314         result = packet_create_reply(packet, "i", ret);
 315         if (!result)
 316                 ErrPrint("Failed to create a packet\n");
 317
 318         return result;
 319 }
 320
 321 static inline int validate_request(const char *pkgname, const char *id, struct inst_info **out_inst, const struct pkg_info **out_pkg)
 322 {
 323         struct inst_info *inst;
 324         const struct pkg_info *pkg;
 325
 326         inst = package_find_instance_by_id(pkgname, id);
 327         if (!inst) {
 328                 ErrPrint("Instance is not exists\n");
 329                 return LB_STATUS_ERROR_NOT_EXIST;
 330         }
 331
 332         pkg = instance_package(inst);
 333         if (!pkg) {
 334                 ErrPrint("System error - instance has no package?\n");
 335                 return LB_STATUS_ERROR_INVALID;
 336         }
 337
 338         if (package_is_fault(pkg)) {
 339                 ErrPrint("Faulted package: %s\n", pkgname);
 340                 return LB_STATUS_ERROR_FAULT;
 341         }
 342
 343         if (out_inst)
 344                 *out_inst = inst;
 345
 346         if (out_pkg)
 347                 *out_pkg = pkg;
 348
 349         return LB_STATUS_SUCCESS;
 350 }
 351
 352 /*!< pid, pkgname, filename, event, timestamp, x, y, ret */
 353 static struct packet *client_clicked(pid_t pid, int handle, const struct packet *packet)
 354 {
 355         struct client_node *client;
 356         const char *pkgname;
 357         const char *id;
 358         const char *event;
 359         double timestamp;
 360         double x;
 361         double y;
 362         int ret;
 363         struct inst_info *inst;
 364
 365         client = client_find_by_pid(pid);
 366         if (!client) {
 367                 ErrPrint("Client %d is not exists\n", pid);
 368                 goto out;
 369         }
 370
 371         ret = packet_get(packet, "sssddd", &pkgname, &id, &event, &timestamp, &x, &y);
 372         if (ret != 6) {
 373                 ErrPrint("Parameter is not matched\n");
 374                 goto out;
 375         }
 376
 377         /*!
 378          * \NOTE:
 379          * Trust the package name which are sent by the client.
 380          * The package has to be a livebox package name.
 381          */
 382         ret = validate_request(pkgname, id, &inst, NULL);
 383         if (ret == LB_STATUS_SUCCESS)
 384                 (void)instance_clicked(inst, event, timestamp, x, y);
 385
 386 out:
 387         /*! \note No reply packet */
 388         return NULL;
 389 }
 390
 391 static struct packet *client_update_mode(pid_t pid, int handle, const struct packet *packet)
 392 {
 393         struct packet *result;
 394         struct client_node *client;
 395         int active_update;
 396         const char *pkgname;
 397         const char *id;
 398         int ret;
 399         struct inst_info *inst;
 400
 401         client = client_find_by_pid(pid);
 402         if (!client) {
 403                 ErrPrint("Client %d is not exists\n", pid);
 404                 ret = LB_STATUS_ERROR_INVALID;
 405                 goto out;
 406         }
 407
 408         ret = packet_get(packet, "ssi", &pkgname, &id, &active_update);
 409         if (ret != 3) {
 410                 ErrPrint("Invalid argument\n");
 411                 ret = LB_STATUS_ERROR_INVALID;
 412                 goto out;
 413         }
 414
 415         ret = validate_request(pkgname, id, &inst, NULL);
 416         if (ret == LB_STATUS_SUCCESS) {
 417                 /*!
 418                  * \note
 419                  * Send change update mode request to a slave
 420                  */
 421                 ret = instance_set_update_mode(inst, active_update);
 422         }
 423
 424 out:
 425         result = packet_create_reply(packet, "i", ret);
 426         if (!result)
 427                 ErrPrint("Failed to create a packet\n");
 428
 429         return result;
 430 }
 431
 432 /* pid, pkgname, filename, emission, source, s, sy, ex, ey, ret */
 433 static struct packet *client_text_signal(pid_t pid, int handle, const struct packet *packet)
 434 {
 435         struct client_node *client;
 436         struct packet *result;
 437         const char *pkgname;
 438         const char *id;
 439         const char *emission;
 440         const char *source;
 441         double sx;
 442         double sy;
 443         double ex;
 444         double ey;
 445         struct inst_info *inst;
 446         int ret;
 447
 448         client = client_find_by_pid(pid);
 449         if (!client) {
 450                 ErrPrint("Client %d is not exists\n", pid);
 451                 ret = LB_STATUS_ERROR_NOT_EXIST;
 452                 goto out;
 453         }
 454
 455         ret = packet_get(packet, "ssssdddd", &pkgname, &id, &emission, &source, &sx, &sy, &ex, &ey);
 456         if (ret != 8) {
 457                 ErrPrint("Parameter is not matched\n");
 458                 ret = LB_STATUS_ERROR_INVALID;
 459                 goto out;
 460         }
 461
 462         /*!
 463          * \NOTE:
 464          * Trust the package name which are sent by the client.
 465          * The package has to be a livebox package name.
 466          */
 467         ret = validate_request(pkgname, id, &inst, NULL);
 468         if (ret == LB_STATUS_SUCCESS)
 469                 ret = instance_text_signal_emit(inst, emission, source, sx, sy, ex, ey);
 470
 471 out:
 472         result = packet_create_reply(packet, "i", ret);
 473         if (!result)
 474                 ErrPrint("Failed to create a packet\n");
 475
 476         return result;
 477 }
 478
 479 static Eina_Bool lazy_delete_cb(void *data)
 480 {
 481         struct deleted_item *item = data;
 482
 483         DbgPrint("Send delete event to the client\n");
 484
 485         /*!
 486          * Before invoke this callback, the instance is able to already remove this client
 487          * So check it again
 488          */
 489         if (instance_has_client(item->inst, item->client)) {
 490                 instance_unicast_deleted_event(item->inst, item->client);
 491                 instance_del_client(item->inst, item->client);
 492         }
 493
 494         (void)client_unref(item->client);
 495         (void)instance_unref(item->inst);
 496         DbgFree(item);
 497         return ECORE_CALLBACK_CANCEL;
 498 }
 499
 500 static struct packet *client_delete(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, ret */
 501 {
 502         struct client_node *client;
 503         struct packet *result;
 504         const char *pkgname;
 505         const char *id;
 506         struct inst_info *inst;
 507         int ret;
 508
 509         client = client_find_by_pid(pid);
 510         if (!client) {
 511                 ErrPrint("Client %d is not exists\n", pid);
 512                 ret = LB_STATUS_ERROR_NOT_EXIST;
 513                 goto out;
 514         }
 515
 516         ret = packet_get(packet, "ss", &pkgname, &id);
 517         if (ret != 2) {
 518                 ErrPrint("Parameter is not matched\n");
 519                 ret = LB_STATUS_ERROR_INVALID;
 520                 goto out;
 521         }
 522
 523         /*!
 524          * \NOTE:
 525          * Trust the package name which are sent by the client.
 526          * The package has to be a livebox package name.
 527          */
 528         ret = validate_request(pkgname, id, &inst, NULL);
 529         if (ret != LB_STATUS_SUCCESS)
 530                 goto out;
 531
 532         if (instance_client(inst) != client) {
 533                 if (instance_has_client(inst, client)) {
 534                         struct deleted_item *item;
 535
 536                         item = malloc(sizeof(*item));
 537                         if (!item) {
 538                                 ErrPrint("Heap: %s\n", strerror(errno));
 539                                 ret = LB_STATUS_ERROR_MEMORY;
 540                         } else {
 541                                 /*!
 542                                  * \NOTE:
 543                                  * Send DELETED EVENT to the client.
 544                                  * after return from this function.
 545                                  *
 546                                  * Client will prepare the deleted event after get this function's return value.
 547                                  * So We have to make a delay to send a deleted event.
 548                                  */
 549
 550                                 item->client = client_ref(client);
 551                                 item->inst = instance_ref(inst);
 552
 553                                 if (!ecore_timer_add(DELAY_TIME, lazy_delete_cb, item)) {
 554                                         ErrPrint("Failed to add a delayzed delete callback\n");
 555                                         (void)client_unref(client);
 556                                         (void)instance_unref(inst);
 557                                         DbgFree(item);
 558                                         ret = LB_STATUS_ERROR_FAULT;
 559                                 } else {
 560                                         ret = LB_STATUS_SUCCESS;
 561                                 }
 562                         }
 563                 } else {
 564                         ErrPrint("Client has no permission\n");
 565                         ret = LB_STATUS_ERROR_PERMISSION;
 566                 }
 567         } else {
 568                 ret = instance_destroy(inst);
 569         }
 570
 571 out:
 572         result = packet_create_reply(packet, "i", ret);
 573         if (!result)
 574                 ErrPrint("Failed to create a packet\n");
 575
 576         return result;
 577 }
 578
 579 static struct packet *client_resize(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, w, h, ret */
 580 {
 581         struct client_node *client;
 582         struct packet *result;
 583         const char *pkgname;
 584         const char *id;
 585         int w;
 586         int h;
 587         struct inst_info *inst;
 588         int ret;
 589
 590         client = client_find_by_pid(pid);
 591         if (!client) {
 592                 ErrPrint("Client %d is not exists\n", pid);
 593                 ret = LB_STATUS_ERROR_NOT_EXIST;
 594                 goto out;
 595         }
 596
 597         ret = packet_get(packet, "ssii", &pkgname, &id, &w, &h);
 598         if (ret != 4) {
 599                 ErrPrint("Parameter is not matched\n");
 600                 ret = LB_STATUS_ERROR_INVALID;
 601                 goto out;
 602         }
 603
 604         DbgPrint("RESIZE: Client request resize to %dx%d (pid: %d, pkgname: %s)\n", w, h, pid, pkgname);
 605
 606         /*!
 607          * \NOTE:
 608          * Trust the package name which are sent by the client.
 609          * The package has to be a livebox package name.
 610          */
 611         ret = validate_request(pkgname, id, &inst, NULL);
 612         if (ret != LB_STATUS_SUCCESS)
 613                 goto out;
 614
 615         if (instance_client(inst) != client)
 616                 ret = LB_STATUS_ERROR_PERMISSION;
 617         else
 618                 ret = instance_resize(inst, w, h);
 619
 620 out:
 621         result = packet_create_reply(packet, "i", ret);
 622         if (!result)
 623                 ErrPrint("Failed to create a packet\n");
 624
 625         return result;
 626 }
 627
 628 static struct packet *client_new(pid_t pid, int handle, const struct packet *packet) /* pid, timestamp, pkgname, content, cluster, category, period, ret */
 629 {
 630         struct client_node *client;
 631         struct packet *result;
 632         const char *pkgname;
 633         const char *content;
 634         const char *cluster;
 635         const char *category;
 636         double period;
 637         double timestamp;
 638         int ret;
 639         struct pkg_info *info;
 640         int width;
 641         int height;
 642         char *lb_pkgname;
 643         char *mainappid;
 644
 645         client = client_find_by_pid(pid);
 646         if (!client) {
 647                 ErrPrint("Client %d is not exists\n", pid);
 648                 ret = LB_STATUS_ERROR_NOT_EXIST;
 649                 goto out;
 650         }
 651
 652         ret = packet_get(packet, "dssssdii", &timestamp, &pkgname, &content, &cluster, &category, &period, &width, &height);
 653         if (ret != 8) {
 654                 ErrPrint("Parameter is not matched\n");
 655                 ret = LB_STATUS_ERROR_INVALID;
 656                 goto out;
 657         }
 658
 659         DbgPrint("pid[%d] period[%lf] pkgname[%s] content[%s] cluster[%s] category[%s] period[%lf]\n",
 660                                                 pid, timestamp, pkgname, content, cluster, category, period);
 661
 662         lb_pkgname = package_lb_pkgname(pkgname);
 663         if (!lb_pkgname) {
 664                 ErrPrint("This %s has no livebox package\n", pkgname);
 665                 ret = LB_STATUS_ERROR_INVALID;
 666                 goto out;
 667         }
 668
 669         mainappid = livebox_service_mainappid(lb_pkgname);
 670         if (!package_is_enabled(mainappid)) {
 671                 DbgFree(mainappid);
 672                 DbgFree(lb_pkgname);
 673                 ret = LB_STATUS_ERROR_DISABLED;
 674                 goto out;
 675         }
 676         DbgFree(mainappid);
 677
 678         info = package_find(lb_pkgname);
 679         if (!info)
 680                 info = package_create(lb_pkgname);
 681
 682         if (!info) {
 683                 ret = LB_STATUS_ERROR_FAULT;
 684         } else if (package_is_fault(info)) {
 685                 ret = LB_STATUS_ERROR_FAULT;
 686         } else if (util_free_space(IMAGE_PATH) < MINIMUM_SPACE) {
 687                 ErrPrint("Not enough space\n");
 688                 ret = LB_STATUS_ERROR_NO_SPACE;
 689         } else {
 690                 struct inst_info *inst;
 691
 692                 if (period > 0.0f && period < MINIMUM_PERIOD)
 693                         period = MINIMUM_PERIOD;
 694
 695                 inst = instance_create(client, timestamp, lb_pkgname, content, cluster, category, period, width, height);
 696                 /*!
 697                  * \note
 698                  * Using the "inst" without validate its value is at my disposal. ;)
 699                  */
 700                 ret = inst ? 0 : LB_STATUS_ERROR_FAULT;
 701         }
 702
 703         DbgFree(lb_pkgname);
 704
 705 out:
 706         result = packet_create_reply(packet, "i", ret);
 707         if (!result)
 708                 ErrPrint("Failed to create a packet\n");
 709
 710         return result;
 711 }
 712
 713 static struct packet *client_change_visibility(pid_t pid, int handle, const struct packet *packet)
 714 {
 715         struct client_node *client;
 716         const char *pkgname;
 717         const char *id;
 718         enum livebox_visible_state state;
 719         int ret;
 720         struct inst_info *inst;
 721
 722         client = client_find_by_pid(pid);
 723         if (!client) {
 724                 ErrPrint("Client %d is not exists\n", pid);
 725                 ret = LB_STATUS_ERROR_NOT_EXIST;
 726                 goto out;
 727         }
 728
 729         ret = packet_get(packet, "ssi", &pkgname, &id, (int *)&state);
 730         if (ret != 3) {
 731                 ErrPrint("Parameter is not matched\n");
 732                 ret = LB_STATUS_ERROR_INVALID;
 733                 goto out;
 734         }
 735
 736         /*!
 737          * \NOTE:
 738          * Trust the package name which are sent by the client.
 739          * The package has to be a livebox package name.
 740          */
 741         ret = validate_request(pkgname, id, &inst, NULL);
 742         if (ret != LB_STATUS_SUCCESS)
 743                 goto out;
 744
 745         if (instance_client(inst) != client)
 746                 ret = LB_STATUS_ERROR_PERMISSION;
 747         else
 748                 ret = instance_set_visible_state(inst, state);
 749
 750 out:
 751         /*! \note No reply packet */
 752         return NULL;
 753 }
 754
 755 static struct packet *client_set_period(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, period, ret */
 756 {
 757         struct client_node *client;
 758         struct packet *result;
 759         const char *pkgname;
 760         const char *id;
 761         double period;
 762         int ret;
 763         struct inst_info *inst;
 764
 765         client = client_find_by_pid(pid);
 766         if (!client) {
 767                 ErrPrint("Client %d is not exists\n", pid);
 768                 ret = LB_STATUS_ERROR_NOT_EXIST;
 769                 goto out;
 770         }
 771
 772         ret = packet_get(packet, "ssd", &pkgname, &id, &period);
 773         if (ret != 3) {
 774                 ErrPrint("Parameter is not matched\n");
 775                 ret = LB_STATUS_ERROR_INVALID;
 776                 goto out;
 777         }
 778
 779         DbgPrint("pid[%d] pkgname[%s] period[%lf]\n", pid, pkgname, period);
 780
 781         /*!
 782          * \NOTE:
 783          * Trust the package name which are sent by the client.
 784          * The package has to be a livebox package name.
 785          */
 786         ret = validate_request(pkgname, id, &inst, NULL);
 787         if (ret != LB_STATUS_SUCCESS)
 788                 goto out;
 789
 790         if (instance_client(inst) != client)
 791                 ret = LB_STATUS_ERROR_PERMISSION;
 792         else
 793                 ret = instance_set_period(inst, period);
 794
 795 out:
 796         result = packet_create_reply(packet, "i", ret);
 797         if (!result)
 798                 ErrPrint("Failed to create a packet\n");
 799
 800         return result;
 801 }
 802
 803 static struct packet *client_change_group(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, cluster, category, ret */
 804 {
 805         struct client_node *client;
 806         struct packet *result;
 807         const char *pkgname;
 808         const char *id;
 809         const char *cluster;
 810         const char *category;
 811         struct inst_info *inst;
 812         int ret;
 813
 814         client = client_find_by_pid(pid);
 815         if (!client) {
 816                 ErrPrint("Client %d is not exists\n", pid);
 817                 ret = LB_STATUS_ERROR_NOT_EXIST;
 818                 goto out;
 819         }
 820
 821         ret = packet_get(packet, "ssss", &pkgname, &id, &cluster, &category);
 822         if (ret != 4) {
 823                 ErrPrint("Parameter is not matched\n");
 824                 ret = LB_STATUS_ERROR_INVALID;
 825                 goto out;
 826         }
 827
 828         DbgPrint("pid[%d] pkgname[%s] cluster[%s] category[%s]\n", pid, pkgname, cluster, category);
 829
 830         /*!
 831          * \NOTE:
 832          * Trust the package name which are sent by the client.
 833          * The package has to be a livebox package name.
 834          */
 835         ret = validate_request(pkgname, id, &inst, NULL);
 836         if (ret != LB_STATUS_SUCCESS)
 837                 goto out;
 838
 839         if (instance_client(inst) != client)
 840                 ret = LB_STATUS_ERROR_PERMISSION;
 841         else
 842                 ret = instance_change_group(inst, cluster, category);
 843
 844 out:
 845         result = packet_create_reply(packet, "i", ret);
 846         if (!result)
 847                 ErrPrint("Failed to create a packet\n");
 848
 849         return result;
 850 }
 851
 852 static struct packet *client_pd_mouse_enter(pid_t pid, int handle, const struct packet *packet)
 853 {
 854         struct client_node *client;
 855         const char *pkgname;
 856         const char *id;
 857         int ret;
 858         double timestamp;
 859         int x;
 860         int y;
 861         struct inst_info *inst;
 862         const struct pkg_info *pkg;
 863
 864         client = client_find_by_pid(pid);
 865         if (!client) {
 866                 ErrPrint("Client %d is not exists\n", pid);
 867                 ret = LB_STATUS_ERROR_NOT_EXIST;
 868                 goto out;
 869         }
 870
 871         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
 872         if (ret != 5) {
 873                 ErrPrint("Invalid parameter\n");
 874                 ret = LB_STATUS_ERROR_INVALID;
 875                 goto out;
 876         }
 877
 878         ret = validate_request(pkgname, id, &inst, &pkg);
 879         if (ret != LB_STATUS_SUCCESS)
 880                 goto out;
 881
 882         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
 883                 struct buffer_info *buffer;
 884                 struct slave_node *slave;
 885
 886                 buffer = instance_pd_buffer(inst);
 887                 if (!buffer) {
 888                         ErrPrint("Instance[%s] has no buffer\n", id);
 889                         ret = LB_STATUS_ERROR_FAULT;
 890                         goto out;
 891                 }
 892
 893                 slave = package_slave(pkg);
 894                 if (!slave) {
 895                         ErrPrint("Package[%s] has no slave\n", pkgname);
 896                         ret = LB_STATUS_ERROR_INVALID;
 897                         goto out;
 898                 }
 899
 900                 packet_ref((struct packet *)packet);
 901                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
 902         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
 903                 struct script_info *script;
 904                 Evas *e;
 905
 906                 script = instance_pd_script(inst);
 907                 if (!script) {
 908                         ret = LB_STATUS_ERROR_FAULT;
 909                         goto out;
 910                 }
 911
 912                 e = script_handler_evas(script);
 913                 if (!e) {
 914                         ret = LB_STATUS_ERROR_FAULT;
 915                         goto out;
 916                 }
 917
 918                 script_handler_update_pointer(script, x, y, -1);
 919                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_IN, timestamp);
 920                 ret = 0;
 921         } else {
 922                 ErrPrint("Unsupported package\n");
 923                 ret = LB_STATUS_ERROR_INVALID;
 924         }
 925
 926 out:
 927         /*! \note No reply packet */
 928         return NULL;
 929 }
 930
 931 static struct packet *client_pd_mouse_leave(pid_t pid, int handle, const struct packet *packet)
 932 {
 933         struct client_node *client;
 934         const char *pkgname;
 935         const char *id;
 936         int ret;
 937         double timestamp;
 938         int x;
 939         int y;
 940         struct inst_info *inst;
 941         const struct pkg_info *pkg;
 942
 943         client = client_find_by_pid(pid);
 944         if (!client) {
 945                 ErrPrint("Client %d is not exists\n", pid);
 946                 ret = LB_STATUS_ERROR_NOT_EXIST;
 947                 goto out;
 948         }
 949
 950         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
 951         if (ret != 5) {
 952                 ErrPrint("Parameter is not matched\n");
 953                 ret = LB_STATUS_ERROR_INVALID;
 954                 goto out;
 955         }
 956
 957         ret = validate_request(pkgname, id, &inst, &pkg);
 958         if (ret != LB_STATUS_SUCCESS)
 959                 goto out;
 960
 961         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
 962                 struct buffer_info *buffer;
 963                 struct slave_node *slave;
 964
 965                 buffer = instance_pd_buffer(inst);
 966                 if (!buffer) {
 967                         ErrPrint("Instance[%s] has no buffer\n", id);
 968                         ret = LB_STATUS_ERROR_FAULT;
 969                         goto out;
 970                 }
 971
 972                 slave = package_slave(pkg);
 973                 if (!slave) {
 974                         ErrPrint("Package[%s] has no slave\n", pkgname);
 975                         ret = LB_STATUS_ERROR_INVALID;
 976                         goto out;
 977                 }
 978
 979                 packet_ref((struct packet *)packet);
 980                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
 981         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
 982                 struct script_info *script;
 983                 Evas *e;
 984
 985                 script = instance_pd_script(inst);
 986                 if (!script) {
 987                         ret = LB_STATUS_ERROR_FAULT;
 988                         goto out;
 989                 }
 990
 991                 e = script_handler_evas(script);
 992                 if (!e) {
 993                         ret = LB_STATUS_ERROR_FAULT;
 994                         goto out;
 995                 }
 996
 997                 script_handler_update_pointer(script, x, y, -1);
 998                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_OUT, timestamp);
 999                 ret = 0;
1000         } else {
1001                 ErrPrint("Unsupported package\n");
1002                 ret = LB_STATUS_ERROR_INVALID;
1003         }
1004
1005 out:
1006         /*! \note No reply packet */
1007         return NULL;
1008 }
1009
1010 static struct packet *client_pd_mouse_down(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, id, width, height, timestamp, x, y, ret */
1011 {
1012         struct client_node *client;
1013         const char *pkgname;
1014         const char *id;
1015         int ret;
1016         double timestamp;
1017         int x;
1018         int y;
1019         struct inst_info *inst;
1020         const struct pkg_info *pkg;
1021
1022         client = client_find_by_pid(pid);
1023         if (!client) {
1024                 ErrPrint("Client %d is not exists\n", pid);
1025                 ret = LB_STATUS_ERROR_NOT_EXIST;
1026                 goto out;
1027         }
1028
1029         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1030         if (ret != 5) {
1031                 ErrPrint("Parameter is not matched\n");
1032                 ret = LB_STATUS_ERROR_INVALID;
1033                 goto out;
1034         }
1035
1036         ret = validate_request(pkgname, id, &inst, &pkg);
1037         if (ret != LB_STATUS_SUCCESS)
1038                 goto out;
1039
1040         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1041                 struct buffer_info *buffer;
1042                 struct slave_node *slave;
1043
1044                 buffer = instance_pd_buffer(inst);
1045                 if (!buffer) {
1046                         ErrPrint("Instance[%s] has no buffer\n", id);
1047                         ret = LB_STATUS_ERROR_FAULT;
1048                         goto out;
1049                 }
1050
1051                 slave = package_slave(pkg);
1052                 if (!slave) {
1053                         ErrPrint("Package[%s] has no slave\n", pkgname);
1054                         ret = LB_STATUS_ERROR_INVALID;
1055                         goto out;
1056                 }
1057
1058                 packet_ref((struct packet *)packet);
1059                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1060         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
1061                 struct script_info *script;
1062                 Evas *e;
1063
1064                 script = instance_pd_script(inst);
1065                 if (!script) {
1066                         ret = LB_STATUS_ERROR_FAULT;
1067                         goto out;
1068                 }
1069
1070                 e = script_handler_evas(script);
1071                 if (!e) {
1072                         ret = LB_STATUS_ERROR_FAULT;
1073                         goto out;
1074                 }
1075
1076                 script_handler_update_pointer(script, x, y, 1);
1077                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_DOWN, timestamp);
1078                 ret = 0;
1079         } else {
1080                 ErrPrint("Unsupported package\n");
1081                 ret = LB_STATUS_ERROR_INVALID;
1082         }
1083
1084 out:
1085         /*! \note No reply packet */
1086         return NULL;
1087 }
1088
1089 static struct packet *client_pd_mouse_up(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1090 {
1091         struct client_node *client;
1092         const char *pkgname;
1093         const char *id;
1094         int ret;
1095         double timestamp;
1096         int x;
1097         int y;
1098         struct inst_info *inst;
1099         const struct pkg_info *pkg;
1100
1101         client = client_find_by_pid(pid);
1102         if (!client) {
1103                 ErrPrint("Client %d is not exists\n", pid);
1104                 ret = LB_STATUS_ERROR_NOT_EXIST;
1105                 goto out;
1106         }
1107
1108         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1109         if (ret != 5) {
1110                 ErrPrint("Parameter is not matched\n");
1111                 ret = LB_STATUS_ERROR_INVALID;
1112                 goto out;
1113         }
1114
1115         ret = validate_request(pkgname, id, &inst, &pkg);
1116         if (ret != LB_STATUS_SUCCESS)
1117                 goto out;
1118
1119         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1120                 struct buffer_info *buffer;
1121                 struct slave_node *slave;
1122
1123                 buffer = instance_pd_buffer(inst);
1124                 if (!buffer) {
1125                         ErrPrint("Instance[%s] has no buffer\n", id);
1126                         ret = LB_STATUS_ERROR_FAULT;
1127                         goto out;
1128                 }
1129
1130                 slave = package_slave(pkg);
1131                 if (!slave) {
1132                         ErrPrint("Package[%s] has no slave\n", pkgname);
1133                         ret = LB_STATUS_ERROR_INVALID;
1134                         goto out;
1135                 }
1136
1137                 packet_ref((struct packet *)packet);
1138                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1139         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
1140                 struct script_info *script;
1141                 Evas *e;
1142
1143                 script = instance_pd_script(inst);
1144                 if (!script) {
1145                         ret = LB_STATUS_ERROR_FAULT;
1146                         goto out;
1147                 }
1148
1149                 e = script_handler_evas(script);
1150                 if (!e) {
1151                         ret = LB_STATUS_ERROR_FAULT;
1152                         goto out;
1153                 }
1154
1155                 script_handler_update_pointer(script, x, y, 0);
1156                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_UP, timestamp);
1157                 ret = 0;
1158         } else {
1159                 ErrPrint("Unsupported package\n");
1160                 ret = LB_STATUS_ERROR_INVALID;
1161         }
1162
1163 out:
1164         /*! \note No reply packet */
1165         return NULL;
1166 }
1167
1168 static struct packet *client_pd_mouse_move(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1169 {
1170         struct client_node *client;
1171         const char *pkgname;
1172         const char *id;
1173         int ret;
1174         double timestamp;
1175         int x;
1176         int y;
1177         struct inst_info *inst;
1178         const struct pkg_info *pkg;
1179
1180         client = client_find_by_pid(pid);
1181         if (!client) {
1182                 ErrPrint("Client %d is not exists\n", pid);
1183                 ret = LB_STATUS_ERROR_NOT_EXIST;
1184                 goto out;
1185         }
1186
1187         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1188         if (ret != 5) {
1189                 ErrPrint("Parameter is not matched\n");
1190                 ret = LB_STATUS_ERROR_INVALID;
1191                 goto out;
1192         }
1193
1194         ret = validate_request(pkgname, id, &inst, &pkg);
1195         if (ret != LB_STATUS_SUCCESS)
1196                 goto out;
1197
1198         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1199                 struct buffer_info *buffer;
1200                 struct slave_node *slave;
1201
1202                 buffer = instance_pd_buffer(inst);
1203                 if (!buffer) {
1204                         ErrPrint("Instance[%s] has no buffer\n", id);
1205                         ret = LB_STATUS_ERROR_FAULT;
1206                         goto out;
1207                 }
1208
1209                 slave = package_slave(pkg);
1210                 if (!slave) {
1211                         ErrPrint("Package[%s] has no slave\n", pkgname);
1212                         ret = LB_STATUS_ERROR_INVALID;
1213                         goto out;
1214                 }
1215
1216                 packet_ref((struct packet *)packet);
1217                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1218         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
1219                 struct script_info *script;
1220                 Evas *e;
1221
1222                 script = instance_pd_script(inst);
1223                 if (!script) {
1224                         ret = LB_STATUS_ERROR_FAULT;
1225                         goto out;
1226                 }
1227
1228                 e = script_handler_evas(script);
1229                 if (!e) {
1230                         ret = LB_STATUS_ERROR_FAULT;
1231                         goto out;
1232                 }
1233
1234                 script_handler_update_pointer(script, x, y, -1);
1235                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_MOVE, timestamp);
1236                 ret = 0;
1237         } else {
1238                 ErrPrint("Unsupported package\n");
1239                 ret = LB_STATUS_ERROR_INVALID;
1240         }
1241
1242 out:
1243         /*! \note No reply packet */
1244         return NULL;
1245 }
1246
1247 static struct packet *client_lb_mouse_move(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1248 {
1249         struct client_node *client;
1250         const char *pkgname;
1251         const char *id;
1252         int ret;
1253         double timestamp;
1254         int x;
1255         int y;
1256         struct inst_info *inst;
1257         const struct pkg_info *pkg;
1258
1259         client = client_find_by_pid(pid);
1260         if (!client) {
1261                 ErrPrint("Client %d is not exists\n", pid);
1262                 ret = LB_STATUS_ERROR_NOT_EXIST;
1263                 goto out;
1264         }
1265
1266         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1267         if (ret != 5) {
1268                 ErrPrint("Parameter is not matched\n");
1269                 ret = LB_STATUS_ERROR_INVALID;
1270                 goto out;
1271         }
1272
1273         ret = validate_request(pkgname, id, &inst, &pkg);
1274         if (ret != LB_STATUS_SUCCESS)
1275                 goto out;
1276
1277         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1278                 struct buffer_info *buffer;
1279                 struct slave_node *slave;
1280
1281                 buffer = instance_lb_buffer(inst);
1282                 if (!buffer) {
1283                         ErrPrint("Instance[%s] has no buffer\n", id);
1284                         ret = LB_STATUS_ERROR_FAULT;
1285                         goto out;
1286                 }
1287
1288                 slave = package_slave(pkg);
1289                 if (!slave) {
1290                         ErrPrint("Package[%s] has no slave\n", pkgname);
1291                         ret = LB_STATUS_ERROR_INVALID;
1292                         goto out;
1293                 }
1294
1295                 packet_ref((struct packet *)packet);
1296                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1297         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1298                 struct script_info *script;
1299                 Evas *e;
1300
1301                 script = instance_lb_script(inst);
1302                 if (!script) {
1303                         ret = LB_STATUS_ERROR_FAULT;
1304                         goto out;
1305                 }
1306
1307                 e = script_handler_evas(script);
1308                 if (!e) {
1309                         ret = LB_STATUS_ERROR_FAULT;
1310                         goto out;
1311                 }
1312
1313                 script_handler_update_pointer(script, x, y, -1);
1314                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_MOVE, timestamp);
1315                 ret = 0;
1316         } else {
1317                 ErrPrint("Unsupported package\n");
1318                 ret = LB_STATUS_ERROR_INVALID;
1319         }
1320
1321 out:
1322         /*! \note No reply packet */
1323         return NULL;
1324 }
1325
1326 static int inst_del_cb(struct inst_info *inst, void *data)
1327 {
1328         (void)event_deactivate();
1329         return -1; /* Delete this callback */
1330 }
1331
1332 static struct packet *client_lb_mouse_set(pid_t pid, int handle, const struct packet *packet)
1333 {
1334         struct client_node *client;
1335         const char *pkgname;
1336         const char *id;
1337         int ret;
1338         double timestamp;
1339         int x;
1340         int y;
1341         struct inst_info *inst;
1342         const struct pkg_info *pkg;
1343
1344         client = client_find_by_pid(pid);
1345         if (!client) {
1346                 ErrPrint("Client %d is not exists\n", pid);
1347                 ret = LB_STATUS_ERROR_NOT_EXIST;
1348                 goto out;
1349         }
1350
1351         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1352         if (ret != 5) {
1353                 ErrPrint("Parameter is not matched\n");
1354                 ret = LB_STATUS_ERROR_INVALID;
1355                 goto out;
1356         }
1357
1358         ret = validate_request(pkgname, id, &inst, &pkg);
1359         if (ret != LB_STATUS_SUCCESS)
1360                 goto out;
1361
1362         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1363                 if (event_is_activated()) {
1364                         if (event_deactivate() == 0)
1365                                 instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1366                 }
1367
1368                 ret = event_activate(x, y, event_lb_route_cb, inst);
1369                 if (ret == 0)
1370                         instance_event_callback_add(inst, INSTANCE_EVENT_DESTROY, inst_del_cb, NULL);
1371         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1372                 if (event_is_activated()) {
1373                         if (event_deactivate() == 0)
1374                                 instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1375                 }
1376
1377                 ret = event_activate(x, y, event_lb_consume_cb, inst);
1378                 if (ret == 0)
1379                         instance_event_callback_add(inst, INSTANCE_EVENT_DESTROY, inst_del_cb, NULL);
1380         } else {
1381                 ErrPrint("Unsupported package\n");
1382                 ret = LB_STATUS_ERROR_INVALID;
1383         }
1384 out:
1385         return NULL;
1386 }
1387
1388 static struct packet *client_lb_mouse_unset(pid_t pid, int handle, const struct packet *packet)
1389 {
1390         struct client_node *client;
1391         const char *pkgname;
1392         const char *id;
1393         int ret;
1394         double timestamp;
1395         int x;
1396         int y;
1397         struct inst_info *inst;
1398         const struct pkg_info *pkg;
1399
1400         client = client_find_by_pid(pid);
1401         if (!client) {
1402                 ErrPrint("Client %d is not exists\n", pid);
1403                 ret = LB_STATUS_ERROR_NOT_EXIST;
1404                 goto out;
1405         }
1406
1407         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1408         if (ret != 5) {
1409                 ErrPrint("Parameter is not matched\n");
1410                 ret = LB_STATUS_ERROR_INVALID;
1411                 goto out;
1412         }
1413
1414         ret = validate_request(pkgname, id, &inst, &pkg);
1415         if (ret != LB_STATUS_SUCCESS)
1416                 goto out;
1417
1418         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1419                 ret = event_deactivate();
1420                 if (ret == 0)
1421                         instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1422         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1423                 ret = event_deactivate();
1424                 if (ret == 0)
1425                         instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1426         } else {
1427                 ErrPrint("Unsupported package\n");
1428                 ret = LB_STATUS_ERROR_INVALID;
1429         }
1430 out:
1431         return NULL;
1432 }
1433
1434 static struct packet *client_pd_mouse_set(pid_t pid, int handle, const struct packet *packet)
1435 {
1436         struct client_node *client;
1437         const char *pkgname;
1438         const char *id;
1439         int ret;
1440         double timestamp;
1441         int x;
1442         int y;
1443         struct inst_info *inst;
1444         const struct pkg_info *pkg;
1445
1446         client = client_find_by_pid(pid);
1447         if (!client) {
1448                 ErrPrint("Client %d is not exists\n", pid);
1449                 ret = LB_STATUS_ERROR_NOT_EXIST;
1450                 goto out;
1451         }
1452
1453         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1454         if (ret != 5) {
1455                 ErrPrint("Parameter is not matched\n");
1456                 ret = LB_STATUS_ERROR_INVALID;
1457                 goto out;
1458         }
1459
1460         ret = validate_request(pkgname, id, &inst, &pkg);
1461         if (ret != LB_STATUS_SUCCESS)
1462                 goto out;
1463
1464         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1465                 if (event_is_activated()) {
1466                         if (event_deactivate() == 0)
1467                                 instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1468                 }
1469
1470                 ret = event_activate(x, y, event_pd_route_cb, inst);
1471                 if (ret == 0)
1472                         instance_event_callback_add(inst, INSTANCE_EVENT_DESTROY, inst_del_cb, NULL);
1473         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
1474                 if (event_is_activated()) {
1475                         if (event_deactivate() == 0)
1476                                 instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1477                 }
1478
1479                 ret = event_activate(x, y, event_pd_consume_cb, inst);
1480                 if (ret == 0)
1481                         instance_event_callback_add(inst, INSTANCE_EVENT_DESTROY, inst_del_cb, NULL);
1482         } else {
1483                 ErrPrint("Unsupported package\n");
1484                 ret = LB_STATUS_ERROR_INVALID;
1485         }
1486
1487 out:
1488         return NULL;
1489 }
1490
1491 static struct packet *client_pd_mouse_unset(pid_t pid, int handle, const struct packet *packet)
1492 {
1493         struct client_node *client;
1494         const char *pkgname;
1495         const char *id;
1496         int ret;
1497         double timestamp;
1498         int x;
1499         int y;
1500         struct inst_info *inst;
1501         const struct pkg_info *pkg;
1502
1503         client = client_find_by_pid(pid);
1504         if (!client) {
1505                 ErrPrint("Client %d is not exists\n", pid);
1506                 ret = LB_STATUS_ERROR_NOT_EXIST;
1507                 goto out;
1508         }
1509
1510         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1511         if (ret != 5) {
1512                 ErrPrint("Parameter is not matched\n");
1513                 ret = LB_STATUS_ERROR_INVALID;
1514                 goto out;
1515         }
1516
1517         ret = validate_request(pkgname, id, &inst, &pkg);
1518         if (ret != LB_STATUS_SUCCESS)
1519                 goto out;
1520
1521         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1522                 ret = event_deactivate();
1523                 if (ret == 0)
1524                         instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1525         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
1526                 ret = event_deactivate();
1527                 if (ret == 0)
1528                         instance_event_callback_del(inst, INSTANCE_EVENT_DESTROY, inst_del_cb);
1529         } else {
1530                 ErrPrint("Unsupported package\n");
1531                 ret = LB_STATUS_ERROR_INVALID;
1532         }
1533 out:
1534         return NULL;
1535 }
1536
1537 static struct packet *client_lb_mouse_enter(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1538 {
1539         struct client_node *client;
1540         const char *pkgname;
1541         const char *id;
1542         int ret;
1543         double timestamp;
1544         int x;
1545         int y;
1546         struct inst_info *inst;
1547         const struct pkg_info *pkg;
1548
1549         client = client_find_by_pid(pid);
1550         if (!client) {
1551                 ErrPrint("Client %d is not exists\n", pid);
1552                 ret = LB_STATUS_ERROR_NOT_EXIST;
1553                 goto out;
1554         }
1555
1556         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1557         if (ret != 5) {
1558                 ErrPrint("Parameter is not matched\n");
1559                 ret = LB_STATUS_ERROR_INVALID;
1560                 goto out;
1561         }
1562
1563         ret = validate_request(pkgname, id, &inst, &pkg);
1564         if (ret != LB_STATUS_SUCCESS)
1565                 goto out;
1566
1567         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1568                 struct buffer_info *buffer;
1569                 struct slave_node *slave;
1570
1571                 buffer = instance_lb_buffer(inst);
1572                 if (!buffer) {
1573                         ErrPrint("Instance[%s] has no buffer\n", id);
1574                         ret = LB_STATUS_ERROR_FAULT;
1575                         goto out;
1576                 }
1577
1578                 slave = package_slave(pkg);
1579                 if (!slave) {
1580                         ErrPrint("Package[%s] has no slave\n", pkgname);
1581                         ret = LB_STATUS_ERROR_INVALID;
1582                         goto out;
1583                 }
1584
1585                 packet_ref((struct packet *)packet);
1586                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1587         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1588                 struct script_info *script;
1589                 Evas *e;
1590
1591                 script = instance_lb_script(inst);
1592                 if (!script) {
1593                         ret = LB_STATUS_ERROR_FAULT;
1594                         goto out;
1595                 }
1596
1597                 e = script_handler_evas(script);
1598                 if (!e) {
1599                         ret = LB_STATUS_ERROR_FAULT;
1600                         goto out;
1601                 }
1602
1603                 script_handler_update_pointer(script, x, y, -1);
1604                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_IN, timestamp);
1605                 ret = 0;
1606         } else {
1607                 ErrPrint("Unsupported package\n");
1608                 ret = LB_STATUS_ERROR_INVALID;
1609         }
1610
1611 out:
1612         /*! \note No reply packet */
1613         return NULL;
1614 }
1615
1616 static struct packet *client_lb_mouse_leave(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1617 {
1618         struct client_node *client;
1619         const char *pkgname;
1620         const char *id;
1621         int ret;
1622         double timestamp;
1623         int x;
1624         int y;
1625         struct inst_info *inst;
1626         const struct pkg_info *pkg;
1627
1628         client = client_find_by_pid(pid);
1629         if (!client) {
1630                 ErrPrint("Client %d is not exists\n", pid);
1631                 ret = LB_STATUS_ERROR_NOT_EXIST;
1632                 goto out;
1633         }
1634
1635         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1636         if (ret != 5) {
1637                 ErrPrint("Parameter is not matched\n");
1638                 ret = LB_STATUS_ERROR_INVALID;
1639                 goto out;
1640         }
1641
1642         ret = validate_request(pkgname, id, &inst, &pkg);
1643         if (ret != LB_STATUS_SUCCESS)
1644                 goto out;
1645
1646         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1647                 struct buffer_info *buffer;
1648                 struct slave_node *slave;
1649
1650                 buffer = instance_lb_buffer(inst);
1651                 if (!buffer) {
1652                         ErrPrint("Instance[%s] has no buffer\n", id);
1653                         ret = LB_STATUS_ERROR_FAULT;
1654                         goto out;
1655                 }
1656
1657                 slave = package_slave(pkg);
1658                 if (!slave) {
1659                         ErrPrint("Package[%s] has no slave\n", pkgname);
1660                         ret = LB_STATUS_ERROR_INVALID;
1661                         goto out;
1662                 }
1663
1664                 packet_ref((struct packet *)packet);
1665                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1666         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1667                 struct script_info *script;
1668                 Evas *e;
1669
1670                 script = instance_lb_script(inst);
1671                 if (!script) {
1672                         ret = LB_STATUS_ERROR_FAULT;
1673                         goto out;
1674                 }
1675
1676                 e = script_handler_evas(script);
1677                 if (!e) {
1678                         ret = LB_STATUS_ERROR_FAULT;
1679                         goto out;
1680                 }
1681
1682                 script_handler_update_pointer(script, x, y, -1);
1683                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_OUT, timestamp);
1684                 ret = 0;
1685         } else {
1686                 ErrPrint("Unsupported package\n");
1687                 ret = LB_STATUS_ERROR_INVALID;
1688         }
1689
1690 out:
1691         /*! \note No reply packet */
1692         return NULL;
1693 }
1694
1695 static struct packet *client_lb_mouse_down(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1696 {
1697         struct client_node *client;
1698         const char *pkgname;
1699         const char *id;
1700         int ret;
1701         double timestamp;
1702         int x;
1703         int y;
1704         struct inst_info *inst;
1705         const struct pkg_info *pkg;
1706
1707         client = client_find_by_pid(pid);
1708         if (!client) {
1709                 ErrPrint("Client %d is not exists\n", pid);
1710                 ret = LB_STATUS_ERROR_NOT_EXIST;
1711                 goto out;
1712         }
1713
1714         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1715         if (ret != 5) {
1716                 ErrPrint("Parameter is not matched\n");
1717                 ret = LB_STATUS_ERROR_INVALID;
1718                 goto out;
1719         }
1720
1721         ret = validate_request(pkgname, id, &inst, &pkg);
1722         if (ret != LB_STATUS_SUCCESS)
1723                 goto out;
1724
1725         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1726                 struct buffer_info *buffer;
1727                 struct slave_node *slave;
1728
1729                 buffer = instance_lb_buffer(inst);
1730                 if (!buffer) {
1731                         ErrPrint("Instance[%s] has no buffer\n", id);
1732                         ret = LB_STATUS_ERROR_FAULT;
1733                         goto out;
1734                 }
1735
1736                 slave = package_slave(pkg);
1737                 if (!slave) {
1738                         ErrPrint("Package[%s] has no slave\n", pkgname);
1739                         ret = LB_STATUS_ERROR_INVALID;
1740                         goto out;
1741                 }
1742
1743                 packet_ref((struct packet *)packet);
1744                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1745         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1746                 struct script_info *script;
1747                 Evas *e;
1748
1749                 script = instance_lb_script(inst);
1750                 if (!script) {
1751                         ret = LB_STATUS_ERROR_FAULT;
1752                         goto out;
1753                 }
1754
1755                 e = script_handler_evas(script);
1756                 if (!e) {
1757                         ret = LB_STATUS_ERROR_FAULT;
1758                         goto out;
1759                 }
1760
1761                 script_handler_update_pointer(script, x, y, 1);
1762                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_DOWN, timestamp);
1763                 ret = 0;
1764         } else {
1765                 ErrPrint("Unsupported package\n");
1766                 ret = LB_STATUS_ERROR_INVALID;
1767         }
1768
1769 out:
1770         /*! \note No reply packet */
1771         return NULL;
1772 }
1773
1774 static struct packet *client_lb_mouse_up(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
1775 {
1776         struct client_node *client;
1777         const char *pkgname;
1778         const char *id;
1779         int ret;
1780         double timestamp;
1781         int x;
1782         int y;
1783         struct inst_info *inst;
1784         const struct pkg_info *pkg;
1785
1786         client = client_find_by_pid(pid);
1787         if (!client) {
1788                 ErrPrint("Client %d is not exists\n", pid);
1789                 ret = LB_STATUS_ERROR_NOT_EXIST;
1790                 goto out;
1791         }
1792
1793         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1794         if (ret != 5) {
1795                 ErrPrint("Parameter is not matched\n");
1796                 ret = LB_STATUS_ERROR_INVALID;
1797                 goto out;
1798         }
1799
1800         ret = validate_request(pkgname, id, &inst, &pkg);
1801         if (ret != LB_STATUS_SUCCESS)
1802                 goto out;
1803
1804         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
1805                 struct buffer_info *buffer;
1806                 struct slave_node *slave;
1807
1808                 buffer = instance_lb_buffer(inst);
1809                 if (!buffer) {
1810                         ErrPrint("Instance[%s] has no buffer\n", id);
1811                         ret = LB_STATUS_ERROR_FAULT;
1812                         goto out;
1813                 }
1814
1815                 slave = package_slave(pkg);
1816                 if (!slave) {
1817                         ErrPrint("Package[%s] has no slave\n", pkgname);
1818                         ret = LB_STATUS_ERROR_INVALID;
1819                         goto out;
1820                 }
1821
1822                 packet_ref((struct packet *)packet);
1823                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1824         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
1825                 struct script_info *script;
1826                 Evas *e;
1827
1828                 script = instance_lb_script(inst);
1829                 if (!script) {
1830                         ret = LB_STATUS_ERROR_FAULT;
1831                         goto out;
1832                 }
1833
1834                 e = script_handler_evas(script);
1835                 if (!e) {
1836                         ret = LB_STATUS_ERROR_FAULT;
1837                         goto out;
1838                 }
1839
1840                 script_handler_update_pointer(script, x, y, 0);
1841                 script_handler_feed_event(script, LB_SCRIPT_MOUSE_UP, timestamp);
1842                 ret = 0;
1843         } else {
1844                 ErrPrint("Unsupported package\n");
1845                 ret = LB_STATUS_ERROR_INVALID;
1846         }
1847
1848 out:
1849         /*! \note No reply packet */
1850         return NULL;
1851 }
1852
1853 static struct packet *client_pd_access_action_up(pid_t pid, int handle, const struct packet *packet)
1854 {
1855         struct packet *result;
1856         struct client_node *client;
1857         const char *pkgname;
1858         const char *id;
1859         int ret;
1860         double timestamp;
1861         int x;
1862         int y;
1863         struct inst_info *inst;
1864         const struct pkg_info *pkg;
1865
1866         client = client_find_by_pid(pid);
1867         if (!client) {
1868                 ErrPrint("Client %d is not exists\n", pid);
1869                 ret = LB_STATUS_ERROR_NOT_EXIST;
1870                 goto out;
1871         }
1872
1873         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1874         if (ret != 5) {
1875                 ErrPrint("Invalid parameter\n");
1876                 ret = LB_STATUS_ERROR_INVALID;
1877                 goto out;
1878         }
1879
1880         ret = validate_request(pkgname, id, &inst, &pkg);
1881         if (ret != LB_STATUS_SUCCESS)
1882                 goto out;
1883
1884         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1885                 struct buffer_info *buffer;
1886                 struct slave_node *slave;
1887
1888                 buffer = instance_pd_buffer(inst);
1889                 if (!buffer) {
1890                         ErrPrint("Instance[%s] has no buffer\n", id);
1891                         ret = LB_STATUS_ERROR_FAULT;
1892                         goto out;
1893                 }
1894
1895                 slave = package_slave(pkg);
1896                 if (!slave) {
1897                         ErrPrint("Package[%s] has no slave\n", pkgname);
1898                         ret = LB_STATUS_ERROR_INVALID;
1899                         goto out;
1900                 }
1901
1902                 packet_ref((struct packet *)packet);
1903                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
1904         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
1905                 struct script_info *script;
1906                 Evas *e;
1907
1908                 script = instance_pd_script(inst);
1909                 if (!script) {
1910                         ret = LB_STATUS_ERROR_FAULT;
1911                         goto out;
1912                 }
1913
1914                 e = script_handler_evas(script);
1915                 if (!e) {
1916                         ret = LB_STATUS_ERROR_FAULT;
1917                         goto out;
1918                 }
1919
1920                 script_handler_update_pointer(script, x, y, 0);
1921                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_ACTION, timestamp);
1922                 if (ret >= 0) {
1923                         struct access_cbdata *cbdata;
1924
1925                         cbdata = malloc(sizeof(*cbdata));
1926                         if (!cbdata) {
1927                                 ret = LB_STATUS_ERROR_MEMORY;
1928                         } else {
1929                                 cbdata->inst = instance_ref(inst);
1930                                 cbdata->status = ret;
1931
1932                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
1933                                         (void)instance_unref(cbdata->inst);
1934                                         DbgFree(cbdata);
1935                                         ret = LB_STATUS_ERROR_FAULT;
1936                                 } else {
1937                                         ret = LB_STATUS_SUCCESS;
1938                                 }
1939                         }
1940                 }
1941         } else {
1942                 ErrPrint("Unsupported package\n");
1943                 ret = LB_STATUS_ERROR_INVALID;
1944         }
1945
1946 out:
1947         result = packet_create_reply(packet, "i", ret);
1948         if (!result)
1949                 ErrPrint("Failed to create a reply packet\n");
1950
1951         return result;
1952 }
1953
1954 static struct packet *client_pd_access_action_down(pid_t pid, int handle, const struct packet *packet)
1955 {
1956         struct packet *result;
1957         struct client_node *client;
1958         const char *pkgname;
1959         const char *id;
1960         int ret;
1961         double timestamp;
1962         int x;
1963         int y;
1964         struct inst_info *inst;
1965         const struct pkg_info *pkg;
1966
1967         client = client_find_by_pid(pid);
1968         if (!client) {
1969                 ErrPrint("Client %d is not exists\n", pid);
1970                 ret = LB_STATUS_ERROR_NOT_EXIST;
1971                 goto out;
1972         }
1973
1974         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
1975         if (ret != 5) {
1976                 ErrPrint("Invalid parameter\n");
1977                 ret = LB_STATUS_ERROR_INVALID;
1978                 goto out;
1979         }
1980
1981         ret = validate_request(pkgname, id, &inst, &pkg);
1982         if (ret != LB_STATUS_SUCCESS)
1983                 goto out;
1984
1985         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
1986                 struct buffer_info *buffer;
1987                 struct slave_node *slave;
1988
1989                 buffer = instance_pd_buffer(inst);
1990                 if (!buffer) {
1991                         ErrPrint("Instance[%s] has no buffer\n", id);
1992                         ret = LB_STATUS_ERROR_FAULT;
1993                         goto out;
1994                 }
1995
1996                 slave = package_slave(pkg);
1997                 if (!slave) {
1998                         ErrPrint("Package[%s] has no slave\n", pkgname);
1999                         ret = LB_STATUS_ERROR_INVALID;
2000                         goto out;
2001                 }
2002
2003                 packet_ref((struct packet *)packet);
2004                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2005         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2006                 struct script_info *script;
2007                 Evas *e;
2008
2009                 script = instance_pd_script(inst);
2010                 if (!script) {
2011                         ret = LB_STATUS_ERROR_FAULT;
2012                         goto out;
2013                 }
2014
2015                 e = script_handler_evas(script);
2016                 if (!e) {
2017                         ret = LB_STATUS_ERROR_FAULT;
2018                         goto out;
2019                 }
2020
2021                 script_handler_update_pointer(script, x, y, 1);
2022                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_ACTION, timestamp);
2023                 if (ret >= 0) {
2024                         struct access_cbdata *cbdata;
2025
2026                         cbdata = malloc(sizeof(*cbdata));
2027                         if (!cbdata) {
2028                                 ret = LB_STATUS_ERROR_MEMORY;
2029                         } else {
2030                                 cbdata->inst = instance_ref(inst);
2031                                 cbdata->status = ret;
2032
2033                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2034                                         (void)instance_unref(cbdata->inst);
2035                                         DbgFree(cbdata);
2036                                         ret = LB_STATUS_ERROR_FAULT;
2037                                 } else {
2038                                         ret = LB_STATUS_SUCCESS;
2039                                 }
2040                         }
2041                 }
2042         } else {
2043                 ErrPrint("Unsupported package\n");
2044                 ret = LB_STATUS_ERROR_INVALID;
2045         }
2046
2047 out:
2048         result = packet_create_reply(packet, "i", ret);
2049         if (!result)
2050                 ErrPrint("Failed to create a reply packet\n");
2051
2052         return result;
2053 }
2054
2055 static struct packet *client_pd_access_scroll_down(pid_t pid, int handle, const struct packet *packet)
2056 {
2057         struct packet *result;
2058         struct client_node *client;
2059         const char *pkgname;
2060         const char *id;
2061         int ret;
2062         double timestamp;
2063         int x;
2064         int y;
2065         struct inst_info *inst;
2066         const struct pkg_info *pkg;
2067
2068         client = client_find_by_pid(pid);
2069         if (!client) {
2070                 ErrPrint("Client %d is not exists\n", pid);
2071                 ret = LB_STATUS_ERROR_NOT_EXIST;
2072                 goto out;
2073         }
2074
2075         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2076         if (ret != 5) {
2077                 ErrPrint("Invalid parameter\n");
2078                 ret = LB_STATUS_ERROR_INVALID;
2079                 goto out;
2080         }
2081
2082         ret = validate_request(pkgname, id, &inst, &pkg);
2083         if (ret != LB_STATUS_SUCCESS)
2084                 goto out;
2085
2086         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2087                 struct buffer_info *buffer;
2088                 struct slave_node *slave;
2089
2090                 buffer = instance_pd_buffer(inst);
2091                 if (!buffer) {
2092                         ErrPrint("Instance[%s] has no buffer\n", id);
2093                         ret = LB_STATUS_ERROR_FAULT;
2094                         goto out;
2095                 }
2096
2097                 slave = package_slave(pkg);
2098                 if (!slave) {
2099                         ErrPrint("Package[%s] has no slave\n", pkgname);
2100                         ret = LB_STATUS_ERROR_INVALID;
2101                         goto out;
2102                 }
2103
2104                 packet_ref((struct packet *)packet);
2105                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2106         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2107                 struct script_info *script;
2108                 Evas *e;
2109
2110                 script = instance_pd_script(inst);
2111                 if (!script) {
2112                         ret = LB_STATUS_ERROR_FAULT;
2113                         goto out;
2114                 }
2115
2116                 e = script_handler_evas(script);
2117                 if (!e) {
2118                         ret = LB_STATUS_ERROR_FAULT;
2119                         goto out;
2120                 }
2121
2122                 script_handler_update_pointer(script, x, y, 1);
2123                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_SCROLL, timestamp);
2124                 if (ret >= 0) {
2125                         struct access_cbdata *cbdata;
2126
2127                         cbdata = malloc(sizeof(*cbdata));
2128                         if (!cbdata) {
2129                                 ret = LB_STATUS_ERROR_MEMORY;
2130                         } else {
2131                                 cbdata->inst = instance_ref(inst);
2132                                 cbdata->status = ret;
2133
2134                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2135                                         (void)instance_unref(cbdata->inst);
2136                                         DbgFree(cbdata);
2137                                         ret = LB_STATUS_ERROR_FAULT;
2138                                 } else {
2139                                         ret = LB_STATUS_SUCCESS;
2140                                 }
2141                         }
2142                 }
2143         } else {
2144                 ErrPrint("Unsupported package\n");
2145                 ret = LB_STATUS_ERROR_INVALID;
2146         }
2147
2148 out:
2149         result = packet_create_reply(packet, "i", ret);
2150         if (!result)
2151                 ErrPrint("Failed to create a reply packet\n");
2152
2153         return result;
2154 }
2155
2156 static struct packet *client_pd_access_scroll_move(pid_t pid, int handle, const struct packet *packet)
2157 {
2158         struct packet *result;
2159         struct client_node *client;
2160         const char *pkgname;
2161         const char *id;
2162         int ret;
2163         double timestamp;
2164         int x;
2165         int y;
2166         struct inst_info *inst;
2167         const struct pkg_info *pkg;
2168
2169         client = client_find_by_pid(pid);
2170         if (!client) {
2171                 ErrPrint("Client %d is not exists\n", pid);
2172                 ret = LB_STATUS_ERROR_NOT_EXIST;
2173                 goto out;
2174         }
2175
2176         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2177         if (ret != 5) {
2178                 ErrPrint("Invalid parameter\n");
2179                 ret = LB_STATUS_ERROR_INVALID;
2180                 goto out;
2181         }
2182
2183         ret = validate_request(pkgname, id, &inst, &pkg);
2184         if (ret != LB_STATUS_SUCCESS)
2185                 goto out;
2186
2187         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2188                 struct buffer_info *buffer;
2189                 struct slave_node *slave;
2190
2191                 buffer = instance_pd_buffer(inst);
2192                 if (!buffer) {
2193                         ErrPrint("Instance[%s] has no buffer\n", id);
2194                         ret = LB_STATUS_ERROR_FAULT;
2195                         goto out;
2196                 }
2197
2198                 slave = package_slave(pkg);
2199                 if (!slave) {
2200                         ErrPrint("Package[%s] has no slave\n", pkgname);
2201                         ret = LB_STATUS_ERROR_INVALID;
2202                         goto out;
2203                 }
2204
2205                 packet_ref((struct packet *)packet);
2206                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2207         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2208                 struct script_info *script;
2209                 Evas *e;
2210
2211                 script = instance_pd_script(inst);
2212                 if (!script) {
2213                         ret = LB_STATUS_ERROR_FAULT;
2214                         goto out;
2215                 }
2216
2217                 e = script_handler_evas(script);
2218                 if (!e) {
2219                         ret = LB_STATUS_ERROR_FAULT;
2220                         goto out;
2221                 }
2222
2223                 script_handler_update_pointer(script, x, y, -1);
2224                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_SCROLL, timestamp);
2225                 if (ret >= 0) {
2226                         struct access_cbdata *cbdata;
2227
2228                         cbdata = malloc(sizeof(*cbdata));
2229                         if (!cbdata) {
2230                                 ret = LB_STATUS_ERROR_MEMORY;
2231                         } else {
2232                                 cbdata->inst = instance_ref(inst);
2233                                 cbdata->status = ret;
2234
2235                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2236                                         (void)instance_unref(cbdata->inst);
2237                                         DbgFree(cbdata);
2238                                         ret = LB_STATUS_ERROR_FAULT;
2239                                 } else {
2240                                         ret = LB_STATUS_SUCCESS;
2241                                 }
2242                         }
2243                 }
2244         } else {
2245                 ErrPrint("Unsupported package\n");
2246                 ret = LB_STATUS_ERROR_INVALID;
2247         }
2248
2249 out:
2250         result = packet_create_reply(packet, "i", ret);
2251         if (!result)
2252                 ErrPrint("Failed to create a reply packet\n");
2253
2254         return result;
2255 }
2256
2257 static struct packet *client_pd_access_scroll_up(pid_t pid, int handle, const struct packet *packet)
2258 {
2259         struct packet *result;
2260         struct client_node *client;
2261         const char *pkgname;
2262         const char *id;
2263         int ret;
2264         double timestamp;
2265         int x;
2266         int y;
2267         struct inst_info *inst;
2268         const struct pkg_info *pkg;
2269
2270         client = client_find_by_pid(pid);
2271         if (!client) {
2272                 ErrPrint("Client %d is not exists\n", pid);
2273                 ret = LB_STATUS_ERROR_NOT_EXIST;
2274                 goto out;
2275         }
2276
2277         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2278         if (ret != 5) {
2279                 ErrPrint("Invalid parameter\n");
2280                 ret = LB_STATUS_ERROR_INVALID;
2281                 goto out;
2282         }
2283
2284         ret = validate_request(pkgname, id, &inst, &pkg);
2285         if (ret != LB_STATUS_SUCCESS)
2286                 goto out;
2287
2288         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2289                 struct buffer_info *buffer;
2290                 struct slave_node *slave;
2291
2292                 buffer = instance_pd_buffer(inst);
2293                 if (!buffer) {
2294                         ErrPrint("Instance[%s] has no buffer\n", id);
2295                         ret = LB_STATUS_ERROR_FAULT;
2296                         goto out;
2297                 }
2298
2299                 slave = package_slave(pkg);
2300                 if (!slave) {
2301                         ErrPrint("Package[%s] has no slave\n", pkgname);
2302                         ret = LB_STATUS_ERROR_INVALID;
2303                         goto out;
2304                 }
2305
2306                 packet_ref((struct packet *)packet);
2307                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2308         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2309                 struct script_info *script;
2310                 Evas *e;
2311
2312                 script = instance_pd_script(inst);
2313                 if (!script) {
2314                         ret = LB_STATUS_ERROR_FAULT;
2315                         goto out;
2316                 }
2317
2318                 e = script_handler_evas(script);
2319                 if (!e) {
2320                         ret = LB_STATUS_ERROR_FAULT;
2321                         goto out;
2322                 }
2323
2324                 script_handler_update_pointer(script, x, y, 0);
2325                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_SCROLL, timestamp);
2326                 if (ret >= 0) {
2327                         struct access_cbdata *cbdata;
2328
2329                         cbdata = malloc(sizeof(*cbdata));
2330                         if (!cbdata) {
2331                                 ret = LB_STATUS_ERROR_MEMORY;
2332                         } else {
2333                                 cbdata->inst = instance_ref(inst);
2334                                 cbdata->status = ret;
2335
2336                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2337                                         (void)instance_unref(cbdata->inst);
2338                                         DbgFree(cbdata);
2339                                         ret = LB_STATUS_ERROR_FAULT;
2340                                 } else {
2341                                         ret = LB_STATUS_SUCCESS;
2342                                 }
2343                         }
2344                 }
2345         } else {
2346                 ErrPrint("Unsupported package\n");
2347                 ret = LB_STATUS_ERROR_INVALID;
2348         }
2349
2350 out:
2351         result = packet_create_reply(packet, "i", ret);
2352         if (!result)
2353                 ErrPrint("Failed to create a reply packet\n");
2354
2355         return result;
2356 }
2357
2358 static struct packet *client_pd_access_unhighlight(pid_t pid, int handle, const struct packet *packet)
2359 {
2360         struct packet *result;
2361         struct client_node *client;
2362         const char *pkgname;
2363         const char *id;
2364         int x;
2365         int y;
2366         struct inst_info *inst;
2367         const struct pkg_info *pkg;
2368         int ret;
2369         double timestamp;
2370
2371         client = client_find_by_pid(pid);
2372         if (!client) {
2373                 ErrPrint("Client %d is not exists\n", pid);
2374                 ret = LB_STATUS_ERROR_NOT_EXIST;
2375                 goto out;
2376         }
2377
2378         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2379         if (ret != 5) {
2380                 ErrPrint("Invalid parameter\n");
2381                 ret = LB_STATUS_ERROR_INVALID;
2382                 goto out;
2383         }
2384
2385         ret = validate_request(pkgname, id, &inst, &pkg);
2386         if (ret != LB_STATUS_SUCCESS)
2387                 goto out;
2388
2389         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2390                 struct buffer_info *buffer;
2391                 struct slave_node *slave;
2392
2393                 buffer = instance_pd_buffer(inst);
2394                 if (!buffer) {
2395                         ErrPrint("Instance[%s] has no buffer\n", id);
2396                         ret = LB_STATUS_ERROR_FAULT;
2397                         goto out;
2398                 }
2399
2400                 slave = package_slave(pkg);
2401                 if (!slave) {
2402                         ErrPrint("Package[%s] has no slave\n", pkgname);
2403                         ret = LB_STATUS_ERROR_INVALID;
2404                         goto out;
2405                 }
2406
2407                 packet_ref((struct packet *)packet);
2408                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2409         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2410                 struct script_info *script;
2411                 Evas *e;
2412
2413                 script = instance_pd_script(inst);
2414                 if (!script) {
2415                         ret = LB_STATUS_ERROR_FAULT;
2416                         goto out;
2417                 }
2418
2419                 e = script_handler_evas(script);
2420                 if (!e) {
2421                         ret = LB_STATUS_ERROR_FAULT;
2422                         goto out;
2423                 }
2424
2425                 script_handler_update_pointer(script, x, y, -1);
2426                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_UNHIGHLIGHT, timestamp);
2427                 if (ret >= 0) {
2428                         struct access_cbdata *cbdata;
2429
2430                         cbdata = malloc(sizeof(*cbdata));
2431                         if (!cbdata) {
2432                                 ret = LB_STATUS_ERROR_MEMORY;
2433                         } else {
2434                                 cbdata->inst = instance_ref(inst);
2435                                 cbdata->status = ret;
2436
2437                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2438                                         (void)instance_unref(cbdata->inst);
2439                                         DbgFree(cbdata);
2440                                         ret = LB_STATUS_ERROR_FAULT;
2441                                 } else {
2442                                         ret = LB_STATUS_SUCCESS;
2443                                 }
2444                         }
2445                 }
2446         } else {
2447                 ErrPrint("Unsupported package\n");
2448                 ret = LB_STATUS_ERROR_INVALID;
2449         }
2450 out:
2451         result = packet_create_reply(packet, "i", ret);
2452         if (!result)
2453                 ErrPrint("Failed to create a reply packet\n");
2454
2455         return result;
2456 }
2457
2458 static struct packet *client_pd_access_hl(pid_t pid, int handle, const struct packet *packet)
2459 {
2460         struct packet *result;
2461         struct client_node *client;
2462         const char *pkgname;
2463         const char *id;
2464         int ret;
2465         double timestamp;
2466         int x;
2467         int y;
2468         struct inst_info *inst;
2469         const struct pkg_info *pkg;
2470
2471         client = client_find_by_pid(pid);
2472         if (!client) {
2473                 ErrPrint("Client %d is not exists\n", pid);
2474                 ret = LB_STATUS_ERROR_NOT_EXIST;
2475                 goto out;
2476         }
2477
2478         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2479         if (ret != 5) {
2480                 ErrPrint("Invalid parameter\n");
2481                 ret = LB_STATUS_ERROR_INVALID;
2482                 goto out;
2483         }
2484
2485         ret = validate_request(pkgname, id, &inst, &pkg);
2486         if (ret != LB_STATUS_SUCCESS)
2487                 goto out;
2488
2489         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2490                 struct buffer_info *buffer;
2491                 struct slave_node *slave;
2492
2493                 buffer = instance_pd_buffer(inst);
2494                 if (!buffer) {
2495                         ErrPrint("Instance[%s] has no buffer\n", id);
2496                         ret = LB_STATUS_ERROR_FAULT;
2497                         goto out;
2498                 }
2499
2500                 slave = package_slave(pkg);
2501                 if (!slave) {
2502                         ErrPrint("Package[%s] has no slave\n", pkgname);
2503                         ret = LB_STATUS_ERROR_INVALID;
2504                         goto out;
2505                 }
2506
2507                 packet_ref((struct packet *)packet);
2508                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2509         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2510                 struct script_info *script;
2511                 Evas *e;
2512
2513                 script = instance_pd_script(inst);
2514                 if (!script) {
2515                         ret = LB_STATUS_ERROR_FAULT;
2516                         goto out;
2517                 }
2518
2519                 e = script_handler_evas(script);
2520                 if (!e) {
2521                         ret = LB_STATUS_ERROR_FAULT;
2522                         goto out;
2523                 }
2524
2525                 script_handler_update_pointer(script, x, y, -1);
2526                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_HIGHLIGHT, timestamp);
2527                 if (ret >= 0) {
2528                         struct access_cbdata *cbdata;
2529
2530                         cbdata = malloc(sizeof(*cbdata));
2531                         if (!cbdata) {
2532                                 ret = LB_STATUS_ERROR_MEMORY;
2533                         } else {
2534                                 cbdata->inst = instance_ref(inst);
2535                                 cbdata->status = ret;
2536
2537                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2538                                         (void)instance_unref(cbdata->inst);
2539                                         DbgFree(cbdata);
2540                                         ret = LB_STATUS_ERROR_FAULT;
2541                                 } else {
2542                                         ret = LB_STATUS_SUCCESS;
2543                                 }
2544                         }
2545                 }
2546         } else {
2547                 ErrPrint("Unsupported package\n");
2548                 ret = LB_STATUS_ERROR_INVALID;
2549         }
2550
2551 out:
2552         result = packet_create_reply(packet, "i", ret);
2553         if (!result)
2554                 ErrPrint("Failed to create a reply packet\n");
2555
2556         return result;
2557 }
2558
2559 static struct packet *client_pd_access_hl_prev(pid_t pid, int handle, const struct packet *packet)
2560 {
2561         struct packet *result;
2562         struct client_node *client;
2563         const char *pkgname;
2564         const char *id;
2565         int ret;
2566         double timestamp;
2567         int x;
2568         int y;
2569         struct inst_info *inst;
2570         const struct pkg_info *pkg;
2571
2572         client = client_find_by_pid(pid);
2573         if (!client) {
2574                 ErrPrint("Client %d is not exists\n", pid);
2575                 ret = LB_STATUS_ERROR_NOT_EXIST;
2576                 goto out;
2577         }
2578
2579         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2580         if (ret != 5) {
2581                 ErrPrint("Invalid parameter\n");
2582                 ret = LB_STATUS_ERROR_INVALID;
2583                 goto out;
2584         }
2585
2586         ret = validate_request(pkgname, id, &inst, &pkg);
2587         if (ret != LB_STATUS_SUCCESS)
2588                 goto out;
2589
2590         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2591                 struct buffer_info *buffer;
2592                 struct slave_node *slave;
2593
2594                 buffer = instance_pd_buffer(inst);
2595                 if (!buffer) {
2596                         ErrPrint("Instance[%s] has no buffer\n", id);
2597                         ret = LB_STATUS_ERROR_FAULT;
2598                         goto out;
2599                 }
2600
2601                 slave = package_slave(pkg);
2602                 if (!slave) {
2603                         ErrPrint("Package[%s] has no slave\n", pkgname);
2604                         ret = LB_STATUS_ERROR_INVALID;
2605                         goto out;
2606                 }
2607
2608                 packet_ref((struct packet *)packet);
2609                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2610         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2611                 struct script_info *script;
2612                 Evas *e;
2613
2614                 script = instance_pd_script(inst);
2615                 if (!script) {
2616                         ret = LB_STATUS_ERROR_FAULT;
2617                         goto out;
2618                 }
2619
2620                 e = script_handler_evas(script);
2621                 if (!e) {
2622                         ret = LB_STATUS_ERROR_FAULT;
2623                         goto out;
2624                 }
2625
2626                 script_handler_update_pointer(script, x, y, -1);
2627                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_HIGHLIGHT_PREV, timestamp);
2628                 if (ret >= 0) {
2629                         struct access_cbdata *cbdata;
2630
2631                         cbdata = malloc(sizeof(*cbdata));
2632                         if (!cbdata) {
2633                                 ret = LB_STATUS_ERROR_MEMORY;
2634                         } else {
2635                                 cbdata->inst = instance_ref(inst);
2636                                 cbdata->status = ret;
2637
2638                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2639                                         (void)instance_unref(cbdata->inst);
2640                                         DbgFree(cbdata);
2641                                         ret = LB_STATUS_ERROR_FAULT;
2642                                 } else {
2643                                         ret = LB_STATUS_SUCCESS;
2644                                 }
2645                         }
2646                 }
2647         } else {
2648                 ErrPrint("Unsupported package\n");
2649                 ret = LB_STATUS_ERROR_INVALID;
2650         }
2651
2652 out:
2653         result = packet_create_reply(packet, "i", ret);
2654         if (!result)
2655                 ErrPrint("Failed to create a reply packet\n");
2656
2657         return result;
2658 }
2659
2660 static struct packet *client_pd_access_hl_next(pid_t pid, int handle, const struct packet *packet)
2661 {
2662         struct packet *result;
2663         struct client_node *client;
2664         const char *pkgname;
2665         const char *id;
2666         int ret;
2667         double timestamp;
2668         int x;
2669         int y;
2670         struct inst_info *inst;
2671         const struct pkg_info *pkg;
2672
2673         client = client_find_by_pid(pid);
2674         if (!client) {
2675                 ErrPrint("Client %d is not exists\n", pid);
2676                 ret = LB_STATUS_ERROR_NOT_EXIST;
2677                 goto out;
2678         }
2679
2680         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2681         if (ret != 5) {
2682                 ErrPrint("Invalid parameter\n");
2683                 ret = LB_STATUS_ERROR_INVALID;
2684                 goto out;
2685         }
2686
2687         ret = validate_request(pkgname, id, &inst, &pkg);
2688         if (ret != LB_STATUS_SUCCESS)
2689                 goto out;
2690
2691         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2692                 struct buffer_info *buffer;
2693                 struct slave_node *slave;
2694
2695                 buffer = instance_pd_buffer(inst);
2696                 if (!buffer) {
2697                         ErrPrint("Instance[%s] has no buffer\n", id);
2698                         ret = LB_STATUS_ERROR_FAULT;
2699                         goto out;
2700                 }
2701
2702                 slave = package_slave(pkg);
2703                 if (!slave) {
2704                         ErrPrint("Package[%s] has no slave\n", pkgname);
2705                         ret = LB_STATUS_ERROR_INVALID;
2706                         goto out;
2707                 }
2708
2709                 packet_ref((struct packet *)packet);
2710                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2711         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2712                 struct script_info *script;
2713                 Evas *e;
2714
2715                 script = instance_pd_script(inst);
2716                 if (!script) {
2717                         ErrPrint("Script is not created yet\n");
2718                         ret = LB_STATUS_ERROR_FAULT;
2719                         goto out;
2720                 }
2721
2722                 e = script_handler_evas(script);
2723                 if (!e) {
2724                         ErrPrint("Evas is not exists\n");
2725                         ret = LB_STATUS_ERROR_FAULT;
2726                         goto out;
2727                 }
2728
2729                 script_handler_update_pointer(script, x, y, -1);
2730                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_HIGHLIGHT_NEXT, timestamp);
2731                 if (ret >= 0) {
2732                         struct access_cbdata *cbdata;
2733
2734                         cbdata = malloc(sizeof(*cbdata));
2735                         if (!cbdata) {
2736                                 ErrPrint("Heap: %s\n", strerror(errno));
2737                                 ret = LB_STATUS_ERROR_MEMORY;
2738                         } else {
2739                                 cbdata->inst = instance_ref(inst);
2740                                 cbdata->status = ret;
2741
2742                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2743                                         ErrPrint("Failed to add timer\n");
2744                                         (void)instance_unref(cbdata->inst);
2745                                         DbgFree(cbdata);
2746                                         ret = LB_STATUS_ERROR_FAULT;
2747                                 } else {
2748                                         ret = LB_STATUS_SUCCESS;
2749                                 }
2750                         }
2751                 } else {
2752                         DbgPrint("Returns: %d\n", ret);
2753                 }
2754         } else {
2755                 ErrPrint("Unsupported package\n");
2756                 ret = LB_STATUS_ERROR_INVALID;
2757         }
2758
2759 out:
2760         result = packet_create_reply(packet, "i", ret);
2761         if (!result)
2762                 ErrPrint("Failed to create a reply packet\n");
2763
2764         return result;
2765 }
2766
2767 static struct packet *client_pd_access_activate(pid_t pid, int handle, const struct packet *packet)
2768 {
2769         struct packet *result;
2770         struct client_node *client;
2771         const char *pkgname;
2772         const char *id;
2773         int ret;
2774         double timestamp;
2775         int x;
2776         int y;
2777         struct inst_info *inst;
2778         const struct pkg_info *pkg;
2779
2780         client = client_find_by_pid(pid);
2781         if (!client) {
2782                 ErrPrint("Client %d is not exists\n", pid);
2783                 ret = LB_STATUS_ERROR_NOT_EXIST;
2784                 goto out;
2785         }
2786
2787         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2788         if (ret != 5) {
2789                 ErrPrint("Invalid parameter\n");
2790                 ret = LB_STATUS_ERROR_INVALID;
2791                 goto out;
2792         }
2793
2794         ret = validate_request(pkgname, id, &inst, &pkg);
2795         if (ret != LB_STATUS_SUCCESS)
2796                 goto out;
2797
2798         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2799                 struct buffer_info *buffer;
2800                 struct slave_node *slave;
2801
2802                 buffer = instance_pd_buffer(inst);
2803                 if (!buffer) {
2804                         ErrPrint("Instance[%s] has no buffer\n", id);
2805                         ret = LB_STATUS_ERROR_FAULT;
2806                         goto out;
2807                 }
2808
2809                 slave = package_slave(pkg);
2810                 if (!slave) {
2811                         ErrPrint("Package[%s] has no slave\n", pkgname);
2812                         ret = LB_STATUS_ERROR_INVALID;
2813                         goto out;
2814                 }
2815
2816                 packet_ref((struct packet *)packet);
2817                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2818         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2819                 struct script_info *script;
2820                 Evas *e;
2821
2822                 script = instance_pd_script(inst);
2823                 if (!script) {
2824                         ret = LB_STATUS_ERROR_FAULT;
2825                         goto out;
2826                 }
2827
2828                 e = script_handler_evas(script);
2829                 if (!e) {
2830                         ret = LB_STATUS_ERROR_FAULT;
2831                         goto out;
2832                 }
2833
2834                 script_handler_update_pointer(script, x, y, -1);
2835                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_ACTIVATE, timestamp);
2836                 if (ret >= 0) {
2837                         struct access_cbdata *cbdata;
2838
2839                         cbdata = malloc(sizeof(*cbdata));
2840                         if (!cbdata) {
2841                                 ret = LB_STATUS_ERROR_MEMORY;
2842                         } else {
2843                                 cbdata->inst = instance_ref(inst);
2844                                 cbdata->status = ret;
2845
2846                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
2847                                         (void)instance_unref(cbdata->inst);
2848                                         DbgFree(cbdata);
2849                                         ret = LB_STATUS_ERROR_FAULT;
2850                                 } else {
2851                                         ret = LB_STATUS_SUCCESS;
2852                                 }
2853                         }
2854                 }
2855         } else {
2856                 ErrPrint("Unsupported package\n");
2857                 ret = LB_STATUS_ERROR_INVALID;
2858         }
2859
2860 out:
2861         result = packet_create_reply(packet, "i", ret);
2862         if (!result)
2863                 ErrPrint("Failed to create a reply packet\n");
2864
2865         return result;
2866 }
2867
2868 static struct packet *client_pd_key_down(pid_t pid, int handle, const struct packet *packet)
2869 {
2870         struct client_node *client;
2871         const char *pkgname;
2872         const char *id;
2873         int ret;
2874         double timestamp;
2875         int x;
2876         int y;
2877         struct inst_info *inst;
2878         const struct pkg_info *pkg;
2879
2880         client = client_find_by_pid(pid);
2881         if (!client) {
2882                 ErrPrint("Client %d is not exists\n", pid);
2883                 ret = LB_STATUS_ERROR_NOT_EXIST;
2884                 goto out;
2885         }
2886
2887         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
2888         if (ret != 5) {
2889                 ErrPrint("Invalid parameter\n");
2890                 ret = LB_STATUS_ERROR_INVALID;
2891                 goto out;
2892         }
2893
2894         ret = validate_request(pkgname, id, &inst, &pkg);
2895         if (ret != LB_STATUS_SUCCESS)
2896                 goto out;
2897
2898         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
2899                 struct buffer_info *buffer;
2900                 struct slave_node *slave;
2901
2902                 buffer = instance_pd_buffer(inst);
2903                 if (!buffer) {
2904                         ErrPrint("Instance[%s] has no buffer\n", id);
2905                         ret = LB_STATUS_ERROR_FAULT;
2906                         goto out;
2907                 }
2908
2909                 slave = package_slave(pkg);
2910                 if (!slave) {
2911                         ErrPrint("Package[%s] has no slave\n", pkgname);
2912                         ret = LB_STATUS_ERROR_INVALID;
2913                         goto out;
2914                 }
2915
2916                 packet_ref((struct packet *)packet);
2917                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
2918         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
2919                 struct script_info *script;
2920                 Evas *e;
2921
2922                 script = instance_pd_script(inst);
2923                 if (!script) {
2924                         ret = LB_STATUS_ERROR_FAULT;
2925                         goto out;
2926                 }
2927
2928                 e = script_handler_evas(script);
2929                 if (!e) {
2930                         ret = LB_STATUS_ERROR_FAULT;
2931                         goto out;
2932                 }
2933
2934                 script_handler_update_pointer(script, x, y, -1);
2935                 /*!
2936                  * \TODO: Push up the KEY_DOWN event
2937                  */
2938                 ret = 0;
2939         } else {
2940                 ErrPrint("Unsupported package\n");
2941                 ret = LB_STATUS_ERROR_INVALID;
2942         }
2943
2944 out:
2945         /*! \note No reply packet */
2946         return NULL;
2947 }
2948
2949 static struct packet *client_pause_request(pid_t pid, int handle, const struct packet *packet)
2950 {
2951         struct client_node *client;
2952         double timestamp;
2953         int ret;
2954
2955         client = client_find_by_pid(pid);
2956         if (!client) {
2957                 ErrPrint("Client %d is paused - manually reported\n", pid);
2958                 ret = LB_STATUS_ERROR_NOT_EXIST;
2959                 goto out;
2960         }
2961
2962         ret = packet_get(packet, "d", &timestamp);
2963         if (ret != 1) {
2964                 ErrPrint("Invalid parameter\n");
2965                 ret = LB_STATUS_ERROR_INVALID;
2966                 goto out;
2967         }
2968
2969         if (USE_XMONITOR)
2970                 DbgPrint("XMONITOR enabled. ignore client paused request\n");
2971         else
2972                 xmonitor_pause(client);
2973
2974 out:
2975         return NULL;
2976 }
2977
2978 static struct packet *client_resume_request(pid_t pid, int handle, const struct packet *packet)
2979 {
2980         struct client_node *client;
2981         double timestamp;
2982         int ret;
2983
2984         client = client_find_by_pid(pid);
2985         if (!client) {
2986                 ErrPrint("Client %d is not exists\n", pid);
2987                 goto out;
2988         }
2989
2990         ret = packet_get(packet, "d", &timestamp);
2991         if (ret != 1) {
2992                 ErrPrint("Invalid parameter\n");
2993                 goto out;
2994         }
2995
2996         if (USE_XMONITOR)
2997                 DbgPrint("XMONITOR enabled. ignore client resumed request\n");
2998         else
2999                 xmonitor_resume(client);
3000
3001 out:
3002         return NULL;
3003 }
3004
3005 static struct packet *client_pd_key_up(pid_t pid, int handle, const struct packet *packet)
3006 {
3007         struct client_node *client;
3008         const char *pkgname;
3009         const char *id;
3010         int ret;
3011         double timestamp;
3012         int x;
3013         int y;
3014         struct inst_info *inst;
3015         const struct pkg_info *pkg;
3016
3017         client = client_find_by_pid(pid);
3018         if (!client) {
3019                 ErrPrint("Client %d is not exists\n", pid);
3020                 ret = LB_STATUS_ERROR_NOT_EXIST;
3021                 goto out;
3022         }
3023
3024         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3025         if (ret != 7) {
3026                 ErrPrint("Invalid parameter\n");
3027                 ret = LB_STATUS_ERROR_INVALID;
3028                 goto out;
3029         }
3030
3031         ret = validate_request(pkgname, id, &inst, &pkg);
3032         if (ret != LB_STATUS_SUCCESS)
3033                 goto out;
3034
3035         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
3036                 struct buffer_info *buffer;
3037                 struct slave_node *slave;
3038
3039                 buffer = instance_pd_buffer(inst);
3040                 if (!buffer) {
3041                         ErrPrint("Instance[%s] has no buffer\n", id);
3042                         ret = LB_STATUS_ERROR_FAULT;
3043                         goto out;
3044                 }
3045
3046                 slave = package_slave(pkg);
3047                 if (!slave) {
3048                         ErrPrint("Package[%s] has no slave\n", pkgname);
3049                         ret = LB_STATUS_ERROR_INVALID;
3050                         goto out;
3051                 }
3052
3053                 packet_ref((struct packet *)packet);
3054                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3055         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
3056                 struct script_info *script;
3057                 Evas *e;
3058
3059                 script = instance_pd_script(inst);
3060                 if (!script) {
3061                         ret = LB_STATUS_ERROR_FAULT;
3062                         goto out;
3063                 }
3064
3065                 e = script_handler_evas(script);
3066                 if (!e) {
3067                         ret = LB_STATUS_ERROR_FAULT;
3068                         goto out;
3069                 }
3070
3071                 script_handler_update_pointer(script, x, y, -1);
3072                 /*!
3073                  * \TODO: Push up the KEY_UP event
3074                  */
3075                 ret = 0;
3076         } else {
3077                 ErrPrint("Unsupported package\n");
3078                 ret = LB_STATUS_ERROR_INVALID;
3079         }
3080
3081 out:
3082         /*! \note No reply packet */
3083         return NULL;
3084 }
3085
3086 static struct packet *client_lb_access_hl(pid_t pid, int handle, const struct packet *packet)
3087 {
3088         struct packet *result;
3089         struct client_node *client;
3090         const char *pkgname;
3091         const char *id;
3092         int ret;
3093         double timestamp;
3094         int x;
3095         int y;
3096         struct inst_info *inst;
3097         const struct pkg_info *pkg;
3098
3099         client = client_find_by_pid(pid);
3100         if (!client) {
3101                 ErrPrint("Client %d is not exists\n", pid);
3102                 ret = LB_STATUS_ERROR_NOT_EXIST;
3103                 goto out;
3104         }
3105
3106         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3107         if (ret != 5) {
3108                 ErrPrint("Parameter is not matched\n");
3109                 ret = LB_STATUS_ERROR_INVALID;
3110                 goto out;
3111         }
3112
3113         ret = validate_request(pkgname, id, &inst, &pkg);
3114         if (ret != LB_STATUS_SUCCESS)
3115                 goto out;
3116
3117         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3118                 struct buffer_info *buffer;
3119                 struct slave_node *slave;
3120
3121                 buffer = instance_lb_buffer(inst);
3122                 if (!buffer) {
3123                         ErrPrint("Instance[%s] has no buffer\n", id);
3124                         ret = LB_STATUS_ERROR_FAULT;
3125                         goto out;
3126                 }
3127
3128                 slave = package_slave(pkg);
3129                 if (!slave) {
3130                         ErrPrint("Package[%s] has no slave\n", pkgname);
3131                         ret = LB_STATUS_ERROR_INVALID;
3132                         goto out;
3133                 }
3134
3135                 packet_ref((struct packet *)packet);
3136                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3137         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3138                 struct script_info *script;
3139                 Evas *e;
3140
3141                 script = instance_lb_script(inst);
3142                 if (!script) {
3143                         ret = LB_STATUS_ERROR_FAULT;
3144                         goto out;
3145                 }
3146
3147                 e = script_handler_evas(script);
3148                 if (!e) {
3149                         ret = LB_STATUS_ERROR_FAULT;
3150                         goto out;
3151                 }
3152
3153                 script_handler_update_pointer(script, x, y, -1);
3154                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_HIGHLIGHT, timestamp);
3155                 if (ret >= 0) {
3156                         struct access_cbdata *cbdata;
3157
3158                         cbdata = malloc(sizeof(*cbdata));
3159                         if (!cbdata) {
3160                                 ret = LB_STATUS_ERROR_MEMORY;
3161                         } else {
3162                                 cbdata->inst = instance_ref(inst);
3163                                 cbdata->status = ret;
3164
3165                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3166                                         (void)instance_unref(cbdata->inst);
3167                                         DbgFree(cbdata);
3168                                         ret = LB_STATUS_ERROR_FAULT;
3169                                 } else {
3170                                         ret = LB_STATUS_SUCCESS;
3171                                 }
3172                         }
3173                 }
3174         } else {
3175                 ErrPrint("Unsupported package\n");
3176                 ret = LB_STATUS_ERROR_INVALID;
3177         }
3178
3179 out:
3180         result = packet_create_reply(packet, "i", ret);
3181         if (!result)
3182                 ErrPrint("Failed to create a reply packet\n");
3183
3184         return result;
3185 }
3186
3187 static struct packet *client_lb_access_hl_prev(pid_t pid, int handle, const struct packet *packet)
3188 {
3189         struct packet *result;
3190         struct client_node *client;
3191         const char *pkgname;
3192         const char *id;
3193         int ret;
3194         double timestamp;
3195         int x;
3196         int y;
3197         struct inst_info *inst;
3198         const struct pkg_info *pkg;
3199
3200         client = client_find_by_pid(pid);
3201         if (!client) {
3202                 ErrPrint("Client %d is not exists\n", pid);
3203                 ret = LB_STATUS_ERROR_NOT_EXIST;
3204                 goto out;
3205         }
3206
3207         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3208         if (ret != 5) {
3209                 ErrPrint("Parameter is not matched\n");
3210                 ret = LB_STATUS_ERROR_INVALID;
3211                 goto out;
3212         }
3213
3214         ret = validate_request(pkgname, id, &inst, &pkg);
3215         if (ret != LB_STATUS_SUCCESS)
3216                 goto out;
3217
3218         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3219                 struct buffer_info *buffer;
3220                 struct slave_node *slave;
3221
3222                 buffer = instance_lb_buffer(inst);
3223                 if (!buffer) {
3224                         ErrPrint("Instance[%s] has no buffer\n", id);
3225                         ret = LB_STATUS_ERROR_FAULT;
3226                         goto out;
3227                 }
3228
3229                 slave = package_slave(pkg);
3230                 if (!slave) {
3231                         ErrPrint("Package[%s] has no slave\n", pkgname);
3232                         ret = LB_STATUS_ERROR_INVALID;
3233                         goto out;
3234                 }
3235
3236                 packet_ref((struct packet *)packet);
3237                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3238         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3239                 struct script_info *script;
3240                 Evas *e;
3241
3242                 script = instance_lb_script(inst);
3243                 if (!script) {
3244                         ret = LB_STATUS_ERROR_FAULT;
3245                         goto out;
3246                 }
3247
3248                 e = script_handler_evas(script);
3249                 if (!e) {
3250                         ret = LB_STATUS_ERROR_FAULT;
3251                         goto out;
3252                 }
3253
3254                 script_handler_update_pointer(script, x, y, -1);
3255                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_HIGHLIGHT_PREV, timestamp);
3256                 if (ret >= 0) {
3257                         struct access_cbdata *cbdata;
3258
3259                         cbdata = malloc(sizeof(*cbdata));
3260                         if (!cbdata) {
3261                                 ret = LB_STATUS_ERROR_MEMORY;
3262                         } else {
3263                                 cbdata->inst = instance_ref(inst);
3264                                 cbdata->status = ret;
3265
3266                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3267                                         (void)instance_unref(cbdata->inst);
3268                                         DbgFree(cbdata);
3269                                         ret = LB_STATUS_ERROR_FAULT;
3270                                 } else {
3271                                         ret = LB_STATUS_SUCCESS;
3272                                 }
3273                         }
3274                 }
3275         } else {
3276                 ErrPrint("Unsupported package\n");
3277                 ret = LB_STATUS_ERROR_INVALID;
3278         }
3279
3280 out:
3281         result = packet_create_reply(packet, "i", ret);
3282         if (!result)
3283                 ErrPrint("Failed to create a reply packet\n");
3284
3285         return result;
3286 }
3287
3288 static struct packet *client_lb_access_hl_next(pid_t pid, int handle, const struct packet *packet)
3289 {
3290         struct packet *result;
3291         struct client_node *client;
3292         const char *pkgname;
3293         const char *id;
3294         int ret;
3295         double timestamp;
3296         int x;
3297         int y;
3298         struct inst_info *inst;
3299         const struct pkg_info *pkg;
3300
3301         client = client_find_by_pid(pid);
3302         if (!client) {
3303                 ErrPrint("Client %d is not exists\n", pid);
3304                 ret = LB_STATUS_ERROR_NOT_EXIST;
3305                 goto out;
3306         }
3307
3308         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3309         if (ret != 5) {
3310                 ErrPrint("Parameter is not matched\n");
3311                 ret = LB_STATUS_ERROR_INVALID;
3312                 goto out;
3313         }
3314
3315         ret = validate_request(pkgname, id, &inst, &pkg);
3316         if (ret != LB_STATUS_SUCCESS)
3317                 goto out;
3318
3319         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3320                 struct buffer_info *buffer;
3321                 struct slave_node *slave;
3322
3323                 buffer = instance_lb_buffer(inst);
3324                 if (!buffer) {
3325                         ErrPrint("Instance[%s] has no buffer\n", id);
3326                         ret = LB_STATUS_ERROR_FAULT;
3327                         goto out;
3328                 }
3329
3330                 slave = package_slave(pkg);
3331                 if (!slave) {
3332                         ErrPrint("Package[%s] has no slave\n", pkgname);
3333                         ret = LB_STATUS_ERROR_INVALID;
3334                         goto out;
3335                 }
3336
3337                 packet_ref((struct packet *)packet);
3338                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3339         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3340                 struct script_info *script;
3341                 Evas *e;
3342
3343                 script = instance_lb_script(inst);
3344                 if (!script) {
3345                         ret = LB_STATUS_ERROR_FAULT;
3346                         goto out;
3347                 }
3348
3349                 e = script_handler_evas(script);
3350                 if (!e) {
3351                         ret = LB_STATUS_ERROR_FAULT;
3352                         goto out;
3353                 }
3354
3355                 script_handler_update_pointer(script, x, y, -1);
3356                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_HIGHLIGHT_NEXT, timestamp);
3357                 if (ret >= 0) {
3358                         struct access_cbdata *cbdata;
3359
3360                         cbdata = malloc(sizeof(*cbdata));
3361                         if (!cbdata) {
3362                                 ret = LB_STATUS_ERROR_MEMORY;
3363                         } else {
3364                                 cbdata->inst = instance_ref(inst);
3365                                 cbdata->status = ret;
3366
3367                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3368                                         (void)instance_unref(cbdata->inst);
3369                                         DbgFree(cbdata);
3370                                         ret = LB_STATUS_ERROR_FAULT;
3371                                 } else {
3372                                         ret = LB_STATUS_SUCCESS;
3373                                 }
3374                         }
3375                 }
3376         } else {
3377                 ErrPrint("Unsupported package\n");
3378                 ret = LB_STATUS_ERROR_INVALID;
3379         }
3380
3381 out:
3382         result = packet_create_reply(packet, "i", ret);
3383         if (!result)
3384                 ErrPrint("Failed to create a reply packet\n");
3385
3386         return result;
3387 }
3388
3389 static struct packet *client_lb_access_action_up(pid_t pid, int handle, const struct packet *packet)
3390 {
3391         struct packet *result;
3392         struct client_node *client;
3393         const char *pkgname;
3394         const char *id;
3395         int ret;
3396         double timestamp;
3397         struct inst_info *inst;
3398         const struct pkg_info *pkg;
3399         int x;
3400         int y;
3401
3402         client = client_find_by_pid(pid);
3403         if (!client) {
3404                 ErrPrint("Client %d is not exist\n", pid);
3405                 ret = LB_STATUS_ERROR_NOT_EXIST;
3406                 goto out;
3407         }
3408
3409         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3410         if (ret != 5) {
3411                 ErrPrint("Parameter is not matched\n");
3412                 ret = LB_STATUS_ERROR_INVALID;
3413                 goto out;
3414         }
3415
3416         ret = validate_request(pkgname, id, &inst, &pkg);
3417         if (ret != LB_STATUS_SUCCESS)
3418                 goto out;
3419
3420         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3421                 struct buffer_info *buffer;
3422                 struct slave_node *slave;
3423
3424                 buffer = instance_lb_buffer(inst);
3425                 if (!buffer) {
3426                         ErrPrint("Instance[%s] has no buffer\n", id);
3427                         ret = LB_STATUS_ERROR_FAULT;
3428                         goto out;
3429                 }
3430
3431                 slave = package_slave(pkg);
3432                 if (!slave) {
3433                         ErrPrint("Slave is not exists\n");
3434                         ret = LB_STATUS_ERROR_INVALID;
3435                         goto out;
3436                 }
3437
3438                 packet_ref((struct packet *)packet);
3439                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3440                 /*!
3441                  * Enen if it fails to send packet,
3442                  * The packet will be unref'd
3443                  * So we don't need to check the ret value.
3444                  */
3445         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3446                 struct script_info *script;
3447                 Evas *e;
3448
3449                 script = instance_lb_script(inst);
3450                 if (!script) {
3451                         ErrPrint("Instance has no script\n");
3452                         ret = LB_STATUS_ERROR_FAULT;
3453                         goto out;
3454                 }
3455
3456                 e = script_handler_evas(script);
3457                 if (!e) {
3458                         ErrPrint("Script has no evas\n");
3459                         ret = LB_STATUS_ERROR_INVALID;
3460                         goto out;
3461                 }
3462
3463                 script_handler_update_pointer(script, x, y, 0);
3464                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_ACTION, timestamp);
3465                 if (ret >= 0) {
3466                         struct access_cbdata *cbdata;
3467
3468                         cbdata = malloc(sizeof(*cbdata));
3469                         if (!cbdata) {
3470                                 ret = LB_STATUS_ERROR_MEMORY;
3471                         } else {
3472                                 cbdata->inst = instance_ref(inst);
3473                                 cbdata->status = ret;
3474
3475                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3476                                         (void)instance_unref(cbdata->inst);
3477                                         DbgFree(cbdata);
3478                                         ret = LB_STATUS_ERROR_FAULT;
3479                                 } else {
3480                                         ret = LB_STATUS_SUCCESS;
3481                                 }
3482                         }
3483                 }
3484         } else {
3485                 ErrPrint("Unsupported package\n");
3486                 ret = LB_STATUS_ERROR_INVALID;
3487         }
3488
3489 out:
3490         result = packet_create_reply(packet, "i", ret);
3491         if (!result)
3492                 ErrPrint("Failed to create a reply packet\n");
3493
3494         return result;
3495 }
3496
3497 static struct packet *client_lb_access_action_down(pid_t pid, int handle, const struct packet *packet)
3498 {
3499         struct packet *result;
3500         struct client_node *client;
3501         const char *pkgname;
3502         const char *id;
3503         int ret;
3504         double timestamp;
3505         struct inst_info *inst;
3506         const struct pkg_info *pkg;
3507         int x;
3508         int y;
3509
3510         client = client_find_by_pid(pid);
3511         if (!client) {
3512                 ErrPrint("Client %d is not exist\n", pid);
3513                 ret = LB_STATUS_ERROR_NOT_EXIST;
3514                 goto out;
3515         }
3516
3517         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3518         if (ret != 5) {
3519                 ErrPrint("Parameter is not matched\n");
3520                 ret = LB_STATUS_ERROR_INVALID;
3521                 goto out;
3522         }
3523
3524         ret = validate_request(pkgname, id, &inst, &pkg);
3525         if (ret != LB_STATUS_SUCCESS)
3526                 goto out;
3527
3528         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3529                 struct buffer_info *buffer;
3530                 struct slave_node *slave;
3531
3532                 buffer = instance_lb_buffer(inst);
3533                 if (!buffer) {
3534                         ErrPrint("Instance[%s] has no buffer\n", id);
3535                         ret = LB_STATUS_ERROR_FAULT;
3536                         goto out;
3537                 }
3538
3539                 slave = package_slave(pkg);
3540                 if (!slave) {
3541                         ErrPrint("Slave is not exists\n");
3542                         ret = LB_STATUS_ERROR_INVALID;
3543                         goto out;
3544                 }
3545
3546                 packet_ref((struct packet *)packet);
3547                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3548                 /*!
3549                  * Enen if it fails to send packet,
3550                  * The packet will be unref'd
3551                  * So we don't need to check the ret value.
3552                  */
3553         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3554                 struct script_info *script;
3555                 Evas *e;
3556
3557                 script = instance_lb_script(inst);
3558                 if (!script) {
3559                         ErrPrint("Instance has no script\n");
3560                         ret = LB_STATUS_ERROR_FAULT;
3561                         goto out;
3562                 }
3563
3564                 e = script_handler_evas(script);
3565                 if (!e) {
3566                         ErrPrint("Script has no evas\n");
3567                         ret = LB_STATUS_ERROR_INVALID;
3568                         goto out;
3569                 }
3570
3571                 script_handler_update_pointer(script, x, y, 1);
3572                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_ACTION, timestamp);
3573                 if (ret >= 0) {
3574                         struct access_cbdata *cbdata;
3575
3576                         cbdata = malloc(sizeof(*cbdata));
3577                         if (!cbdata) {
3578                                 ret = LB_STATUS_ERROR_MEMORY;
3579                         } else {
3580                                 cbdata->inst = instance_ref(inst);
3581                                 cbdata->status = ret;
3582
3583                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3584                                         (void)instance_unref(cbdata->inst);
3585                                         DbgFree(cbdata);
3586                                         ret = LB_STATUS_ERROR_FAULT;
3587                                 } else {
3588                                         ret = LB_STATUS_SUCCESS;
3589                                 }
3590                         }
3591                 }
3592         } else {
3593                 ErrPrint("Unsupported package\n");
3594                 ret = LB_STATUS_ERROR_INVALID;
3595         }
3596
3597 out:
3598         result = packet_create_reply(packet, "i", ret);
3599         if (!result)
3600                 ErrPrint("Failed to create a reply packet\n");
3601
3602         return result;
3603 }
3604
3605 static struct packet *client_lb_access_unhighlight(pid_t pid, int handle, const struct packet *packet)
3606 {
3607         struct packet *result;
3608         struct client_node *client;
3609         const char *pkgname;
3610         const char *id;
3611         int ret;
3612         double timestamp;
3613         int x;
3614         int y;
3615         struct inst_info *inst;
3616         const struct pkg_info *pkg;
3617
3618         client = client_find_by_pid(pid);
3619         if (!client) {
3620                 ErrPrint("Client %d is not exists\n", pid);
3621                 ret = LB_STATUS_ERROR_NOT_EXIST;
3622                 goto out;
3623         }
3624
3625         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3626         if (ret != 5) {
3627                 ErrPrint("Parameter is not matched\n");
3628                 ret = LB_STATUS_ERROR_INVALID;
3629                 goto out;
3630         }
3631
3632         ret = validate_request(pkgname, id, &inst, &pkg);
3633         if (ret != LB_STATUS_SUCCESS)
3634                 goto out;
3635
3636         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3637                 struct buffer_info *buffer;
3638                 struct slave_node *slave;
3639
3640                 buffer = instance_lb_buffer(inst);
3641                 if (!buffer) {
3642                         ErrPrint("Instance[%s] has no buffer\n", id);
3643                         ret = LB_STATUS_ERROR_FAULT;
3644                         goto out;
3645                 }
3646
3647                 slave = package_slave(pkg);
3648                 if (!slave) {
3649                         ErrPrint("Package[%s] has no slave\n", pkgname);
3650                         ret = LB_STATUS_ERROR_INVALID;
3651                         goto out;
3652                 }
3653
3654                 packet_ref((struct packet *)packet);
3655                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3656         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3657                 struct script_info *script;
3658                 Evas *e;
3659
3660                 script = instance_lb_script(inst);
3661                 if (!script) {
3662                         ret = LB_STATUS_ERROR_FAULT;
3663                         goto out;
3664                 }
3665
3666                 e = script_handler_evas(script);
3667                 if (!e) {
3668                         ret = LB_STATUS_ERROR_FAULT;
3669                         goto out;
3670                 }
3671
3672                 script_handler_update_pointer(script, x, y, -1);
3673                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_UNHIGHLIGHT, timestamp);
3674                 if (ret >= 0) {
3675                         struct access_cbdata *cbdata;
3676
3677                         cbdata = malloc(sizeof(*cbdata));
3678                         if (!cbdata) {
3679                                 ret = LB_STATUS_ERROR_MEMORY;
3680                         } else {
3681                                 cbdata->inst = instance_ref(inst);
3682                                 cbdata->status = ret;
3683
3684                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3685                                         (void)instance_unref(cbdata->inst);
3686                                         DbgFree(cbdata);
3687                                         ret = LB_STATUS_ERROR_FAULT;
3688                                 } else {
3689                                         ret = LB_STATUS_SUCCESS;
3690                                 }
3691                         }
3692                 }
3693         } else {
3694                 ErrPrint("Unsupported package\n");
3695                 ret = LB_STATUS_ERROR_INVALID;
3696         }
3697
3698 out:
3699         result = packet_create_reply(packet, "i", ret);
3700         if (!result)
3701                 ErrPrint("Failed to create a reply packet\n");
3702
3703         return result;
3704 }
3705
3706 static struct packet *client_lb_access_scroll_down(pid_t pid, int handle, const struct packet *packet)
3707 {
3708         struct packet *result;
3709         struct client_node *client;
3710         const char *pkgname;
3711         const char *id;
3712         int ret;
3713         double timestamp;
3714         struct inst_info *inst;
3715         const struct pkg_info *pkg;
3716         int x;
3717         int y;
3718
3719         client = client_find_by_pid(pid);
3720         if (!client) {
3721                 ErrPrint("Client %d is not exist\n", pid);
3722                 ret = LB_STATUS_ERROR_NOT_EXIST;
3723                 goto out;
3724         }
3725
3726         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3727         if (ret != 5) {
3728                 ErrPrint("Parameter is not matched\n");
3729                 ret = LB_STATUS_ERROR_INVALID;
3730                 goto out;
3731         }
3732
3733         ret = validate_request(pkgname, id, &inst, &pkg);
3734         if (ret != LB_STATUS_SUCCESS)
3735                 goto out;
3736
3737         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3738                 struct buffer_info *buffer;
3739                 struct slave_node *slave;
3740
3741                 buffer = instance_lb_buffer(inst);
3742                 if (!buffer) {
3743                         ErrPrint("Instance[%s] has no buffer\n", id);
3744                         ret = LB_STATUS_ERROR_FAULT;
3745                         goto out;
3746                 }
3747
3748                 slave = package_slave(pkg);
3749                 if (!slave) {
3750                         ErrPrint("Slave is not exists\n");
3751                         ret = LB_STATUS_ERROR_INVALID;
3752                         goto out;
3753                 }
3754
3755                 packet_ref((struct packet *)packet);
3756                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3757                 /*!
3758                  * Enen if it fails to send packet,
3759                  * The packet will be unref'd
3760                  * So we don't need to check the ret value.
3761                  */
3762         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3763                 struct script_info *script;
3764                 Evas *e;
3765
3766                 script = instance_lb_script(inst);
3767                 if (!script) {
3768                         ErrPrint("Instance has no script\n");
3769                         ret = LB_STATUS_ERROR_FAULT;
3770                         goto out;
3771                 }
3772
3773                 e = script_handler_evas(script);
3774                 if (!e) {
3775                         ErrPrint("Instance has no evas\n");
3776                         ret = LB_STATUS_ERROR_INVALID;
3777                         goto out;
3778                 }
3779
3780                 script_handler_update_pointer(script, x, y, 1);
3781                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_SCROLL, timestamp);
3782                 if (ret >= 0) {
3783                         struct access_cbdata *cbdata;
3784
3785                         cbdata = malloc(sizeof(*cbdata));
3786                         if (!cbdata) {
3787                                 ret = LB_STATUS_ERROR_MEMORY;
3788                         } else {
3789                                 cbdata->inst = instance_ref(inst);
3790                                 cbdata->status = ret;
3791
3792                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3793                                         (void)instance_unref(cbdata->inst);
3794                                         DbgFree(cbdata);
3795                                         ret = LB_STATUS_ERROR_FAULT;
3796                                 } else {
3797                                         ret = LB_STATUS_SUCCESS;
3798                                 }
3799                         }
3800                 }
3801         } else {
3802                 ErrPrint("Unsupported package\n");
3803                 ret = LB_STATUS_ERROR_INVALID;
3804         }
3805
3806 out:
3807         result = packet_create_reply(packet, "i", ret);
3808         if (!result)
3809                 ErrPrint("Failed to create a reply packet\n");
3810
3811         return result;
3812 }
3813
3814 static struct packet *client_lb_access_scroll_move(pid_t pid, int handle, const struct packet *packet)
3815 {
3816         struct packet *result;
3817         struct client_node *client;
3818         const char *pkgname;
3819         const char *id;
3820         int ret;
3821         double timestamp;
3822         struct inst_info *inst;
3823         const struct pkg_info *pkg;
3824         int x;
3825         int y;
3826
3827         client = client_find_by_pid(pid);
3828         if (!client) {
3829                 ErrPrint("Client %d is not exist\n", pid);
3830                 ret = LB_STATUS_ERROR_NOT_EXIST;
3831                 goto out;
3832         }
3833
3834         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3835         if (ret != 5) {
3836                 ErrPrint("Parameter is not matched\n");
3837                 ret = LB_STATUS_ERROR_INVALID;
3838                 goto out;
3839         }
3840
3841         ret = validate_request(pkgname, id, &inst, &pkg);
3842         if (ret != LB_STATUS_SUCCESS)
3843                 goto out;
3844
3845         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3846                 struct buffer_info *buffer;
3847                 struct slave_node *slave;
3848
3849                 buffer = instance_lb_buffer(inst);
3850                 if (!buffer) {
3851                         ErrPrint("Instance[%s] has no buffer\n", id);
3852                         ret = LB_STATUS_ERROR_FAULT;
3853                         goto out;
3854                 }
3855
3856                 slave = package_slave(pkg);
3857                 if (!slave) {
3858                         ErrPrint("Slave is not exists\n");
3859                         ret = LB_STATUS_ERROR_INVALID;
3860                         goto out;
3861                 }
3862
3863                 packet_ref((struct packet *)packet);
3864                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3865                 /*!
3866                  * Enen if it fails to send packet,
3867                  * The packet will be unref'd
3868                  * So we don't need to check the ret value.
3869                  */
3870         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3871                 struct script_info *script;
3872                 Evas *e;
3873
3874                 script = instance_lb_script(inst);
3875                 if (!script) {
3876                         ErrPrint("Instance has no script\n");
3877                         ret = LB_STATUS_ERROR_FAULT;
3878                         goto out;
3879                 }
3880
3881                 e = script_handler_evas(script);
3882                 if (!e) {
3883                         ErrPrint("Instance has no evas\n");
3884                         ret = LB_STATUS_ERROR_INVALID;
3885                         goto out;
3886                 }
3887
3888                 script_handler_update_pointer(script, x, y, -1);
3889                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_SCROLL, timestamp);
3890                 if (ret >= 0) {
3891                         struct access_cbdata *cbdata;
3892
3893                         cbdata = malloc(sizeof(*cbdata));
3894                         if (!cbdata) {
3895                                 ret = LB_STATUS_ERROR_MEMORY;
3896                         } else {
3897                                 cbdata->inst = instance_ref(inst);
3898                                 cbdata->status = ret;
3899
3900                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
3901                                         (void)instance_unref(cbdata->inst);
3902                                         DbgFree(cbdata);
3903                                         ret = LB_STATUS_ERROR_FAULT;
3904                                 } else {
3905                                         ret = LB_STATUS_SUCCESS;
3906                                 }
3907                         }
3908                 }
3909         } else {
3910                 ErrPrint("Unsupported package\n");
3911                 ret = LB_STATUS_ERROR_INVALID;
3912         }
3913
3914 out:
3915         result = packet_create_reply(packet, "i", ret);
3916         if (!result)
3917                 ErrPrint("Failed to create a reply packet\n");
3918
3919         return result;
3920 }
3921
3922 static struct packet *client_lb_access_scroll_up(pid_t pid, int handle, const struct packet *packet)
3923 {
3924         struct packet *result;
3925         struct client_node *client;
3926         const char *pkgname;
3927         const char *id;
3928         int ret;
3929         double timestamp;
3930         struct inst_info *inst;
3931         const struct pkg_info *pkg;
3932         int x;
3933         int y;
3934
3935         client = client_find_by_pid(pid);
3936         if (!client) {
3937                 ErrPrint("Client %d is not exist\n", pid);
3938                 ret = LB_STATUS_ERROR_NOT_EXIST;
3939                 goto out;
3940         }
3941
3942         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
3943         if (ret != 5) {
3944                 ErrPrint("Parameter is not matched\n");
3945                 ret = LB_STATUS_ERROR_INVALID;
3946                 goto out;
3947         }
3948
3949         ret = validate_request(pkgname, id, &inst, &pkg);
3950         if (ret != LB_STATUS_SUCCESS)
3951                 goto out;
3952
3953         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
3954                 struct buffer_info *buffer;
3955                 struct slave_node *slave;
3956
3957                 buffer = instance_lb_buffer(inst);
3958                 if (!buffer) {
3959                         ErrPrint("Instance[%s] has no buffer\n", id);
3960                         ret = LB_STATUS_ERROR_FAULT;
3961                         goto out;
3962                 }
3963
3964                 slave = package_slave(pkg);
3965                 if (!slave) {
3966                         ErrPrint("Slave is not exists\n");
3967                         ret = LB_STATUS_ERROR_INVALID;
3968                         goto out;
3969                 }
3970
3971                 packet_ref((struct packet *)packet);
3972                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
3973                 /*!
3974                  * Enen if it fails to send packet,
3975                  * The packet will be unref'd
3976                  * So we don't need to check the ret value.
3977                  */
3978         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
3979                 struct script_info *script;
3980                 Evas *e;
3981
3982                 script = instance_lb_script(inst);
3983                 if (!script) {
3984                         ErrPrint("Instance has no script\n");
3985                         ret = LB_STATUS_ERROR_FAULT;
3986                         goto out;
3987                 }
3988
3989                 e = script_handler_evas(script);
3990                 if (!e) {
3991                         ErrPrint("Instance has no evas\n");
3992                         ret = LB_STATUS_ERROR_INVALID;
3993                         goto out;
3994                 }
3995
3996                 script_handler_update_pointer(script, x, y, 0);
3997                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_SCROLL, timestamp);
3998                 if (ret >= 0) {
3999                         struct access_cbdata *cbdata;
4000
4001                         cbdata = malloc(sizeof(*cbdata));
4002                         if (!cbdata) {
4003                                 ret = LB_STATUS_ERROR_MEMORY;
4004                         } else {
4005                                 cbdata->inst = instance_ref(inst);
4006                                 cbdata->status = ret;
4007
4008                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
4009                                         (void)instance_unref(cbdata->inst);
4010                                         DbgFree(cbdata);
4011                                         ret = LB_STATUS_ERROR_FAULT;
4012                                 } else {
4013                                         ret = LB_STATUS_SUCCESS;
4014                                 }
4015                         }
4016                 }
4017         } else {
4018                 ErrPrint("Unsupported package\n");
4019                 ret = LB_STATUS_ERROR_INVALID;
4020         }
4021
4022 out:
4023         result = packet_create_reply(packet, "i", ret);
4024         if (!result)
4025                 ErrPrint("Failed to create a reply packet\n");
4026
4027         return result;
4028 }
4029
4030 static struct packet *client_lb_access_activate(pid_t pid, int handle, const struct packet *packet)
4031 {
4032         struct packet *result;
4033         struct client_node *client;
4034         const char *pkgname;
4035         const char *id;
4036         int ret;
4037         double timestamp;
4038         int x;
4039         int y;
4040         struct inst_info *inst;
4041         const struct pkg_info *pkg;
4042
4043         client = client_find_by_pid(pid);
4044         if (!client) {
4045                 ErrPrint("Client %d is not exists\n", pid);
4046                 ret = LB_STATUS_ERROR_NOT_EXIST;
4047                 goto out;
4048         }
4049
4050         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
4051         if (ret != 5) {
4052                 ErrPrint("Parameter is not matched\n");
4053                 ret = LB_STATUS_ERROR_INVALID;
4054                 goto out;
4055         }
4056
4057         ret = validate_request(pkgname, id, &inst, &pkg);
4058         if (ret != LB_STATUS_SUCCESS)
4059                 goto out;
4060
4061         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
4062                 struct buffer_info *buffer;
4063                 struct slave_node *slave;
4064
4065                 buffer = instance_lb_buffer(inst);
4066                 if (!buffer) {
4067                         ErrPrint("Instance[%s] has no buffer\n", id);
4068                         ret = LB_STATUS_ERROR_FAULT;
4069                         goto out;
4070                 }
4071
4072                 slave = package_slave(pkg);
4073                 if (!slave) {
4074                         ErrPrint("Package[%s] has no slave\n", pkgname);
4075                         ret = LB_STATUS_ERROR_INVALID;
4076                         goto out;
4077                 }
4078
4079                 packet_ref((struct packet *)packet);
4080                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
4081         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
4082                 struct script_info *script;
4083                 Evas *e;
4084
4085                 script = instance_lb_script(inst);
4086                 if (!script) {
4087                         ErrPrint("Instance has no script\n");
4088                         ret = LB_STATUS_ERROR_FAULT;
4089                         goto out;
4090                 }
4091
4092                 e = script_handler_evas(script);
4093                 if (!e) {
4094                         ErrPrint("Script has no Evas\n");
4095                         ret = LB_STATUS_ERROR_INVALID;
4096                         goto out;
4097                 }
4098
4099                 script_handler_update_pointer(script, x, y, -1);
4100                 ret = script_handler_feed_event(script, LB_SCRIPT_ACCESS_ACTIVATE, timestamp);
4101                 if (ret >= 0) {
4102                         struct access_cbdata *cbdata;
4103
4104                         cbdata = malloc(sizeof(*cbdata));
4105                         if (!cbdata) {
4106                                 ret = LB_STATUS_ERROR_MEMORY;
4107                         } else {
4108                                 cbdata->inst = instance_ref(inst);
4109                                 cbdata->status = ret;
4110
4111                                 if (!ecore_timer_add(DELAY_TIME, lazy_access_status_cb, cbdata)) {
4112                                         (void)instance_unref(cbdata->inst);
4113                                         DbgFree(cbdata);
4114                                         ret = LB_STATUS_ERROR_FAULT;
4115                                 } else {
4116                                         ret = LB_STATUS_SUCCESS;
4117                                 }
4118                         }
4119                 }
4120         } else {
4121                 ErrPrint("Unsupported package\n");
4122                 ret = LB_STATUS_ERROR_INVALID;
4123         }
4124
4125 out:
4126         result = packet_create_reply(packet, "i", ret);
4127         if (!result)
4128                 ErrPrint("Failed to create a reply packet\n");
4129
4130         return result;
4131 }
4132
4133 static struct packet *client_lb_key_down(pid_t pid, int handle, const struct packet *packet)
4134 {
4135         struct client_node *client;
4136         const char *pkgname;
4137         const char *id;
4138         int ret;
4139         double timestamp;
4140         int x;
4141         int y;
4142         struct inst_info *inst;
4143         const struct pkg_info *pkg;
4144
4145         client = client_find_by_pid(pid);
4146         if (!client) {
4147                 ErrPrint("Client %d is not exists\n", pid);
4148                 ret = LB_STATUS_ERROR_NOT_EXIST;
4149                 goto out;
4150         }
4151
4152         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
4153         if (ret != 7) {
4154                 ErrPrint("Parameter is not matched\n");
4155                 ret = LB_STATUS_ERROR_INVALID;
4156                 goto out;
4157         }
4158
4159         ret = validate_request(pkgname, id, &inst, &pkg);
4160         if (ret != LB_STATUS_SUCCESS)
4161                 goto out;
4162
4163         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
4164                 struct buffer_info *buffer;
4165                 struct slave_node *slave;
4166
4167                 buffer = instance_lb_buffer(inst);
4168                 if (!buffer) {
4169                         ErrPrint("Instance[%s] has no buffer\n", id);
4170                         ret = LB_STATUS_ERROR_FAULT;
4171                         goto out;
4172                 }
4173
4174                 slave = package_slave(pkg);
4175                 if (!slave) {
4176                         ErrPrint("Package[%s] has no slave\n", pkgname);
4177                         ret = LB_STATUS_ERROR_INVALID;
4178                         goto out;
4179                 }
4180
4181                 packet_ref((struct packet *)packet);
4182                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
4183         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
4184                 struct script_info *script;
4185                 Evas *e;
4186
4187                 script = instance_lb_script(inst);
4188                 if (!script) {
4189                         ret = LB_STATUS_ERROR_FAULT;
4190                         goto out;
4191                 }
4192
4193                 e = script_handler_evas(script);
4194                 if (!e) {
4195                         ret = LB_STATUS_ERROR_FAULT;
4196                         goto out;
4197                 }
4198
4199                 script_handler_update_pointer(script, x, y, -1);
4200
4201                 /*!
4202                  * \TODO: Feed up this KEY_DOWN event
4203                  */
4204                 ret = 0;
4205         } else {
4206                 ErrPrint("Unsupported package\n");
4207                 ret = LB_STATUS_ERROR_INVALID;
4208         }
4209
4210 out:
4211         /*! \note No reply packet */
4212         return NULL;
4213 }
4214
4215 static struct packet *client_lb_key_up(pid_t pid, int handle, const struct packet *packet)
4216 {
4217         struct client_node *client;
4218         const char *pkgname;
4219         const char *id;
4220         int ret;
4221         double timestamp;
4222         int x;
4223         int y;
4224         struct inst_info *inst;
4225         const struct pkg_info *pkg;
4226
4227         client = client_find_by_pid(pid);
4228         if (!client) {
4229                 ErrPrint("Client %d is not exists\n", pid);
4230                 ret = LB_STATUS_ERROR_NOT_EXIST;
4231                 goto out;
4232         }
4233
4234         ret = packet_get(packet, "ssdii", &pkgname, &id, &timestamp, &x, &y);
4235         if (ret != 7) {
4236                 ErrPrint("Parameter is not matched\n");
4237                 ret = LB_STATUS_ERROR_INVALID;
4238                 goto out;
4239         }
4240
4241         ret = validate_request(pkgname, id, &inst, &pkg);
4242         if (ret != LB_STATUS_SUCCESS)
4243                 goto out;
4244
4245         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
4246                 struct buffer_info *buffer;
4247                 struct slave_node *slave;
4248
4249                 buffer = instance_lb_buffer(inst);
4250                 if (!buffer) {
4251                         ErrPrint("Instance[%s] has no buffer\n", id);
4252                         ret = LB_STATUS_ERROR_FAULT;
4253                         goto out;
4254                 }
4255
4256                 slave = package_slave(pkg);
4257                 if (!slave) {
4258                         ErrPrint("Package[%s] has no slave\n", pkgname);
4259                         ret = LB_STATUS_ERROR_INVALID;
4260                         goto out;
4261                 }
4262
4263                 packet_ref((struct packet *)packet);
4264                 ret = slave_rpc_request_only(slave, pkgname, (struct packet *)packet, 0);
4265         } else if (package_lb_type(pkg) == LB_TYPE_SCRIPT) {
4266                 struct script_info *script;
4267                 Evas *e;
4268
4269                 script = instance_lb_script(inst);
4270                 if (!script) {
4271                         ret = LB_STATUS_ERROR_FAULT;
4272                         goto out;
4273                 }
4274
4275                 e = script_handler_evas(script);
4276                 if (!e) {
4277                         ret = LB_STATUS_ERROR_FAULT;
4278                         goto out;
4279                 }
4280
4281                 script_handler_update_pointer(script, x, y, -1);
4282
4283                 /*!
4284                  * \TODO: Feed up this KEY_UP event
4285                  */
4286                 ret = 0;
4287         } else {
4288                 ErrPrint("Unsupported package\n");
4289                 ret = LB_STATUS_ERROR_INVALID;
4290         }
4291
4292 out:
4293         /*! \note No reply packet */
4294         return NULL;
4295 }
4296
4297 static int release_pixmap_cb(struct client_node *client, void *canvas)
4298 {
4299         DbgPrint("Forcely unref the \"buffer\"\n");
4300         buffer_handler_pixmap_unref(canvas);
4301         return -1; /* Delete this callback */
4302 }
4303
4304 static struct packet *client_lb_acquire_pixmap(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
4305 {
4306         struct packet *result;
4307         const char *pkgname;
4308         const char *id;
4309         struct client_node *client;
4310         struct inst_info *inst;
4311         int ret;
4312         int pixmap = 0;
4313         void *buf_ptr;
4314         struct buffer_info *buffer;
4315
4316         client = client_find_by_pid(pid);
4317         if (!client) {
4318                 ErrPrint("Client %d is not exists\n", pid);
4319                 goto out;
4320         }
4321
4322         ret = packet_get(packet, "ss", &pkgname, &id);
4323         if (ret != 2) {
4324                 ErrPrint("Parameter is not matched\n");
4325                 goto out;
4326         }
4327
4328         ret = validate_request(pkgname, id, &inst, NULL);
4329         if (ret != LB_STATUS_SUCCESS)
4330                 goto out;
4331
4332         buffer = instance_lb_buffer(inst);
4333         if (!buffer) {
4334                 struct script_info *script_info;
4335                 struct fb_info *fb_info;
4336
4337                 script_info = instance_lb_script(inst);
4338                 if (!script_info) {
4339                         ErrPrint("Unable to get LB buffer: %s\n", id);
4340                         goto out;
4341                 }
4342
4343                 fb_info = script_handler_fb(script_info);
4344                 if (!fb_info) {
4345                         ErrPrint("Unable to get fb_info: %s\n", id);
4346                         goto out;
4347                 }
4348
4349                 buffer = fb_buffer_info(fb_info);
4350                 if (!buffer) {
4351                         ErrPrint("Unable to get buffer_info: %s\n", id);
4352                         goto out;
4353                 }
4354         }
4355
4356         buf_ptr = buffer_handler_pixmap_ref(buffer);
4357         if (!buf_ptr) {
4358                 ErrPrint("Failed to ref pixmap\n");
4359                 goto out;
4360         }
4361
4362         ret = client_event_callback_add(client, CLIENT_EVENT_DEACTIVATE, release_pixmap_cb, buf_ptr);
4363         if (ret < 0) {
4364                 ErrPrint("Failed to add a new client deactivate callback\n");
4365                 buffer_handler_pixmap_unref(buf_ptr);
4366         } else {
4367                 pixmap = buffer_handler_pixmap(buffer);
4368         }
4369
4370 out:
4371         result = packet_create_reply(packet, "i", pixmap);
4372         if (!result)
4373                 ErrPrint("Failed to create a reply packet\n");
4374
4375         return result;
4376 }
4377
4378 static struct packet *client_lb_release_pixmap(pid_t pid, int handle, const struct packet *packet)
4379 {
4380         const char *pkgname;
4381         const char *id;
4382         struct client_node *client;
4383         struct inst_info *inst;
4384         int pixmap;
4385         void *buf_ptr;
4386         int ret;
4387
4388         client = client_find_by_pid(pid);
4389         if (!client) {
4390                 ErrPrint("Client %d is not exists\n", pid);
4391                 goto out;
4392         }
4393
4394         ret = packet_get(packet, "ssi", &pkgname, &id, &pixmap);
4395         if (ret != 3) {
4396                 ErrPrint("Parameter is not matched\n");
4397                 goto out;
4398         }
4399
4400         ret = validate_request(pkgname, id, &inst, NULL);
4401         if (ret != LB_STATUS_SUCCESS)
4402                 goto out;
4403
4404         buf_ptr = buffer_handler_pixmap_find(pixmap);
4405         if (!buf_ptr) {
4406                 ErrPrint("Failed to find a buf_ptr of 0x%X\n", pixmap);
4407                 goto out;
4408         }
4409
4410         if (client_event_callback_del(client, CLIENT_EVENT_DEACTIVATE, release_pixmap_cb, buf_ptr) == 0)
4411                 buffer_handler_pixmap_unref(buf_ptr);
4412
4413 out:
4414         /*! \note No reply packet */
4415         return NULL;
4416 }
4417
4418 static struct packet *client_pd_acquire_pixmap(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
4419 {
4420         struct packet *result;
4421         const char *pkgname;
4422         const char *id;
4423         struct client_node *client;
4424         struct inst_info *inst;
4425         int ret;
4426         int pixmap = 0;
4427         void *buf_ptr;
4428         struct buffer_info *buffer;
4429
4430         client = client_find_by_pid(pid);
4431         if (!client) {
4432                 ErrPrint("Client %d is not exists\n", pid);
4433                 goto out;
4434         }
4435
4436         ret = packet_get(packet, "ss", &pkgname, &id);
4437         if (ret != 2) {
4438                 ErrPrint("Parameter is not matched\n");
4439                 goto out;
4440         }
4441
4442         ret = validate_request(pkgname, id, &inst, NULL);
4443         if (ret != LB_STATUS_SUCCESS)
4444                 goto out;
4445
4446         buffer = instance_pd_buffer(inst);
4447         if (!buffer) {
4448                 struct script_info *script_info;
4449                 struct fb_info *fb_info;
4450
4451                 script_info = instance_pd_script(inst);
4452                 if (!script_info) {
4453                         ErrPrint("Unable to get LB buffer: %s\n", id);
4454                         goto out;
4455                 }
4456
4457                 fb_info = script_handler_fb(script_info);
4458                 if (!fb_info) {
4459                         ErrPrint("Unable to get fb_info: %s\n", id);
4460                         goto out;
4461                 }
4462
4463                 buffer = fb_buffer_info(fb_info);
4464                 if (!buffer) {
4465                         ErrPrint("Unable to get buffer_info: %s\n", id);
4466                         goto out;
4467                 }
4468         }
4469
4470         buf_ptr = buffer_handler_pixmap_ref(buffer);
4471         if (!buf_ptr) {
4472                 ErrPrint("Failed to ref pixmap\n");
4473                 goto out;
4474         }
4475
4476         ret = client_event_callback_add(client, CLIENT_EVENT_DEACTIVATE, release_pixmap_cb, buf_ptr);
4477         if (ret < 0)
4478                 buffer_handler_pixmap_unref(buf_ptr);
4479
4480         pixmap = buffer_handler_pixmap(buffer);
4481 out:
4482         result = packet_create_reply(packet, "i", pixmap);
4483         if (!result)
4484                 ErrPrint("Failed to create a reply packet\n");
4485
4486         return result;
4487 }
4488
4489 static struct packet *client_pd_release_pixmap(pid_t pid, int handle, const struct packet *packet)
4490 {
4491         const char *pkgname;
4492         const char *id;
4493         struct client_node *client;
4494         int pixmap;
4495         void *buf_ptr;
4496         int ret;
4497
4498         client = client_find_by_pid(pid);
4499         if (!client) {
4500                 ErrPrint("Client %d is not exists\n", pid);
4501                 goto out;
4502         }
4503
4504         ret = packet_get(packet, "ssi", &pkgname, &id, &pixmap);
4505         if (ret != 3) {
4506                 ErrPrint("Parameter is not matched\n");
4507                 goto out;
4508         }
4509
4510         ret = validate_request(pkgname, id, NULL, NULL);
4511         if (ret != LB_STATUS_SUCCESS)
4512                 goto out;
4513
4514         buf_ptr = buffer_handler_pixmap_find(pixmap);
4515         if (!buf_ptr) {
4516                 ErrPrint("Failed to find a buf_ptr of 0x%X\n", pixmap);
4517                 goto out;
4518         }
4519
4520         if (client_event_callback_del(client, CLIENT_EVENT_DEACTIVATE, release_pixmap_cb, buf_ptr) == 0)
4521                 buffer_handler_pixmap_unref(buf_ptr);
4522
4523 out:
4524         /*! \note No reply packet */
4525         return NULL;
4526 }
4527
4528 static struct packet *client_pinup_changed(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, pinup, ret */
4529 {
4530         struct client_node *client;
4531         struct packet *result;
4532         const char *pkgname;
4533         const char *id;
4534         int pinup;
4535         int ret;
4536         struct inst_info *inst;
4537
4538         client = client_find_by_pid(pid);
4539         if (!client) {
4540                 ErrPrint("Client %d is not exists\n", pid);
4541                 ret = LB_STATUS_ERROR_NOT_EXIST;
4542                 pinup = 0;
4543                 goto out;
4544         }
4545
4546         ret = packet_get(packet, "ssi", &pkgname, &id, &pinup);
4547         if (ret != 3) {
4548                 ErrPrint("Parameter is not matched\n");
4549                 ret = LB_STATUS_ERROR_INVALID;
4550                 pinup = 0;
4551                 goto out;
4552         }
4553
4554         ret = validate_request(pkgname, id, &inst, NULL);
4555         if (ret == LB_STATUS_SUCCESS)
4556                 ret = instance_set_pinup(inst, pinup);
4557
4558 out:
4559         result = packet_create_reply(packet, "i", ret);
4560         if (!result)
4561                 ErrPrint("Failed to create a packet\n");
4562
4563         return result;
4564 }
4565
4566 static Eina_Bool lazy_pd_created_cb(void *data)
4567 {
4568         if (!!instance_del_data(data, "lazy,pd,open")) {
4569                 /*!
4570                  * After unref instance first,
4571                  * if the instance is not destroyed, try to notify the created PD event to the client.
4572                  */
4573                 if (instance_unref(data)) {
4574                         int ret;
4575                         ret = instance_client_pd_created(data, LB_STATUS_SUCCESS);
4576                         DbgPrint("Send PD Create event (%d) to client\n", ret);
4577                 }
4578         }
4579
4580         return ECORE_CALLBACK_CANCEL;
4581 }
4582
4583 static Eina_Bool lazy_pd_destroyed_cb(void *data)
4584 {
4585         if (!!instance_del_data(data, "lazy,pd,close")) {
4586                 if (instance_unref(data)) {
4587                         int ret;
4588                         ret = instance_client_pd_destroyed(data, LB_STATUS_SUCCESS);
4589                         DbgPrint("Send PD Destroy event (%d) to client\n", ret);
4590                 }
4591         }
4592
4593         return ECORE_CALLBACK_CANCEL;
4594 }
4595
4596 static struct packet *client_pd_move(pid_t pid, int handle, const struct packet *packet) /* pkgname, id, x, y */
4597 {
4598         struct client_node *client;
4599         struct inst_info *inst;
4600         const struct pkg_info *pkg;
4601         const char *pkgname;
4602         const char *id;
4603         double x = 0.0f;
4604         double y = 0.0f;
4605         int ret;
4606
4607         client = client_find_by_pid(pid);
4608         if (!client) {
4609                 ErrPrint("Client %d is not exists\n", pid);
4610                 ret = LB_STATUS_ERROR_NOT_EXIST;
4611                 goto out;
4612         }
4613
4614         ret = packet_get(packet, "ssdd", &pkgname, &id, &x, &y);
4615         if (ret != 4) {
4616                 ErrPrint("Parameter is not correct\n");
4617                 ret = LB_STATUS_ERROR_INVALID;
4618                 goto out;
4619         }
4620
4621         ret = validate_request(pkgname, id, &inst, &pkg);
4622         if (ret != LB_STATUS_SUCCESS)
4623                 goto out;
4624
4625         if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
4626                 instance_slave_set_pd_pos(inst, x, y);
4627                 ret = instance_signal_emit(inst, "pd,move", instance_id(inst), 0.0, 0.0, 0.0, 0.0, x, y, 0);
4628         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
4629                 int ix;
4630                 int iy;
4631
4632                 instance_slave_set_pd_pos(inst, x, y);
4633                 ix = x * instance_pd_width(inst);
4634                 iy = y * instance_pd_height(inst);
4635                 script_handler_update_pointer(instance_pd_script(inst), ix, iy, 0);
4636                 ret = instance_signal_emit(inst, "pd,move", instance_id(inst), 0.0, 0.0, 0.0, 0.0, x, y, 0);
4637         } else {
4638                 ErrPrint("Invalid PD type\n");
4639                 ret = LB_STATUS_ERROR_INVALID;
4640         }
4641 out:
4642         DbgPrint("Update PD position: %d\n", ret);
4643         return NULL;
4644 }
4645
4646 static Eina_Bool pd_open_monitor_cb(void *data)
4647 {
4648         int ret;
4649         struct inst_info *inst = data;
4650
4651         ret = instance_slave_close_pd(inst, instance_pd_owner(inst));
4652         ret = instance_client_pd_created(inst, LB_STATUS_ERROR_TIMEOUT);
4653         (void)instance_del_data(inst, "pd,open,monitor");
4654         (void)instance_unref(inst);
4655         ErrPrint("PD Open request is timed-out (%lf), ret: %d\n", PD_REQUEST_TIMEOUT, ret);
4656         return ECORE_CALLBACK_CANCEL;
4657 }
4658
4659 static Eina_Bool pd_close_monitor_cb(void *data)
4660 {
4661         int ret;
4662
4663         ret = instance_client_pd_destroyed(data, LB_STATUS_ERROR_TIMEOUT);
4664         (void)instance_del_data(data, "pd,close,monitor");
4665         (void)instance_unref(data);
4666         ErrPrint("PD Close request is not processed in %lf seconds (%d)\n", PD_REQUEST_TIMEOUT, ret);
4667         return ECORE_CALLBACK_CANCEL;
4668 }
4669
4670 static Eina_Bool pd_resize_monitor_cb(void *data)
4671 {
4672         int ret;
4673         struct inst_info *inst = data;
4674
4675         ret = instance_slave_close_pd(inst, instance_pd_owner(inst));
4676         ret = instance_client_pd_destroyed(inst, LB_STATUS_ERROR_TIMEOUT);
4677         (void)instance_del_data(inst, "pd,resize,monitor");
4678         (void)instance_unref(inst);
4679         ErrPrint("PD Resize request is not processed in %lf seconds (%d)\n", PD_REQUEST_TIMEOUT, ret);
4680         return ECORE_CALLBACK_CANCEL;
4681 }
4682
4683 static struct packet *client_create_pd(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, ret */
4684 {
4685         struct client_node *client;
4686         struct packet *result;
4687         const char *pkgname;
4688         const char *id;
4689         int ret;
4690         struct inst_info *inst;
4691         double x;
4692         double y;
4693
4694         DbgPrint("PERF_DBOX\n");
4695
4696         client = client_find_by_pid(pid);
4697         if (!client) {
4698                 ErrPrint("Client %d is not exists\n", pid);
4699                 ret = LB_STATUS_ERROR_NOT_EXIST;
4700                 goto out;
4701         }
4702
4703         ret = packet_get(packet, "ssdd", &pkgname, &id, &x, &y);
4704         if (ret != 4) {
4705                 ErrPrint("Parameter is not matched\n");
4706                 ret = LB_STATUS_ERROR_INVALID;
4707                 goto out;
4708         }
4709
4710         ret = validate_request(pkgname, id, &inst, NULL);
4711         if (ret != LB_STATUS_SUCCESS)
4712                 goto out;
4713
4714         if (instance_pd_owner(inst)) {
4715                 ErrPrint("PD is already owned\n");
4716                 ret = LB_STATUS_ERROR_ALREADY;
4717         } else if (package_pd_type(instance_package(inst)) == PD_TYPE_BUFFER) {
4718                 lazy_pd_destroyed_cb(inst);
4719
4720                 if (instance_get_data(inst, "pd,open,monitor")) {
4721                         DbgPrint("PD Open request is already processed\n");
4722                         ret = LB_STATUS_ERROR_ALREADY;
4723                         goto out;
4724                 }
4725
4726                 if (instance_get_data(inst, "pd,close,monitor")) {
4727                         DbgPrint("PD Close request is already in process\n");
4728                         ret = LB_STATUS_ERROR_BUSY;
4729                         goto out;
4730                 }
4731
4732                 if (instance_get_data(inst, "pd,resize,monitor")) {
4733                         DbgPrint("PD resize request is already in process\n");
4734                         ret = LB_STATUS_ERROR_BUSY;
4735                         goto out;
4736                 }
4737
4738                 instance_slave_set_pd_pos(inst, x, y);
4739                 /*!
4740                  * \note
4741                  * Send request to the slave.
4742                  * The SLAVE must has to repsonse this via "release_buffer" method.
4743                  */
4744                 ret = instance_slave_open_pd(inst, client);
4745                 if (ret == LB_STATUS_SUCCESS) {
4746                         ret = instance_signal_emit(inst, "pd,show", instance_id(inst), 0.0, 0.0, 0.0, 0.0, x, y, 0);
4747                         if (ret != LB_STATUS_SUCCESS) {
4748                                 int tmp_ret;
4749
4750                                 tmp_ret = instance_slave_close_pd(inst, client);
4751                                 ErrPrint("Unable to send script event for openning PD [%s], %d\n", pkgname, tmp_ret);
4752                         } else {
4753                                 Ecore_Timer *pd_monitor;
4754
4755                                 pd_monitor = ecore_timer_add(PD_REQUEST_TIMEOUT, pd_open_monitor_cb, instance_ref(inst));
4756                                 if (!pd_monitor) {
4757                                         (void)instance_unref(inst);
4758                                         ErrPrint("Failed to create a timer for PD Open monitor\n");
4759                                 } else {
4760                                         (void)instance_set_data(inst, "pd,open,monitor", pd_monitor);
4761                                 }
4762                         }
4763                 } else {
4764                         ErrPrint("Unable to send request for openning PD [%s]\n", pkgname);
4765                 }
4766
4767                 /*!
4768                  * \note
4769                  * PD craeted event will be send by the acquire_buffer function.
4770                  * Because the slave will make request the acquire_buffer to
4771                  * render the PD
4772                  *
4773                  * instance_client_pd_created(inst);
4774                  */
4775         } else if (package_pd_type(instance_package(inst)) == PD_TYPE_SCRIPT) {
4776                 int ix;
4777                 int iy;
4778
4779                 lazy_pd_destroyed_cb(inst);
4780
4781                 /*!
4782                  * \note
4783                  * ret value should be cared but in this case,
4784                  * we ignore this for this moment, so we have to handle this error later.
4785                  *
4786                  * if ret is less than 0, the slave has some problem.
4787                  * but the script mode doesn't need slave for rendering default view of PD
4788                  * so we can hanle it later.
4789                  */
4790                 instance_slave_set_pd_pos(inst, x, y);
4791                 ix = x * instance_pd_width(inst);
4792                 iy = y * instance_pd_height(inst);
4793
4794                 script_handler_update_pointer(instance_pd_script(inst), ix, iy, 0);
4795
4796                 ret = instance_slave_open_pd(inst, client);
4797                 if (ret == LB_STATUS_SUCCESS) {
4798                         ret = script_handler_load(instance_pd_script(inst), 1);
4799
4800                         /*!
4801                          * \note
4802                          * Send the PD created event to the clients,
4803                          */
4804                         if (ret == LB_STATUS_SUCCESS) {
4805                                 Ecore_Timer *timer;
4806
4807                                 /*!
4808                                  * \note
4809                                  * But the created event has to be send afte return
4810                                  * from this function or the viewer couldn't care
4811                                  * the event correctly.
4812                                  */
4813                                 inst = instance_ref(inst); /* To guarantee the inst */
4814
4815                                 /*!
4816                                  * \note
4817                                  * At here, we don't need to rememeber the timer object.
4818                                  * Even if the timer callback is called, after the instance is destroyed.
4819                                  * lazy_pd_created_cb will decrease the instance refcnt first.
4820                                  * At that time, if the instance is released, the timer callback will do nothing.
4821                                  *
4822                                  * 13-05-28
4823                                  * I change my mind. There is no requirements to keep the timer handler.
4824                                  * But I just add it to the tagged-data of the instance.
4825                                  * Just reserve for future-use.
4826                                  */
4827                                 timer = ecore_timer_add(DELAY_TIME, lazy_pd_created_cb, inst);
4828                                 if (!timer) {
4829                                         struct inst_info *tmp_inst;
4830
4831                                         tmp_inst = instance_unref(inst);
4832                                         ErrPrint("Instance: %p (%s)\n", tmp_inst, pkgname);
4833
4834                                         ret = script_handler_unload(instance_pd_script(inst), 1);
4835                                         ErrPrint("Unload script: %d\n", ret);
4836
4837                                         ret = instance_slave_close_pd(inst, client);
4838                                         ErrPrint("Close PD %d\n", ret);
4839
4840                                         ret = LB_STATUS_ERROR_FAULT;
4841                                 } else {
4842                                         (void)instance_set_data(inst, "lazy,pd,open", timer);
4843                                 }
4844                         } else {
4845                                 int tmp_ret;
4846                                 tmp_ret = instance_slave_close_pd(inst, client);
4847                                 ErrPrint("Unable to load script: %d, (close: %d)\n", ret, tmp_ret);
4848                         }
4849                 } else {
4850                         ErrPrint("Unable open PD(%s): %d\n", pkgname, ret);
4851                 }
4852         } else {
4853                 ErrPrint("Invalid PD TYPE\n");
4854                 ret = LB_STATUS_ERROR_INVALID;
4855         }
4856
4857 out:
4858         result = packet_create_reply(packet, "i", ret);
4859         if (!result)
4860                 ErrPrint("Failed to create a packet\n");
4861
4862         return result;
4863 }
4864
4865 static struct packet *client_destroy_pd(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, filename, ret */
4866 {
4867         struct client_node *client;
4868         struct packet *result;
4869         const char *pkgname;
4870         const char *id;
4871         int ret;
4872         struct inst_info *inst;
4873         const struct pkg_info *pkg;
4874         Ecore_Timer *pd_monitor;
4875
4876         DbgPrint("PERF_DBOX\n");
4877
4878         client = client_find_by_pid(pid);
4879         if (!client) {
4880                 ErrPrint("Client %d is not exists\n", pid);
4881                 ret = LB_STATUS_ERROR_NOT_EXIST;
4882                 goto out;
4883         }
4884
4885         ret = packet_get(packet, "ss", &pkgname, &id);
4886         if (ret != 2) {
4887                 ErrPrint("Parameter is not matched\n");
4888                 ret = LB_STATUS_ERROR_INVALID;
4889                 goto out;
4890         }
4891
4892         ret = validate_request(pkgname, id, &inst, &pkg);
4893         if (ret != LB_STATUS_SUCCESS)
4894                 goto out;
4895
4896         if (instance_pd_owner(inst) != client) {
4897                 if (instance_pd_owner(inst) == NULL) {
4898                         ErrPrint("PD looks already closed\n");
4899                         ret = LB_STATUS_ERROR_ALREADY;
4900                 } else {
4901                         ErrPrint("PD owner mimatched\n");
4902                         ret = LB_STATUS_ERROR_PERMISSION;
4903                 }
4904         } else if (package_pd_type(pkg) == PD_TYPE_BUFFER) {
4905                 int resize_aborted = 0;
4906
4907                 pd_monitor = instance_del_data(inst, "pd,open,monitor");
4908                 if (pd_monitor) {
4909                         ErrPrint("PD Open request is found. cancel it [%s]\n", pkgname);
4910
4911                         /*!
4912                          * \note
4913                          * We should return negative value
4914                          * Or we have to send "destroyed" event to the client.
4915                          * If we didn't send destroyed event after return SUCCESS from here,
4916                          * The client will permanently waiting destroyed event.
4917                          * Because they understand that the destroy request is successfully processed.
4918                          */
4919                         ret = LB_STATUS_ERROR_CANCEL;
4920                         ret = instance_client_pd_created(inst, ret);
4921                         if (ret < 0)
4922                                 ErrPrint("PD client create event: %d\n", ret);
4923
4924                         ret = instance_client_pd_destroyed(inst, LB_STATUS_SUCCESS);
4925                         if (ret < 0)
4926                                 ErrPrint("PD client destroy event: %d\n", ret);
4927
4928                         ret = instance_signal_emit(inst, "pd,hide", instance_id(inst), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0);
4929                         if (ret < 0)
4930                                 ErrPrint("PD close signal emit failed: %d\n", ret);
4931
4932                         ret = instance_slave_close_pd(inst, client);
4933                         if (ret < 0)
4934                                 ErrPrint("PD close request failed: %d\n", ret);
4935
4936                         ecore_timer_del(pd_monitor);
4937                         (void)instance_unref(inst);
4938                         goto out;
4939                 }
4940
4941                 if (instance_get_data(inst, "lazy,pd,close") || instance_get_data(inst, "pd,close,monitor")) {
4942                         ret = LB_STATUS_ERROR_ALREADY;
4943                         goto out;
4944                 }
4945
4946                 pd_monitor = instance_del_data(inst, "pd,resize,monitor");
4947                 if (pd_monitor) {
4948                         ErrPrint("PD Resize request is found. clear it [%s]\n", pkgname);
4949                         ecore_timer_del(pd_monitor);
4950
4951                         inst = instance_unref(inst);
4952                         if (!inst)
4953                                 goto out;
4954
4955                         resize_aborted = 1;
4956                 }
4957
4958                 ret = instance_signal_emit(inst, "pd,hide", instance_id(inst), 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0);
4959                 if (ret < 0)
4960                         ErrPrint("PD close signal emit failed: %d\n", ret);
4961
4962                 ret = instance_slave_close_pd(inst, client);
4963                 if (ret < 0) {
4964                         ErrPrint("PD close request failed: %d\n", ret);
4965                 } else if (resize_aborted) {
4966                         pd_monitor = ecore_timer_add(DELAY_TIME, lazy_pd_destroyed_cb, instance_ref(inst));
4967                         if (!pd_monitor) {
4968                                 ErrPrint("Failed to create a timer: %s\n", pkgname);
4969                                 (void)instance_unref(inst);
4970                         } else {
4971                                 (void)instance_set_data(inst, "lazy,pd,close", pd_monitor);
4972                         }
4973                 } else {
4974                         pd_monitor = ecore_timer_add(PD_REQUEST_TIMEOUT, pd_close_monitor_cb, instance_ref(inst));
4975                         if (!pd_monitor) {
4976                                 (void)instance_unref(inst);
4977                                 ErrPrint("Failed to add pd close monitor\n");
4978                         } else {
4979                                 (void)instance_set_data(inst, "pd,close,monitor", pd_monitor);
4980                         }
4981                 }
4982                 /*!
4983                  * \note
4984                  * release_buffer will be called by the slave after this.
4985                  * Then it will send the "pd_destroyed" event to the client
4986                  *
4987                  * instance_client_pd_destroyed(inst);
4988                  */
4989         } else if (package_pd_type(pkg) == PD_TYPE_SCRIPT) {
4990                 lazy_pd_created_cb(inst);
4991
4992                 ret = script_handler_unload(instance_pd_script(inst), 1);
4993                 if (ret < 0)
4994                         ErrPrint("Unable to unload the script: %s, %d\n", pkgname, ret);
4995
4996                 /*!
4997                  * \note
4998                  * Send request to the slave.
4999                  * The SLAVE must has to repsonse this via "release_buffer" method.
5000                  */
5001                 ret = instance_slave_close_pd(inst, client);
5002                 if (ret < 0)
5003                         ErrPrint("Unable to close the PD: %s, %d\n", pkgname, ret);
5004
5005                 /*!
5006                  * \note
5007                  * Send the destroyed PD event to the client
5008                  */
5009                 if (ret == LB_STATUS_SUCCESS) {
5010                         /*!
5011                          * \note
5012                          * 13-05-28
5013                          * I change my mind. There is no requirements to keep the timer handler.
5014                          * But I just add it to the tagged-data of the instance.
5015                          * Just reserve for future-use.
5016                          */
5017                         pd_monitor = ecore_timer_add(DELAY_TIME, lazy_pd_destroyed_cb, instance_ref(inst));
5018                         if (!pd_monitor) {
5019                                 ErrPrint("Failed to create a timer: %s\n", pkgname);
5020                                 (void)instance_unref(inst);
5021                         } else {
5022                                 (void)instance_set_data(inst, "lazy,pd,close", pd_monitor);
5023                         }
5024                 }
5025         } else {
5026                 ErrPrint("Invalid PD TYPE\n");
5027                 ret = LB_STATUS_ERROR_INVALID;
5028         }
5029
5030 out:
5031         result = packet_create_reply(packet, "i", ret);
5032         if (!result)
5033                 ErrPrint("Failed to create a packet\n");
5034
5035         return result;
5036 }
5037
5038 static struct packet *client_activate_package(pid_t pid, int handle, const struct packet *packet) /* pid, pkgname, ret */
5039 {
5040         struct client_node *client;
5041         struct packet *result;
5042         const char *pkgname;
5043         int ret;
5044         struct pkg_info *info;
5045
5046         client = client_find_by_pid(pid);
5047         if (!client) {
5048                 ErrPrint("Client %d is not exists\n", pid);
5049                 ret = LB_STATUS_ERROR_NOT_EXIST;
5050                 pkgname = "";
5051                 goto out;
5052         }
5053
5054         ret = packet_get(packet, "s", &pkgname);
5055         if (ret != 1) {
5056                 ErrPrint("Parameter is not matched\n");
5057                 ret = LB_STATUS_ERROR_INVALID;
5058                 pkgname = "";
5059                 goto out;
5060         }
5061
5062         DbgPrint("pid[%d] pkgname[%s]\n", pid, pkgname);
5063
5064         /*!
5065          * \NOTE:
5066          * Validate the livebox package name.
5067          */
5068         if (!package_is_lb_pkgname(pkgname)) {
5069                 ErrPrint("%s is not a valid livebox package\n", pkgname);
5070                 pkgname = "";
5071                 ret = LB_STATUS_ERROR_INVALID;
5072                 goto out;
5073         }
5074
5075         info = package_find(pkgname);
5076         if (!info)
5077                 ret = LB_STATUS_ERROR_NOT_EXIST;
5078         else
5079                 ret = package_clear_fault(info);
5080
5081 out:
5082         result = packet_create_reply(packet, "is", ret, pkgname);
5083         if (!result)
5084                 ErrPrint("Failed to create a packet\n");
5085
5086         return result;
5087 }
5088
5089 static struct packet *client_subscribed(pid_t pid, int handle, const struct packet *packet)
5090 {
5091         const char *cluster;
5092         const char *category;
5093         struct client_node *client;
5094         int ret;
5095
5096         client = client_find_by_pid(pid);
5097         if (!client) {
5098                 ErrPrint("Client %d is not exists\n", pid);
5099                 ret = LB_STATUS_ERROR_NOT_EXIST;
5100                 goto out;
5101         }
5102
5103         ret = packet_get(packet, "ss", &cluster, &category);
5104         if (ret != 2) {
5105                 ErrPrint("Invalid argument\n");
5106                 ret = LB_STATUS_ERROR_INVALID;
5107                 goto out;
5108         }
5109
5110         DbgPrint("[%d] cluster[%s] category[%s]\n", pid, cluster, category);
5111         if (!strlen(cluster) || !strcasecmp(cluster, DEFAULT_CLUSTER)) {
5112                 ErrPrint("Invalid cluster name\n");
5113                 goto out;
5114         }
5115
5116         /*!
5117          * \todo
5118          * SUBSCRIBE cluster & sub-cluster for a client.
5119          */
5120         ret = client_subscribe(client, cluster, category);
5121         if (ret == 0)
5122                 package_alter_instances_to_client(client, ALTER_CREATE);
5123
5124 out:
5125         /*! \note No reply packet */
5126         return NULL;
5127 }
5128
5129 static struct packet *client_delete_cluster(pid_t pid, int handle, const struct packet *packet)
5130 {
5131         const char *cluster;
5132         struct client_node *client;
5133         struct packet *result;
5134         int ret;
5135
5136         client = client_find_by_pid(pid);
5137         if (!client) {
5138                 ErrPrint("Client %d is not exists\n", pid);
5139                 ret = LB_STATUS_ERROR_NOT_EXIST;
5140                 goto out;
5141         }
5142
5143         ret = packet_get(packet, "s", &cluster);
5144         if (ret != 1) {
5145                 ErrPrint("Invalid parameters\n");
5146                 ret = LB_STATUS_ERROR_INVALID;
5147                 goto out;
5148         }
5149
5150         DbgPrint("pid[%d] cluster[%s]\n", pid, cluster);
5151
5152         if (!strlen(cluster) || !strcasecmp(cluster, DEFAULT_CLUSTER)) {
5153                 ErrPrint("Invalid cluster: %s\n", cluster);
5154                 ret = LB_STATUS_ERROR_INVALID;
5155                 goto out;
5156         }
5157
5158         /*!
5159          * \todo
5160          */
5161         ret = LB_STATUS_ERROR_NOT_IMPLEMENTED;
5162
5163 out:
5164         result = packet_create_reply(packet, "i", ret);
5165         if (!result)
5166                 ErrPrint("Failed to create a packet\n");
5167         return result;
5168 }
5169
5170 static inline int update_pkg_cb(struct category *category, const char *pkgname)
5171 {
5172         const char *c_name;
5173         const char *s_name;
5174
5175         c_name = group_cluster_name_by_category(category);
5176         s_name = group_category_name(category);
5177
5178         if (!c_name || !s_name || !pkgname) {
5179                 ErrPrint("Name is not valid\n");
5180                 return EXIT_FAILURE;
5181         }
5182
5183         DbgPrint("Send refresh request: %s (%s/%s)\n", pkgname, c_name, s_name);
5184         slave_rpc_request_update(pkgname, "", c_name, s_name);
5185
5186         /* Just try to create a new package */
5187         if (util_free_space(IMAGE_PATH) > MINIMUM_SPACE) {
5188                 double timestamp;
5189                 struct inst_info *inst;
5190
5191                 timestamp = util_timestamp();
5192                 /*!
5193                  * \NOTE
5194                  * Don't need to check the subscribed clients.
5195                  * Because this callback is called by the requests of clients.
5196                  * It means. some clients wants to handle this instances ;)
5197                  */
5198                 inst = instance_create(NULL, timestamp, pkgname, "", c_name, s_name, DEFAULT_PERIOD, 0, 0);
5199                 if (!inst)
5200                         ErrPrint("Failed to create a new instance\n");
5201         } else {
5202                 ErrPrint("Not enough space\n");
5203         }
5204         return EXIT_SUCCESS;
5205 }
5206
5207 static struct packet *client_update(pid_t pid, int handle, const struct packet *packet)
5208 {
5209         struct inst_info *inst;
5210         struct client_node *client;
5211         const char *pkgname;
5212         const char *id;
5213         int ret;
5214
5215         client = client_find_by_pid(pid);
5216         if (!client) {
5217                 ErrPrint("Cilent %d is not exists\n", pid);
5218                 goto out;
5219         }
5220
5221         ret = packet_get(packet, "ss", &pkgname, &id);
5222         if (ret != 2) {
5223                 ErrPrint("Invalid argument\n");
5224                 goto out;
5225         }
5226
5227         ret = validate_request(pkgname, id, &inst, NULL);
5228         if (ret != LB_STATUS_SUCCESS)
5229                 goto out;
5230
5231         if (instance_client(inst) != client) {
5232                 /* PERMISSIONS */
5233                 ErrPrint("Insufficient permissions [%s] - %d\n", pkgname, pid);
5234         } else {
5235                 slave_rpc_request_update(pkgname, id, instance_cluster(inst), instance_category(inst));
5236         }
5237
5238 out:
5239         /*! \note No reply packet */
5240         return NULL;
5241 }
5242
5243 static struct packet *client_refresh_group(pid_t pid, int handle, const struct packet *packet)
5244 {
5245         const char *cluster_id;
5246         const char *category_id;
5247         struct client_node *client;
5248         int ret;
5249         struct cluster *cluster;
5250         struct category *category;
5251         struct context_info *info;
5252         Eina_List *info_list;
5253         Eina_List *l;
5254
5255         client = client_find_by_pid(pid);
5256         if (!client) {
5257                 ErrPrint("Cilent %d is not exists\n", pid);
5258                 goto out;
5259         }
5260
5261         ret = packet_get(packet, "ss", &cluster_id, &category_id);
5262         if (ret != 2) {
5263                 ErrPrint("Invalid parameter\n");
5264                 goto out;
5265         }
5266
5267         DbgPrint("[%d] cluster[%s] category[%s]\n", pid, cluster_id, category_id);
5268
5269         if (!strlen(cluster_id) || !strcasecmp(cluster_id, DEFAULT_CLUSTER)) {
5270                 ErrPrint("Invalid cluster name: %s\n", cluster_id);
5271                 goto out;
5272         }
5273
5274         cluster = group_find_cluster(cluster_id);
5275         if (!cluster) {
5276                 ErrPrint("Cluster [%s] is not registered\n", cluster_id);
5277                 goto out;
5278         }
5279
5280         category = group_find_category(cluster, category_id);
5281         if (!category) {
5282                 ErrPrint("Category [%s] is not registered\n", category_id);
5283                 goto out;
5284         }
5285
5286         info_list = group_context_info_list(category);
5287         EINA_LIST_FOREACH(info_list, l, info) {
5288                 update_pkg_cb(category, group_pkgname_from_context_info(info));
5289         }
5290
5291 out:
5292         /*! \note No reply packet */
5293         return NULL;
5294 }
5295
5296 static struct packet *client_delete_category(pid_t pid, int handle, const struct packet *packet)
5297 {
5298         const char *cluster;
5299         const char *category;
5300         struct client_node *client;
5301         struct packet *result;
5302         int ret;
5303
5304         client = client_find_by_pid(pid);
5305         if (!client) {
5306                 ErrPrint("Client %d is not exists\n", pid);
5307                 ret = LB_STATUS_ERROR_NOT_EXIST;
5308                 goto out;
5309         }
5310
5311         ret = packet_get(packet, "ss", &cluster, &category);
5312         if (ret != 2) {
5313                 ErrPrint("Invalid paramenters\n");
5314                 ret = LB_STATUS_ERROR_INVALID;
5315                 goto out;
5316         }
5317
5318         DbgPrint("pid[%d] cluster[%s] category[%s]\n", pid, cluster, category);
5319         if (!strlen(cluster) || !strcasecmp(cluster, DEFAULT_CLUSTER)) {
5320                 ErrPrint("Invalid cluster: %s\n", cluster);
5321                 ret = LB_STATUS_ERROR_INVALID;
5322                 goto out;
5323         }
5324
5325         /*!
5326          * \todo
5327          */
5328         ret = LB_STATUS_ERROR_NOT_IMPLEMENTED;
5329
5330 out:
5331         result = packet_create_reply(packet, "i", ret);
5332         if (!result)
5333                 ErrPrint("Failed to create a packet\n");
5334         return result;
5335 }
5336
5337 static struct packet *client_unsubscribed(pid_t pid, int handle, const struct packet *packet)
5338 {
5339         const char *cluster;
5340         const char *category;
5341         struct client_node *client;
5342         int ret;
5343
5344         client = client_find_by_pid(pid);
5345         if (!client) {
5346                 ErrPrint("Client %d is not exists\n", pid);
5347                 ret = LB_STATUS_ERROR_NOT_EXIST;
5348                 goto out;
5349         }
5350
5351         ret = packet_get(packet, "ss", &cluster, &category);
5352         if (ret != 2) {
5353                 ErrPrint("Invalid argument\n");
5354                 ret = LB_STATUS_ERROR_INVALID;
5355                 goto out;
5356         }
5357
5358         DbgPrint("[%d] cluster[%s] category[%s]\n", pid, cluster, category);
5359
5360         if (!strlen(cluster) || !strcasecmp(cluster, DEFAULT_CLUSTER)) {
5361                 ErrPrint("Invalid cluster name: %s\n", cluster);
5362                 goto out;
5363         }
5364
5365         /*!
5366          * \todo
5367          * UNSUBSCRIBE cluster & sub-cluster for a client.
5368          */
5369         ret = client_unsubscribe(client, cluster, category);
5370         if (ret == 0)
5371                 package_alter_instances_to_client(client, ALTER_DESTROY);
5372
5373 out:
5374         /*! \note No reply packet */
5375         return NULL;
5376 }
5377
5378 static struct packet *slave_hello(pid_t pid, int handle, const struct packet *packet) /* slave_name, ret */
5379 {
5380         struct slave_node *slave;
5381         const char *slavename;
5382         int ret;
5383
5384         ret = packet_get(packet, "s", &slavename);
5385         if (ret != 1) {
5386                 ErrPrint("Parameter is not matched\n");
5387                 goto out;
5388         }
5389
5390         DbgPrint("New slave[%s](%d) is arrived\n", slavename, pid);
5391
5392         slave = slave_find_by_name(slavename);
5393
5394         if (!slave) /* Try again to find a slave using pid */
5395                 slave = slave_find_by_pid(pid);
5396
5397         if (!slave) {
5398                 if (DEBUG_MODE) {
5399                         char pkgname[pathconf("/", _PC_PATH_MAX)];
5400                         const char *abi;
5401
5402                         if (aul_app_get_pkgname_bypid(pid, pkgname, sizeof(pkgname)) != AUL_R_OK) {
5403                                 ErrPrint("pid[%d] is not authroized provider package, try to find it using its name[%s]\n", pid, slavename);
5404                                 slave = slave_find_by_name(slavename);
5405                                 pkgname[0] = '\0'; /* Reset the pkgname */
5406                         } else {
5407                                 slave = slave_find_by_pkgname(pkgname);
5408                         }
5409
5410                         if (!slave) {
5411                                 abi = abi_find_by_pkgname(pkgname);
5412                                 if (!abi) {
5413                                         abi = DEFAULT_ABI;
5414                                         DbgPrint("Slave pkgname is invalid, ABI is replaced with '%s'(default)\n", abi);
5415                                 }
5416
5417                                 slave = slave_create(slavename, 1, abi, pkgname, 0);
5418                                 if (!slave) {
5419                                         ErrPrint("Failed to create a new slave for %s\n", slavename);
5420                                         goto out;
5421                                 }
5422
5423                                 DbgPrint("New slave is created (net: 0)\n");
5424                         } else {
5425                                 DbgPrint("Registered slave is replaced with this new one\n");
5426                                 abi = slave_abi(slave);
5427                         }
5428
5429                         slave_set_pid(slave, pid);
5430                         DbgPrint("Provider is forcely activated, pkgname(%s), abi(%s), slavename(%s)\n", pkgname, abi, slavename);
5431                 } else {
5432                         ErrPrint("Slave[%d, %s] is not exists\n", pid, slavename);
5433                         goto out;
5434                 }
5435         } else {
5436                 if (slave_pid(slave) != pid) {
5437                         if (slave_pid(slave) > 0) {
5438                                 CRITICAL_LOG("Slave(%s) is already assigned to %d\n", slave_name(slave), slave_pid(slave));
5439                                 if (pid > 0) {
5440                                         ret = aul_terminate_pid(pid);
5441                                         CRITICAL_LOG("Terminate %d (ret: %d)\n", pid, ret);
5442                                 }
5443                                 goto out;
5444                         }
5445                         CRITICAL_LOG("PID of slave(%s) is updated (%d -> %d)\n", slave_name(slave), slave_pid(slave), pid);
5446                         slave_set_pid(slave, pid);
5447                 }
5448         }
5449
5450         /*!
5451          * \note
5452          * After updating handle,
5453          * slave activated callback will be called.
5454          */
5455         slave_rpc_update_handle(slave, handle);
5456
5457 out:
5458         return NULL;
5459 }
5460
5461 static struct packet *slave_ping(pid_t pid, int handle, const struct packet *packet) /* slave_name, ret */
5462 {
5463         struct slave_node *slave;
5464         const char *slavename;
5465         int ret;
5466
5467         slave = slave_find_by_pid(pid);
5468         if (!slave) {
5469                 ErrPrint("Slave %d is not exists\n", pid);
5470                 goto out;
5471         }
5472
5473         ret = packet_get(packet, "s", &slavename);
5474         if (ret != 1)
5475                 ErrPrint("Parameter is not matched\n");
5476         else
5477                 slave_rpc_ping(slave);
5478
5479 out:
5480         return NULL;
5481 }
5482
5483 static struct packet *slave_faulted(pid_t pid, int handle, const struct packet *packet)
5484 {
5485         struct slave_node *slave;
5486         struct inst_info *inst;
5487         const char *pkgname;
5488         const char *id;
5489         const char *func;
5490         int ret;
5491
5492         slave = slave_find_by_pid(pid);
5493         if (!slave) {
5494                 ErrPrint("Slave %d is not exists\n", pid);
5495                 goto out;
5496         }
5497
5498         ret = packet_get(packet, "sss", &pkgname, &id, &func);
5499         if (ret != 3) {
5500                 ErrPrint("Parameter is not matched\n");
5501                 goto out;
5502         }
5503
5504         ret = fault_info_set(slave, pkgname, id, func);
5505         DbgPrint("Slave Faulted: %s (%d)\n", slave_name(slave), ret);
5506
5507         inst = package_find_instance_by_id(pkgname, id);
5508         if (!inst) {
5509                 DbgPrint("There is a no such instance(%s)\n", id);
5510         } else if (instance_state(inst) == INST_DESTROYED) {
5511                 ErrPrint("Instance(%s) is already destroyed\n", id);
5512         } else {
5513                 ret = instance_destroy(inst);
5514         }
5515
5516 out:
5517         return NULL;
5518 }
5519
5520 static struct packet *slave_lb_update_begin(pid_t pid, int handle, const struct packet *packet)
5521 {
5522         struct slave_node *slave;
5523         struct inst_info *inst;
5524         const struct pkg_info *pkg;
5525         const char *pkgname;
5526         const char *id;
5527         double priority;
5528         const char *content;
5529         const char *title;
5530         int ret;
5531
5532         slave = slave_find_by_pid(pid);
5533         if (!slave) {
5534                 ErrPrint("Slave %d is not exists\n", pid);
5535                 goto out;
5536         }
5537
5538         ret = packet_get(packet, "ssdss", &pkgname, &id, &priority, &content, &title);
5539         if (ret != 5) {
5540                 ErrPrint("Invalid parameters\n");
5541                 goto out;
5542         }
5543
5544         ret = validate_request(pkgname, id, &inst, &pkg);
5545         if (ret != LB_STATUS_SUCCESS)
5546                 goto out;
5547
5548         if (instance_state(inst) == INST_DESTROYED) {
5549                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5550                 goto out;
5551         }
5552
5553         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
5554                 ret = instance_lb_update_begin(inst, priority, content, title);
5555                 if (ret == LB_STATUS_SUCCESS)
5556                         slave_freeze_ttl(slave);
5557         } else {
5558                 ErrPrint("Invalid request[%s]\n", id);
5559         }
5560
5561 out:
5562         return NULL;
5563 }
5564
5565 static struct packet *slave_lb_update_end(pid_t pid, int handle, const struct packet *packet)
5566 {
5567         struct slave_node *slave;
5568         struct inst_info *inst;
5569         const struct pkg_info *pkg;
5570         const char *pkgname;
5571         const char *id;
5572         int ret;
5573
5574         slave = slave_find_by_pid(pid);
5575         if (!slave) {
5576                 ErrPrint("Slave %d is not exists\n", pid);
5577                 goto out;
5578         }
5579
5580         ret = packet_get(packet, "ss", &pkgname, &id);
5581         if (ret != 2) {
5582                 ErrPrint("Invalid parameters\n");
5583                 goto out;
5584         }
5585
5586         ret = validate_request(pkgname, id, &inst, &pkg);
5587         if (ret != LB_STATUS_SUCCESS)
5588                 goto out;
5589
5590         if (instance_state(inst) == INST_DESTROYED) {
5591                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5592                 goto out;
5593         }
5594
5595         if (package_lb_type(pkg) == LB_TYPE_BUFFER) {
5596                 ret = instance_lb_update_end(inst);
5597                 if (ret == LB_STATUS_SUCCESS)
5598                         slave_thaw_ttl(slave);
5599         } else {
5600                 ErrPrint("Invalid request[%s]\n", id);
5601         }
5602
5603 out:
5604         return NULL;
5605 }
5606
5607 static struct packet *slave_pd_update_begin(pid_t pid, int handle, const struct packet *packet)
5608 {
5609         struct slave_node *slave;
5610         const struct pkg_info *pkg;
5611         struct inst_info *inst;
5612         const char *pkgname;
5613         const char *id;
5614         int ret;
5615
5616         slave = slave_find_by_pid(pid);
5617         if (!slave) {
5618                 ErrPrint("Slave %d is not exists\n", pid);
5619                 goto out;
5620         }
5621
5622         ret = packet_get(packet, "ss", &pkgname, &id);
5623         if (ret != 2) {
5624                 ErrPrint("Invalid parameters\n");
5625                 goto out;
5626         }
5627
5628         ret = validate_request(pkgname, id, &inst, &pkg);
5629         if (ret != LB_STATUS_SUCCESS)
5630                 goto out;
5631
5632         if (instance_state(inst) == INST_DESTROYED) {
5633                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5634                 goto out;
5635         }
5636
5637         if (package_pd_type(pkg) == PD_TYPE_BUFFER)
5638                 (void)instance_pd_update_begin(inst);
5639         else
5640                 ErrPrint("Invalid request[%s]\n", id);
5641
5642 out:
5643         return NULL;
5644 }
5645
5646 static struct packet *slave_access_status(pid_t pid, int handle, const struct packet *packet)
5647 {
5648         struct slave_node *slave;
5649         struct inst_info *inst;
5650         const char *pkgname;
5651         const char *id;
5652         int status;
5653         int ret;
5654
5655         slave = slave_find_by_pid(pid);
5656         if (!slave) {
5657                 ErrPrint("Slave %d is not exists\n", pid);
5658                 goto out;
5659         }
5660
5661         ret = packet_get(packet, "ssi", &pkgname, &id, &status);
5662         if (ret != 3) {
5663                 ErrPrint("Invalid parameters\n");
5664                 goto out;
5665         }
5666
5667         ret = validate_request(pkgname, id, &inst, NULL);
5668         if (ret == LB_STATUS_SUCCESS) {
5669                 if (instance_state(inst) == INST_DESTROYED)
5670                         ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5671                 else
5672                         (void)instance_forward_packet(inst, packet_ref((struct packet *)packet));
5673         }
5674
5675 out:
5676         return NULL;
5677 }
5678
5679 static struct packet *slave_pd_update_end(pid_t pid, int handle, const struct packet *packet)
5680 {
5681         struct slave_node *slave;
5682         const struct pkg_info *pkg;
5683         struct inst_info *inst;
5684         const char *pkgname;
5685         const char *id;
5686         int ret;
5687
5688         slave = slave_find_by_pid(pid);
5689         if (!slave) {
5690                 ErrPrint("Slave %d is not exists\n", pid);
5691                 goto out;
5692         }
5693
5694         ret = packet_get(packet, "ss", &pkgname, &id);
5695         if (ret != 2) {
5696                 ErrPrint("Invalid parameters\n");
5697                 goto out;
5698         }
5699
5700         ret = validate_request(pkgname, id, &inst, &pkg);
5701         if (ret != LB_STATUS_SUCCESS)
5702                 goto out;
5703
5704         if (instance_state(inst) == INST_DESTROYED) {
5705                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5706                 goto out;
5707         }
5708
5709         if (package_pd_type(pkg) == PD_TYPE_BUFFER)
5710                 (void)instance_pd_update_end(inst);
5711         else
5712                 ErrPrint("Invalid request[%s]\n", id);
5713
5714 out:
5715         return NULL;
5716 }
5717
5718 static struct packet *slave_call(pid_t pid, int handle, const struct packet *packet) /* slave_name, pkgname, filename, function, ret */
5719 {
5720         struct slave_node *slave;
5721         const char *pkgname;
5722         const char *id;
5723         const char *func;
5724         int ret;
5725
5726         slave = slave_find_by_pid(pid);
5727         if (!slave) {
5728                 ErrPrint("Slave %d is not exists\n", pid);
5729                 goto out;
5730         }
5731
5732         ret = packet_get(packet, "sss", &pkgname, &id, &func);
5733         if (ret != 3) {
5734                 ErrPrint("Parameter is not matched\n");
5735                 goto out;
5736         }
5737
5738         ret = fault_func_call(slave, pkgname, id, func);
5739         slave_give_more_ttl(slave);
5740
5741 out:
5742         return NULL;
5743 }
5744
5745 static struct packet *slave_ret(pid_t pid, int handle, const struct packet *packet) /* slave_name, pkgname, filename, function, ret */
5746 {
5747         struct slave_node *slave;
5748         const char *pkgname;
5749         const char *id;
5750         const char *func;
5751         int ret;
5752
5753         slave = slave_find_by_pid(pid);
5754         if (!slave) {
5755                 ErrPrint("Slave %d is not exists\n", pid);
5756                 goto out;
5757         }
5758
5759         ret = packet_get(packet, "sss", &pkgname, &id, &func);
5760         if (ret != 3) {
5761                 ErrPrint("Parameter is not matched\n");
5762                 goto out;
5763         }
5764
5765         ret = fault_func_ret(slave, pkgname, id, func);
5766         slave_give_more_ttl(slave);
5767
5768 out:
5769         return NULL;
5770 }
5771
5772 static struct packet *slave_updated(pid_t pid, int handle, const struct packet *packet) /* slave_name, pkgname, filename, width, height, priority, ret */
5773 {
5774         struct slave_node *slave;
5775         const char *pkgname;
5776         const char *id;
5777         const char *content_info;
5778         const char *title;
5779         int w;
5780         int h;
5781         double priority;
5782         int ret;
5783         struct inst_info *inst;
5784
5785         slave = slave_find_by_pid(pid);
5786         if (!slave) {
5787                 ErrPrint("Slave %d is not exists\n", pid);
5788                 goto out;
5789         }
5790
5791         ret = packet_get(packet, "ssiidss", &pkgname, &id,
5792                                                 &w, &h, &priority,
5793                                                 &content_info, &title);
5794         if (ret != 7) {
5795                 ErrPrint("Parameter is not matched\n");
5796                 goto out;
5797         }
5798
5799         ret = validate_request(pkgname, id, &inst, NULL);
5800         if (ret == LB_STATUS_SUCCESS) {
5801                 char *filename;
5802
5803                 if (instance_state(inst) == INST_DESTROYED) {
5804                         ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5805                         goto out;
5806                 }
5807
5808                 instance_set_lb_info(inst, priority, content_info, title);
5809
5810                 switch (package_lb_type(instance_package(inst))) {
5811                 case LB_TYPE_SCRIPT:
5812                         script_handler_resize(instance_lb_script(inst), w, h);
5813                         filename = util_get_file_kept_in_safe(id);
5814                         if (filename) {
5815                                 (void)script_handler_parse_desc(pkgname, id, filename, 0);
5816                                 DbgFree(filename);
5817                         } else {
5818                                 (void)script_handler_parse_desc(pkgname, id, util_uri_to_path(id), 0);
5819                         }
5820                         break;
5821                 case LB_TYPE_BUFFER:
5822                 default:
5823                         /*!
5824                          * \check
5825                          * text format (inst)
5826                          */
5827                         instance_set_lb_size(inst, w, h);
5828                         instance_lb_updated_by_instance(inst);
5829                         break;
5830                 }
5831
5832                 slave_give_more_ttl(slave);
5833         }
5834
5835 out:
5836         return NULL;
5837 }
5838
5839 static struct packet *slave_hold_scroll(pid_t pid, int handle, const struct packet *packet)
5840 {
5841         struct slave_node *slave;
5842         struct inst_info *inst;
5843         const char *pkgname;
5844         const char *id;
5845         int seize;
5846         int ret;
5847
5848         slave = slave_find_by_pid(pid);
5849         if (!slave) {
5850                 ErrPrint("Slave %d is not exists\n", pid);
5851                 goto out;
5852         }
5853
5854         ret = packet_get(packet, "ssi", &pkgname, &id, &seize);
5855         if (ret != 3) {
5856                 ErrPrint("Parameter is not matched\n");
5857                 goto out;
5858         }
5859
5860         ret = validate_request(pkgname, id, &inst, NULL);
5861         if (ret == LB_STATUS_SUCCESS) {
5862                 if (instance_state(inst) == INST_DESTROYED)
5863                         ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5864                 else
5865                         (void)instance_hold_scroll(inst, seize);
5866         }
5867
5868 out:
5869         return NULL;
5870 }
5871
5872 static struct packet *slave_desc_updated(pid_t pid, int handle, const struct packet *packet) /* slave_name, pkgname, filename, decsfile, ret */
5873 {
5874         struct slave_node *slave;
5875         const char *pkgname;
5876         const char *id;
5877         const char *descfile;
5878         int ret;
5879         struct inst_info *inst;
5880
5881         slave = slave_find_by_pid(pid);
5882         if (!slave) {
5883                 ErrPrint("Slave %d is not exists\n", pid);
5884                 goto out;
5885         }
5886
5887         ret = packet_get(packet, "sss", &pkgname, &id, &descfile);
5888         if (ret != 3) {
5889                 ErrPrint("Parameter is not matched\n");
5890                 goto out;
5891         }
5892
5893         ret = validate_request(pkgname, id, &inst, NULL);
5894         if (ret != LB_STATUS_SUCCESS)
5895                 goto out;
5896
5897         if (instance_state(inst) == INST_DESTROYED) {
5898                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5899                 goto out;
5900         }
5901
5902         switch (package_pd_type(instance_package(inst))) {
5903         case PD_TYPE_SCRIPT:
5904                 if (script_handler_is_loaded(instance_pd_script(inst))) {
5905                         (void)script_handler_parse_desc(pkgname, id, descfile, 1);
5906                 }
5907                 break;
5908         case PD_TYPE_TEXT:
5909                 instance_set_pd_size(inst, 0, 0);
5910         case PD_TYPE_BUFFER:
5911                 instance_pd_updated(pkgname, id, descfile);
5912                 break;
5913         default:
5914                 DbgPrint("Ignore updated DESC(%s)\n", pkgname);
5915                 break;
5916         }
5917
5918 out:
5919         return NULL;
5920 }
5921
5922 static struct packet *slave_deleted(pid_t pid, int handle, const struct packet *packet) /* slave_name, pkgname, id, ret */
5923 {
5924         struct slave_node *slave;
5925         const char *pkgname;
5926         const char *id;
5927         int ret;
5928         struct inst_info *inst;
5929
5930         slave = slave_find_by_pid(pid);
5931         if (!slave) {
5932                 ErrPrint("Slave %d is not exists\n", pid);
5933                 goto out;
5934         }
5935
5936         ret = packet_get(packet, "ss", &pkgname, &id);
5937         if (ret != 2) {
5938                 ErrPrint("Parameter is not matched\n");
5939                 goto out;
5940         }
5941
5942         ret = validate_request(pkgname, id, &inst, NULL);
5943         if (ret == LB_STATUS_SUCCESS) {
5944                 ret = instance_destroyed(inst);
5945         }
5946
5947 out:
5948         return NULL;
5949 }
5950
5951 /*!
5952  * \note for the BUFFER Type slave
5953  */
5954 static struct packet *slave_acquire_buffer(pid_t pid, int handle, const struct packet *packet) /* type, id, w, h, size */
5955 {
5956         enum target_type target;
5957         const char *pkgname;
5958         const char *id;
5959         int w;
5960         int h;
5961         int pixel_size;
5962         struct packet *result;
5963         struct slave_node *slave;
5964         struct inst_info *inst;
5965         const struct pkg_info *pkg;
5966         int ret;
5967
5968         slave = slave_find_by_pid(pid);
5969         if (!slave) {
5970                 ErrPrint("Failed to find a slave\n");
5971                 id = "";
5972                 ret = LB_STATUS_ERROR_NOT_EXIST;
5973                 goto out;
5974         }
5975
5976         ret = packet_get(packet, "issiii", &target, &pkgname, &id, &w, &h, &pixel_size);
5977         if (ret != 6) {
5978                 ErrPrint("Invalid argument\n");
5979                 id = "";
5980                 ret = LB_STATUS_ERROR_INVALID;
5981                 goto out;
5982         }
5983
5984         ret = validate_request(pkgname, id, &inst, &pkg);
5985         id = "";
5986
5987         if (ret != LB_STATUS_SUCCESS)
5988                 goto out;
5989
5990         ret = LB_STATUS_ERROR_INVALID;
5991
5992         if (instance_state(inst) == INST_DESTROYED) {
5993                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
5994                 goto out;
5995         }
5996
5997         if (target == TYPE_LB && package_lb_type(pkg) == LB_TYPE_BUFFER) {
5998                 struct buffer_info *info;
5999
6000                 info = instance_lb_buffer(inst);
6001                 if (!info) {
6002                         if (!instance_create_lb_buffer(inst)) {
6003                                 ErrPrint("Failed to create a LB buffer\n");
6004                                 ret = LB_STATUS_ERROR_FAULT;
6005                                 goto out;
6006                         }
6007
6008                         info = instance_lb_buffer(inst);
6009                         if (!info) {
6010                                 ErrPrint("LB buffer is not valid\n");
6011                                 /*!
6012                                  * \NOTE
6013                                  * ret value should not be changed.
6014                                  */
6015                                 goto out;
6016                         }
6017                 }
6018
6019                 ret = buffer_handler_resize(info, w, h);
6020                 ret = buffer_handler_load(info);
6021                 if (ret == 0) {
6022                         instance_set_lb_size(inst, w, h);
6023                         instance_set_lb_info(inst, PRIORITY_NO_CHANGE, CONTENT_NO_CHANGE, TITLE_NO_CHANGE);
6024                         id = buffer_handler_id(info);
6025                 } else {
6026                         ErrPrint("Failed to load a buffer(%d)\n", ret);
6027                 }
6028         } else if (target == TYPE_PD && package_pd_type(pkg) == PD_TYPE_BUFFER) {
6029                 struct buffer_info *info;
6030                 Ecore_Timer *pd_monitor;
6031                 int is_resize;
6032
6033                 is_resize = 0;
6034                 pd_monitor = instance_del_data(inst, "pd,open,monitor");
6035                 if (!pd_monitor) {
6036                         pd_monitor = instance_del_data(inst, "pd,resize,monitor");
6037                         is_resize = !!pd_monitor;
6038                         if (!is_resize)
6039                                 goto out;
6040                 }
6041
6042                 ecore_timer_del(pd_monitor);
6043                 inst = instance_unref(inst);
6044                 if (!inst) {
6045                         ErrPrint("Instance refcnt is ZERO: %s\n", pkgname);
6046                         goto out;
6047                 }
6048
6049                 info = instance_pd_buffer(inst);
6050                 if (!info) {
6051                         if (!instance_create_pd_buffer(inst)) {
6052                                 ErrPrint("Failed to create a PD buffer\n");
6053                                 ret = LB_STATUS_ERROR_FAULT;
6054                                 instance_client_pd_created(inst, ret);
6055                                 goto out;
6056                         }
6057
6058                         info = instance_pd_buffer(inst);
6059                         if (!info) {
6060                                 ErrPrint("PD buffer is not valid\n");
6061                                 /*!
6062                                  * \NOTE
6063                                  * ret value should not be changed.
6064                                  */
6065                                 instance_client_pd_created(inst, ret);
6066                                 goto out;
6067                         }
6068                 }
6069
6070                 ret = buffer_handler_resize(info, w, h);
6071                 ret = buffer_handler_load(info);
6072                 if (ret == 0) {
6073                         instance_set_pd_size(inst, w, h);
6074                         id = buffer_handler_id(info);
6075                 } else {
6076                         ErrPrint("Failed to load a buffer (%d)\n", ret);
6077                 }
6078
6079                 /*!
6080                  * Send the PD created event to the client
6081                  */
6082                 if (!is_resize)
6083                         instance_client_pd_created(inst, ret);
6084         }
6085
6086 out:
6087         result = packet_create_reply(packet, "is", ret, id);
6088         if (!result)
6089                 ErrPrint("Failed to create a packet\n");
6090
6091         return result;
6092 }
6093
6094 static struct packet *slave_resize_buffer(pid_t pid, int handle, const struct packet *packet)
6095 {
6096         struct slave_node *slave;
6097         struct packet *result;
6098         enum target_type type;
6099         const char *pkgname;
6100         const char *id;
6101         int w;
6102         int h;
6103         struct inst_info *inst;
6104         const struct pkg_info *pkg;
6105         int ret;
6106
6107         slave = slave_find_by_pid(pid);
6108         if (!slave) {
6109                 ErrPrint("Failed to find a slave\n");
6110                 ret = LB_STATUS_ERROR_NOT_EXIST;
6111                 id = "";
6112                 goto out;
6113         }
6114
6115         ret = packet_get(packet, "issii", &type, &pkgname, &id, &w, &h);
6116         if (ret != 5) {
6117                 ErrPrint("Invalid argument\n");
6118                 ret = LB_STATUS_ERROR_INVALID;
6119                 id = "";
6120                 goto out;
6121         }
6122
6123         ret = validate_request(pkgname, id, &inst, &pkg);
6124         id = "";
6125         if (ret != LB_STATUS_SUCCESS)
6126                 goto out;
6127
6128         ret = LB_STATUS_ERROR_INVALID;
6129         /*!
6130          * \note
6131          * Reset "id", It will be re-used from here
6132          */
6133
6134         if (instance_state(inst) == INST_DESTROYED) {
6135                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
6136                 goto out;
6137         }
6138
6139         if (type == TYPE_LB && package_lb_type(pkg) == LB_TYPE_BUFFER) {
6140                 struct buffer_info *info;
6141
6142                 info = instance_lb_buffer(inst);
6143                 if (!info)
6144                         goto out;
6145
6146                 ret = buffer_handler_resize(info, w, h);
6147                 /*!
6148                  * \note
6149                  * id is resued for newly assigned ID
6150                  */
6151                 if (ret == LB_STATUS_SUCCESS) {
6152                         id = buffer_handler_id(info);
6153                         instance_set_lb_size(inst, w, h);
6154                         instance_set_lb_info(inst, PRIORITY_NO_CHANGE, CONTENT_NO_CHANGE, TITLE_NO_CHANGE);
6155                 }
6156         } else if (type == TYPE_PD && package_pd_type(pkg) == PD_TYPE_BUFFER) {
6157                 struct buffer_info *info;
6158
6159                 info = instance_pd_buffer(inst);
6160                 if (!info)
6161                         goto out;
6162
6163                 ret = buffer_handler_resize(info, w, h);
6164                 /*!
6165                  * \note
6166                  * id is resued for newly assigned ID
6167                  */
6168                 if (ret == LB_STATUS_SUCCESS) {
6169                         id = buffer_handler_id(info);
6170                         instance_set_pd_size(inst, w, h);
6171                 }
6172         }
6173
6174 out:
6175         result = packet_create_reply(packet, "is", ret, id);
6176         if (!result)
6177                 ErrPrint("Failed to create a packet\n");
6178
6179         return result;
6180 }
6181
6182 static struct packet *slave_release_buffer(pid_t pid, int handle, const struct packet *packet)
6183 {
6184         enum target_type type;
6185         const char *pkgname;
6186         const char *id;
6187         struct packet *result;
6188         struct slave_node *slave;
6189         struct inst_info *inst;
6190         const struct pkg_info *pkg;
6191         int ret;
6192
6193         slave = slave_find_by_pid(pid);
6194         if (!slave) {
6195                 ErrPrint("Failed to find a slave\n");
6196                 ret = LB_STATUS_ERROR_NOT_EXIST;
6197                 goto out;
6198         }
6199
6200         if (packet_get(packet, "iss", &type, &pkgname, &id) != 3) {
6201                 ErrPrint("Inavlid argument\n");
6202                 ret = LB_STATUS_ERROR_INVALID;
6203                 goto out;
6204         }
6205
6206         ret = validate_request(pkgname, id, &inst, &pkg);
6207         if (ret != LB_STATUS_SUCCESS)
6208                 goto out;
6209
6210         ret = LB_STATUS_ERROR_INVALID;
6211
6212         if (type == TYPE_LB && package_lb_type(pkg) == LB_TYPE_BUFFER) {
6213                 struct buffer_info *info;
6214
6215                 info = instance_lb_buffer(inst);
6216                 ret = buffer_handler_unload(info);
6217         } else if (type == TYPE_PD && package_pd_type(pkg) == PD_TYPE_BUFFER) {
6218                 struct buffer_info *info;
6219                 Ecore_Timer *pd_monitor;
6220
6221                 pd_monitor = instance_del_data(inst, "pd,close,monitor");
6222                 if (!pd_monitor) {
6223                         ErrPrint("Slave requests to release a buffer\n");
6224                         /*!
6225                          * \note
6226                          * In this case just keep going to release buffer,
6227                          * Even if a user(client) doesn't wants to destroy the PD.
6228                          *
6229                          * If the slave tries to destroy PD buffer, it should be
6230                          * released and reported to the client about its status.
6231                          *
6232                          * Even if the pd is destroyed by timeout handler,
6233                          * instance_client_pd_destroyed function will be ignored
6234                          * by pd.need_to_send_close_event flag.
6235                          * which will be checked by instance_client_pd_destroyed function.
6236                          */
6237
6238                         /*!
6239                          * \note
6240                          * provider can try to resize the buffer size.
6241                          * in that case, it will release the buffer first.
6242                          * Then even though the client doesn't request to close the PD,
6243                          * the provider can release it.
6244                          * If we send the close event to the client,
6245                          * The client will not able to allocate PD again.
6246                          * In this case, add the pd,monitor again. from here.
6247                          * to wait the re-allocate buffer.
6248                          * If the client doesn't request buffer reallocation,
6249                          * Treat it as a fault. and close the PD.
6250                          */
6251                         info = instance_pd_buffer(inst);
6252                         ret = buffer_handler_unload(info);
6253
6254                         if (ret == LB_STATUS_SUCCESS) {
6255                                 pd_monitor = ecore_timer_add(PD_REQUEST_TIMEOUT, pd_resize_monitor_cb, instance_ref(inst));
6256                                 if (!pd_monitor) {
6257                                         (void)instance_unref(inst);
6258                                         ErrPrint("Failed to create a timer for PD Open monitor\n");
6259                                 } else {
6260                                         (void)instance_set_data(inst, "pd,resize,monitor", pd_monitor);
6261                                 }
6262                         }
6263                 } else {
6264                         ecore_timer_del(pd_monitor);
6265                         inst = instance_unref(inst);
6266                         if (!inst) {
6267                                 ErrPrint("Instance is released: %s\n", pkgname);
6268                                 ret = LB_STATUS_ERROR_FAULT;
6269                                 goto out;
6270                         }
6271
6272                         info = instance_pd_buffer(inst);
6273                         ret = buffer_handler_unload(info);
6274
6275                         /*!
6276                          * \note
6277                          * Send the PD destroyed event to the client
6278                          */
6279                         instance_client_pd_destroyed(inst, ret);
6280                 }
6281
6282         }
6283
6284 out:
6285         result = packet_create_reply(packet, "i", ret);
6286         if (!result)
6287                 ErrPrint("Failed to create a packet\n");
6288
6289         return result;
6290 }
6291
6292 static struct packet *service_change_period(pid_t pid, int handle, const struct packet *packet)
6293 {
6294         struct inst_info *inst;
6295         struct packet *result;
6296         const char *pkgname;
6297         const char *id;
6298         double period;
6299         int ret;
6300
6301         ret = packet_get(packet, "ssd", &pkgname, &id, &period);
6302         if (ret != 3) {
6303                 ErrPrint("Invalid packet\n");
6304                 ret = LB_STATUS_ERROR_INVALID;
6305                 goto out;
6306         }
6307
6308         if (!strlen(id)) {
6309                 struct pkg_info *pkg;
6310
6311                 pkg = package_find(pkgname);
6312                 if (!pkg) {
6313                         ret = LB_STATUS_ERROR_NOT_EXIST;
6314                 } else if (package_is_fault(pkg)) {
6315                         ret = LB_STATUS_ERROR_FAULT;
6316                 } else {
6317                         Eina_List *inst_list;
6318                         Eina_List *l;
6319
6320                         inst_list = package_instance_list(pkg);
6321                         EINA_LIST_FOREACH(inst_list, l, inst) {
6322                                 ret = instance_set_period(inst, period);
6323                                 if (ret < 0)
6324                                         ErrPrint("Failed to change the period of %s to (%lf)\n", pkgname, period);
6325                         }
6326                 }
6327         } else {
6328                 ret = validate_request(pkgname, id, &inst, NULL);
6329                 if (ret == LB_STATUS_SUCCESS) {
6330                         if (instance_state(inst) == INST_DESTROYED) {
6331                                 ErrPrint("Package[%s] instance is already destroyed\n", pkgname);
6332                                 ret = LB_STATUS_ERROR_INVALID;
6333                                 goto out;
6334                         }
6335
6336                         ret = instance_set_period(inst, period);
6337                 }
6338         }
6339
6340         DbgPrint("Change the update period: %s, %lf : %d\n", pkgname, period, ret);
6341 out:
6342         result = packet_create_reply(packet, "i", ret);
6343         if (!result)
6344                 ErrPrint("Failed to create a packet\n");
6345
6346         return result;
6347 }
6348
6349 static struct packet *service_update(pid_t pid, int handle, const struct packet *packet)
6350 {
6351         Eina_List *inst_list;
6352         struct pkg_info *pkg;
6353         struct packet *result;
6354         const char *pkgname;
6355         const char *id;
6356         const char *cluster;
6357         const char *category;
6358         char *lb_pkgname;
6359         int ret;
6360
6361         ret = packet_get(packet, "ssss", &pkgname, &id, &cluster, &category);
6362         if (ret != 4) {
6363                 ErrPrint("Invalid Packet\n");
6364                 ret = LB_STATUS_ERROR_INVALID;
6365                 goto out;
6366         }
6367
6368         lb_pkgname = package_lb_pkgname(pkgname);
6369         if (!lb_pkgname) {
6370                 ErrPrint("Invalid package %s\n", pkgname);
6371                 ret = LB_STATUS_ERROR_INVALID;
6372                 goto out;
6373         }
6374
6375         pkg = package_find(lb_pkgname);
6376         if (!pkg) {
6377                 ret = LB_STATUS_ERROR_NOT_EXIST;
6378                 DbgFree(lb_pkgname);
6379                 goto out;
6380         }
6381
6382         if (package_is_fault(pkg)) {
6383                 ret = LB_STATUS_ERROR_FAULT;
6384                 DbgFree(lb_pkgname);
6385                 goto out;
6386         }
6387
6388         inst_list = package_instance_list(pkg);
6389         if (!eina_list_count(inst_list)) {
6390                 ret = LB_STATUS_ERROR_NOT_EXIST;
6391                 DbgFree(lb_pkgname);
6392                 goto out;
6393         }
6394
6395         if (id && strlen(id)) {
6396                 Eina_List *l;
6397                 struct inst_info *inst;
6398
6399                 ret = LB_STATUS_ERROR_NOT_EXIST;
6400                 EINA_LIST_FOREACH(inst_list, l, inst) {
6401                         if (!strcmp(instance_id(inst), id)) {
6402                                 ret = LB_STATUS_SUCCESS;
6403                                 break;
6404                         }
6405                 }
6406
6407                 if (ret == LB_STATUS_ERROR_NOT_EXIST) {
6408                         DbgFree(lb_pkgname);
6409                         goto out;
6410                 }
6411         }
6412
6413         /*!
6414          * \TODO
6415          * Validate the update requstor.
6416          */
6417         slave_rpc_request_update(lb_pkgname, id, cluster, category);
6418         DbgFree(lb_pkgname);
6419         ret = LB_STATUS_SUCCESS;
6420
6421 out:
6422         result = packet_create_reply(packet, "i", ret);
6423         if (!result)
6424                 ErrPrint("Failed to create a packet\n");
6425
6426         return result;
6427 }
6428
6429 static struct packet *liveinfo_hello(pid_t pid, int handle, const struct packet *packet)
6430 {
6431         struct liveinfo *info;
6432         struct packet *result;
6433         int ret;
6434         const char *fifo_name;
6435         double timestamp;
6436
6437         DbgPrint("Request arrived from %d\n", pid);
6438
6439         if (packet_get(packet, "d", &timestamp) != 1) {
6440                 ErrPrint("Invalid packet\n");
6441                 fifo_name = "";
6442                 ret = LB_STATUS_ERROR_INVALID;
6443                 goto out;
6444         }
6445
6446         info = liveinfo_create(pid, handle);
6447         if (!info) {
6448                 ErrPrint("Failed to create a liveinfo object\n");
6449                 fifo_name = "";
6450                 ret = LB_STATUS_ERROR_INVALID;
6451                 goto out;
6452         }
6453
6454         ret = 0;
6455         fifo_name = liveinfo_filename(info);
6456         DbgPrint("FIFO Created: %s (Serve for %d)\n", fifo_name, pid);
6457
6458 out:
6459         result = packet_create_reply(packet, "si", fifo_name, ret);
6460         if (!result)
6461                 ErrPrint("Failed to create a result packet\n");
6462
6463         return result;
6464 }
6465
6466 static struct packet *liveinfo_slave_list(pid_t pid, int handle, const struct packet *packet)
6467 {
6468         Eina_List *l;
6469         Eina_List *list;
6470         struct liveinfo *info;
6471         struct slave_node *slave;
6472         FILE *fp;
6473         double timestamp;
6474
6475         if (packet_get(packet, "d", &timestamp) != 1) {
6476                 ErrPrint("Invalid argument\n");
6477                 goto out;
6478         }
6479
6480         info = liveinfo_find_by_pid(pid);
6481         if (!info) {
6482                 ErrPrint("Invalid request\n");
6483                 goto out;
6484         }
6485
6486         liveinfo_open_fifo(info);
6487         fp = liveinfo_fifo(info);
6488         if (!fp) {
6489                 liveinfo_close_fifo(info);
6490                 goto out;
6491         }
6492
6493         list = (Eina_List *)slave_list();
6494         EINA_LIST_FOREACH(list, l, slave) {
6495                 fprintf(fp, "%d %s %s %s %d %d %d %s %d %d %lf\n",
6496                         slave_pid(slave),
6497                         slave_name(slave),
6498                         slave_pkgname(slave),
6499                         slave_abi(slave),
6500                         slave_is_secured(slave),
6501                         slave_refcnt(slave),
6502                         slave_fault_count(slave),
6503                         slave_state_string(slave),
6504                         slave_loaded_instance(slave),
6505                         slave_loaded_package(slave),
6506                         slave_ttl(slave)
6507                 );
6508         }
6509
6510         fprintf(fp, "EOD\n");
6511         liveinfo_close_fifo(info);
6512 out:
6513         return NULL;
6514 }
6515
6516 static inline const char *visible_state_string(enum livebox_visible_state state)
6517 {
6518         switch (state) {
6519         case LB_SHOW:
6520                 return "Show";
6521         case LB_HIDE:
6522                 return "Hide";
6523         case LB_HIDE_WITH_PAUSE:
6524                 return "Paused";
6525         default:
6526                 break;
6527         }
6528
6529         return "Unknown";
6530 }
6531
6532 static struct packet *liveinfo_inst_list(pid_t pid, int handle, const struct packet *packet)
6533 {
6534         const char *pkgname;
6535         struct liveinfo *info;
6536         struct pkg_info *pkg;
6537         Eina_List *l;
6538         Eina_List *inst_list;
6539         struct inst_info *inst;
6540         FILE *fp;
6541
6542         if (packet_get(packet, "s", &pkgname) != 1) {
6543                 ErrPrint("Invalid argument\n");
6544                 goto out;
6545         }
6546
6547         info = liveinfo_find_by_pid(pid);
6548         if (!info) {
6549                 ErrPrint("Invalid request\n");
6550                 goto out;
6551         }
6552
6553         liveinfo_open_fifo(info);
6554         fp = liveinfo_fifo(info);
6555         if (!fp) {
6556                 ErrPrint("Invalid fp\n");
6557                 liveinfo_close_fifo(info);
6558                 goto out;
6559         }
6560
6561         if (!package_is_lb_pkgname(pkgname)) {
6562                 ErrPrint("Invalid package name\n");
6563                 goto close_out;
6564         }
6565
6566         pkg = package_find(pkgname);
6567         if (!pkg) {
6568                 ErrPrint("Package is not exists\n");
6569                 goto close_out;
6570         }
6571
6572         inst_list = package_instance_list(pkg);
6573         EINA_LIST_FOREACH(inst_list, l, inst) {
6574                 fprintf(fp, "%s %s %s %lf %s %d %d\n",
6575                         instance_id(inst),
6576                         instance_cluster(inst),
6577                         instance_category(inst),
6578                         instance_period(inst),
6579                         visible_state_string(instance_visible_state(inst)),
6580                         instance_lb_width(inst),
6581                         instance_lb_height(inst));
6582         }
6583
6584 close_out:
6585         fprintf(fp, "EOD\n");
6586         liveinfo_close_fifo(info);
6587
6588 out:
6589         return NULL;
6590 }
6591
6592 static struct packet *liveinfo_pkg_list(pid_t pid, int handle, const struct packet *packet)
6593 {
6594         Eina_List *l;
6595         Eina_List *list;
6596         Eina_List *inst_list;
6597         struct liveinfo *info;
6598         struct pkg_info *pkg;
6599         struct slave_node *slave;
6600         FILE *fp;
6601         const char *slavename;
6602         double timestamp;
6603
6604         if (packet_get(packet, "d", &timestamp) != 1) {
6605                 ErrPrint("Invalid argument\n");
6606                 goto out;
6607         }
6608
6609         info = liveinfo_find_by_pid(pid);
6610         if (!info) {
6611                 ErrPrint("Invalid request\n");
6612                 goto out;
6613         }
6614
6615         liveinfo_open_fifo(info);
6616         fp = liveinfo_fifo(info);
6617         if (!fp) {
6618                 liveinfo_close_fifo(info);
6619                 goto out;
6620         }
6621
6622         list = (Eina_List *)package_list();
6623         EINA_LIST_FOREACH(list, l, pkg) {
6624                 slave = package_slave(pkg);
6625
6626                 if (slave) {
6627                         slavename = slave_name(slave);
6628                         pid = slave_pid(slave);
6629                 } else {
6630                         pid = (pid_t)-1;
6631                         slavename = "";
6632                 }
6633
6634                 inst_list = (Eina_List *)package_instance_list(pkg);
6635                 fprintf(fp, "%d %s %s %s %d %d %d\n",
6636                         pid,
6637                         strlen(slavename) ? slavename : "(none)",
6638                         package_name(pkg),
6639                         package_abi(pkg),
6640                         package_refcnt(pkg),
6641                         package_fault_count(pkg),
6642                         eina_list_count(inst_list)
6643                 );
6644         }
6645
6646         fprintf(fp, "EOD\n");
6647         liveinfo_close_fifo(info);
6648 out:
6649         return NULL;
6650 }
6651
6652 static struct packet *liveinfo_slave_ctrl(pid_t pid, int handle, const struct packet *packet)
6653 {
6654         return NULL;
6655 }
6656
6657 static struct packet *liveinfo_pkg_ctrl(pid_t pid, int handle, const struct packet *packet)
6658 {
6659         struct liveinfo *info;
6660         FILE *fp;
6661         char *cmd;
6662         char *pkgname;
6663         char *id;
6664
6665         if (packet_get(packet, "sss", &cmd, &pkgname, &id) != 3) {
6666                 ErrPrint("Invalid argument\n");
6667                 goto out;
6668         }
6669
6670         info = liveinfo_find_by_pid(pid);
6671         if (!info) {
6672                 ErrPrint("Invalid request\n");
6673                 goto out;
6674         }
6675
6676         liveinfo_open_fifo(info);
6677         fp = liveinfo_fifo(info);
6678         if (!fp) {
6679                 liveinfo_close_fifo(info);
6680                 goto out;
6681         }
6682
6683         if (!strcmp(cmd, "rmpack")) {
6684                 fprintf(fp, "%d\n", ENOSYS);
6685         } else if (!strcmp(cmd, "rminst")) {
6686                 struct inst_info *inst;
6687                 inst = package_find_instance_by_id(pkgname, id);
6688                 if (!inst) {
6689                         fprintf(fp, "%d\n", ENOENT);
6690                 } else {
6691                         (void)instance_destroy(inst);
6692                         fprintf(fp, "%d\n", 0);
6693                 }
6694         }
6695
6696         fprintf(fp, "EOD\n");
6697         liveinfo_close_fifo(info);
6698
6699 out:
6700         return NULL;
6701 }
6702
6703 static struct packet *liveinfo_master_ctrl(pid_t pid, int handle, const struct packet *packet)
6704 {
6705         struct liveinfo *info;
6706         char *cmd;
6707         char *var;
6708         char *val;
6709         FILE *fp;
6710         int ret = LB_STATUS_ERROR_INVALID;
6711
6712         if (packet_get(packet, "sss", &cmd, &var, &val) != 3) {
6713                 ErrPrint("Invalid argument\n");
6714                 goto out;
6715         }
6716
6717         info = liveinfo_find_by_pid(pid);
6718         if (!info) {
6719                 ErrPrint("Invalid request\n");
6720                 goto out;
6721         }
6722
6723         if (!strcasecmp(var, "debug")) {
6724                 if (!strcasecmp(cmd, "set")) {
6725                         g_conf.debug_mode = !strcasecmp(val, "on");
6726                 } else if (!strcasecmp(cmd, "get")) {
6727                 }
6728                 ret = g_conf.debug_mode;
6729         } else if (!strcasecmp(var, "slave_max_load")) {
6730                 if (!strcasecmp(cmd, "set")) {
6731                         g_conf.slave_max_load = atoi(val);
6732                 } else if (!strcasecmp(cmd, "get")) {
6733                 }
6734                 ret = g_conf.slave_max_load;
6735         }
6736
6737         liveinfo_open_fifo(info);
6738         fp = liveinfo_fifo(info);
6739         if (!fp) {
6740                 liveinfo_close_fifo(info);
6741                 goto out;
6742         }
6743         fprintf(fp, "%d\nEOD\n", ret);
6744         liveinfo_close_fifo(info);
6745
6746 out:
6747         return NULL;
6748 }
6749
6750 static struct method s_info_table[] = {
6751         {
6752                 .cmd = "liveinfo_hello",
6753                 .handler = liveinfo_hello,
6754         },
6755         {
6756                 .cmd = "slave_list",
6757                 .handler = liveinfo_slave_list,
6758         },
6759         {
6760                 .cmd = "pkg_list",
6761                 .handler = liveinfo_pkg_list,
6762         },
6763         {
6764                 .cmd = "inst_list",
6765                 .handler = liveinfo_inst_list,
6766         },
6767         {
6768                 .cmd = "slave_ctrl",
6769                 .handler = liveinfo_slave_ctrl,
6770         },
6771         {
6772                 .cmd = "pkg_ctrl",
6773                 .handler = liveinfo_pkg_ctrl,
6774         },
6775         {
6776                 .cmd = "master_ctrl",
6777                 .handler = liveinfo_master_ctrl,
6778         },
6779         {
6780                 .cmd = NULL,
6781                 .handler = NULL,
6782         },
6783 };
6784
6785 static struct method s_client_table[] = {
6786         {
6787                 .cmd = "pd_mouse_move",
6788                 .handler = client_pd_mouse_move, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6789         },
6790         {
6791                 .cmd = "lb_mouse_move",
6792                 .handler = client_lb_mouse_move, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6793         },
6794         {
6795                 .cmd = "pd_mouse_down",
6796                 .handler = client_pd_mouse_down, /* pid, pkgname, id, width, height, timestamp, x, y, ret */
6797         },
6798         {
6799                 .cmd = "pd_mouse_up",
6800                 .handler = client_pd_mouse_up, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6801         },
6802         {
6803                 .cmd = "lb_mouse_down",
6804                 .handler = client_lb_mouse_down, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6805         },
6806         {
6807                 .cmd = "lb_mouse_up",
6808                 .handler = client_lb_mouse_up, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6809         },
6810         {
6811                 .cmd = "pd_mouse_enter",
6812                 .handler = client_pd_mouse_enter, /* pid, pkgname, id, width, height, timestamp, x, y, ret */
6813         },
6814         {
6815                 .cmd = "pd_mouse_leave",
6816                 .handler = client_pd_mouse_leave, /* pid, pkgname, id, width, height, timestamp, x, y, ret */
6817         },
6818         {
6819                 .cmd = "lb_mouse_enter",
6820                 .handler = client_lb_mouse_enter, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6821         },
6822         {
6823                 .cmd = "lb_mouse_leave",
6824                 .handler = client_lb_mouse_leave, /* pid, pkgname, filename, width, height, timestamp, x, y, ret */
6825         },
6826         {
6827                 .cmd = "lb_mouse_set",
6828                 .handler = client_lb_mouse_set,
6829         },
6830         {
6831                 .cmd = "lb_mouse_unset",
6832                 .handler = client_lb_mouse_unset,
6833         },
6834         {
6835                 .cmd = "pd_mouse_set",
6836                 .handler = client_pd_mouse_set,
6837         },
6838         {
6839                 .cmd = "pd_mouse_unset",
6840                 .handler = client_pd_mouse_unset,
6841         },
6842         {
6843                 .cmd = "change,visibility",
6844                 .handler = client_change_visibility,
6845         },
6846         {
6847                 .cmd = "lb_acquire_pixmap",
6848                 .handler = client_lb_acquire_pixmap,
6849         },
6850         {
6851                 .cmd = "lb_release_pixmap",
6852                 .handler = client_lb_release_pixmap,
6853         },
6854         {
6855                 .cmd = "pd_acquire_pixmap",
6856                 .handler = client_pd_acquire_pixmap,
6857         },
6858         {
6859                 .cmd = "pd_release_pixmap",
6860                 .handler = client_pd_release_pixmap,
6861         },
6862         {
6863                 .cmd = "acquire",
6864                 .handler = client_acquire, /*!< pid, ret */
6865         },
6866         {
6867                 .cmd = "release",
6868                 .handler = cilent_release, /*!< pid, ret */
6869         },
6870         {
6871                 .cmd = "clicked",
6872                 .handler = client_clicked, /*!< pid, pkgname, filename, event, timestamp, x, y, ret */
6873         },
6874         {
6875                 .cmd = "text_signal",
6876                 .handler = client_text_signal, /* pid, pkgname, filename, emission, source, s, sy, ex, ey, ret */
6877         },
6878         {
6879                 .cmd = "delete",
6880                 .handler = client_delete, /* pid, pkgname, filename, ret */
6881         },
6882         {
6883                 .cmd = "resize",
6884                 .handler = client_resize, /* pid, pkgname, filename, w, h, ret */
6885         },
6886         {
6887                 .cmd = "new",
6888                 .handler = client_new, /* pid, timestamp, pkgname, content, cluster, category, period, ret */
6889         },
6890         {
6891                 .cmd = "set_period",
6892                 .handler = client_set_period, /* pid, pkgname, filename, period, ret, period */
6893         },
6894         {
6895                 .cmd = "change_group",
6896                 .handler = client_change_group, /* pid, pkgname, filename, cluster, category, ret */
6897         },
6898         {
6899                 .cmd = "pinup_changed",
6900                 .handler = client_pinup_changed, /* pid, pkgname, filename, pinup, ret */
6901         },
6902         {
6903                 .cmd = "create_pd",
6904                 .handler = client_create_pd, /* pid, pkgname, filename, ret */
6905         },
6906         {
6907                 .cmd = "pd_move",
6908                 .handler = client_pd_move, /* pkgname, id, x, y */
6909         },
6910         {
6911                 .cmd = "destroy_pd",
6912                 .handler = client_destroy_pd, /* pid, pkgname, filename, ret */
6913         },
6914         {
6915                 .cmd = "activate_package",
6916                 .handler = client_activate_package, /* pid, pkgname, ret */
6917         },
6918         {
6919                 .cmd = "subscribe", /* pid, cluster, sub-cluster */
6920                 .handler = client_subscribed,
6921         },
6922         {
6923                 .cmd = "unsubscribe", /* pid, cluster, sub-cluster */
6924                 .handler = client_unsubscribed,
6925         },
6926         {
6927                 .cmd = "delete_cluster",
6928                 .handler = client_delete_cluster,
6929         },
6930         {
6931                 .cmd = "delete_category",
6932                 .handler = client_delete_category,
6933         },
6934         {
6935                 .cmd = "refresh_group",
6936                 .handler = client_refresh_group,
6937         },
6938         {
6939                 .cmd = "update",
6940                 .handler = client_update,
6941         },
6942
6943         {
6944                 .cmd = "pd_access_hl",
6945                 .handler = client_pd_access_hl,
6946         },
6947         {
6948                 .cmd = "pd_access_hl_prev",
6949                 .handler = client_pd_access_hl_prev,
6950         },
6951         {
6952                 .cmd = "pd_access_hl_next",
6953                 .handler = client_pd_access_hl_next,
6954         },
6955         {
6956                 .cmd = "pd_access_activate",
6957                 .handler = client_pd_access_activate,
6958         },
6959         {
6960                 .cmd = "pd_access_action_up",
6961                 .handler = client_pd_access_action_up,
6962         },
6963         {
6964                 .cmd = "pd_access_action_down",
6965                 .handler = client_pd_access_action_down,
6966         },
6967         {
6968                 .cmd = "pd_access_unhighlight",
6969                 .handler = client_pd_access_unhighlight,
6970         },
6971         {
6972                 .cmd = "pd_access_scroll_down",
6973                 .handler = client_pd_access_scroll_down,
6974         },
6975         {
6976                 .cmd = "pd_access_scroll_move",
6977                 .handler = client_pd_access_scroll_move,
6978         },
6979         {
6980                 .cmd = "pd_access_scroll_up",
6981                 .handler = client_pd_access_scroll_up,
6982         },
6983
6984         {
6985                 .cmd = "lb_access_hl",
6986                 .handler = client_lb_access_hl,
6987         },
6988         {
6989                 .cmd = "lb_access_hl_prev",
6990                 .handler = client_lb_access_hl_prev,
6991         },
6992         {
6993                 .cmd = "lb_access_hl_next",
6994                 .handler = client_lb_access_hl_next,
6995         },
6996         {
6997                 .cmd = "lb_access_activate",
6998                 .handler = client_lb_access_activate,
6999         },
7000         {
7001                 .cmd = "lb_access_action_up",
7002                 .handler = client_lb_access_action_up,
7003         },
7004         {
7005                 .cmd = "lb_access_action_down",
7006                 .handler = client_lb_access_action_down,
7007         },
7008         {
7009                 .cmd = "lb_access_unhighlight",
7010                 .handler = client_lb_access_unhighlight,
7011         },
7012         {
7013                 .cmd = "lb_access_scroll_down",
7014                 .handler = client_lb_access_scroll_down,
7015         },
7016         {
7017                 .cmd = "lb_access_scroll_move",
7018                 .handler = client_lb_access_scroll_move,
7019         },
7020         {
7021                 .cmd = "lb_access_scroll_up",
7022                 .handler = client_lb_access_scroll_up,
7023         },
7024
7025         {
7026                 .cmd = "lb_key_down",
7027                 .handler = client_lb_key_down,
7028         },
7029         {
7030                 .cmd = "lb_key_up",
7031                 .handler = client_lb_key_up,
7032         },
7033
7034         {
7035                 .cmd = "pd_key_down",
7036                 .handler = client_pd_key_down,
7037         },
7038         {
7039                 .cmd = "pd_key_up",
7040                 .handler = client_pd_key_up,
7041         },
7042
7043         {
7044                 .cmd = "client_paused",
7045                 .handler = client_pause_request,
7046         },
7047         {
7048                 .cmd = "client_resumed",
7049                 .handler = client_resume_request,
7050         },
7051
7052         {
7053                 .cmd = "update_mode",
7054                 .handler = client_update_mode,
7055         },
7056
7057         {
7058                 .cmd = NULL,
7059                 .handler = NULL,
7060         },
7061 };
7062
7063 static struct method s_service_table[] = {
7064         {
7065                 .cmd = "service_update",
7066                 .handler = service_update,
7067         },
7068         {
7069                 .cmd = "service_change_period",
7070                 .handler = service_change_period,
7071         },
7072         {
7073                 .cmd = NULL,
7074                 .handler = NULL,
7075         },
7076 };
7077
7078 static struct method s_slave_table[] = {
7079         {
7080                 .cmd = "call",
7081                 .handler = slave_call, /* slave_name, pkgname, filename, function, ret */
7082         },
7083         {
7084                 .cmd = "ret",
7085                 .handler = slave_ret, /* slave_name, pkgname, filename, function, ret */
7086         },
7087         {
7088                 .cmd = "updated",
7089                 .handler = slave_updated, /* slave_name, pkgname, filename, width, height, priority, ret */
7090         },
7091         {
7092                 .cmd = "desc_updated",
7093                 .handler = slave_desc_updated, /* slave_name, pkgname, filename, decsfile, ret */
7094         },
7095         {
7096                 .cmd = "deleted",
7097                 .handler = slave_deleted, /* slave_name, pkgname, filename, ret */
7098         },
7099         {
7100                 .cmd = "acquire_buffer",
7101                 .handler = slave_acquire_buffer, /* slave_name, id, w, h, size, - out - type, shmid */
7102         },
7103         {
7104                 .cmd = "resize_buffer",
7105                 .handler = slave_resize_buffer,
7106         },
7107         {
7108                 .cmd = "release_buffer",
7109                 .handler = slave_release_buffer, /* slave_name, id - ret */
7110         },
7111         {
7112                 .cmd = "faulted",
7113                 .handler = slave_faulted, /* slave_name, pkgname, id, funcname */
7114         },
7115         {
7116                 .cmd = "scroll",
7117                 .handler = slave_hold_scroll, /* slave_name, pkgname, id, seize */
7118         },
7119
7120         {
7121                 .cmd = "lb_update_begin",
7122                 .handler = slave_lb_update_begin,
7123         },
7124         {
7125                 .cmd = "lb_update_end",
7126                 .handler = slave_lb_update_end,
7127         },
7128         {
7129                 .cmd = "pd_update_begin",
7130                 .handler = slave_pd_update_begin,
7131         },
7132         {
7133                 .cmd = "pd_update_end",
7134                 .handler = slave_pd_update_end,
7135         },
7136
7137         {
7138                 .cmd = "access_status",
7139                 .handler = slave_access_status,
7140         },
7141
7142         {
7143                 .cmd = "hello",
7144                 .handler = slave_hello, /* slave_name, ret */
7145         },
7146         {
7147                 .cmd = "ping",
7148                 .handler = slave_ping, /* slave_name, ret */
7149         },
7150
7151         {
7152                 .cmd = NULL,
7153                 .handler = NULL,
7154         },
7155 };
7156
7157 HAPI int server_init(void)
7158 {
7159         com_core_packet_use_thread(COM_CORE_THREAD);
7160
7161         if (unlink(INFO_SOCKET) < 0)
7162                 ErrPrint("info socket: %s\n", strerror(errno));
7163
7164         if (unlink(SLAVE_SOCKET) < 0)
7165                 ErrPrint("slave socket: %s\n", strerror(errno));
7166
7167         if (unlink(CLIENT_SOCKET) < 0)
7168                 ErrPrint("client socket: %s\n", strerror(errno));
7169
7170         if (unlink(SERVICE_SOCKET) < 0)
7171                 ErrPrint("service socket: %s\n", strerror(errno));
7172
7173         s_info.info_fd = com_core_packet_server_init(INFO_SOCKET, s_info_table);
7174         if (s_info.info_fd < 0)
7175                 ErrPrint("Failed to create a info socket\n");
7176
7177         s_info.slave_fd = com_core_packet_server_init(SLAVE_SOCKET, s_slave_table);
7178         if (s_info.slave_fd < 0)
7179                 ErrPrint("Failed to create a slave socket\n");
7180
7181         s_info.client_fd = com_core_packet_server_init(CLIENT_SOCKET, s_client_table);
7182         if (s_info.client_fd < 0)
7183                 ErrPrint("Failed to create a client socket\n");
7184
7185         s_info.service_fd = com_core_packet_server_init(SERVICE_SOCKET, s_service_table);
7186         if (s_info.service_fd < 0)
7187                 ErrPrint("Faild to create a service socket\n");
7188
7189         if (chmod(INFO_SOCKET, 0600) < 0)
7190                 ErrPrint("info socket: %s\n", strerror(errno));
7191
7192         if (chmod(SLAVE_SOCKET, 0666) < 0)
7193                 ErrPrint("slave socket: %s\n", strerror(errno));
7194
7195         if (chmod(CLIENT_SOCKET, 0666) < 0)
7196                 ErrPrint("client socket: %s\n", strerror(errno));
7197
7198         if (chmod(SERVICE_SOCKET, 0666) < 0)
7199                 ErrPrint("service socket: %s\n", strerror(errno));
7200
7201         return 0;
7202 }
7203
7204 HAPI int server_fini(void)
7205 {
7206         if (s_info.info_fd > 0) {
7207                 com_core_packet_server_fini(s_info.info_fd);
7208                 s_info.info_fd = -1;
7209         }
7210
7211         if (s_info.slave_fd > 0) {
7212                 com_core_packet_server_fini(s_info.slave_fd);
7213                 s_info.slave_fd = -1;
7214         }
7215
7216         if (s_info.client_fd > 0) {
7217                 com_core_packet_server_fini(s_info.client_fd);
7218                 s_info.client_fd = -1;
7219         }
7220
7221         if (s_info.service_fd > 0) {
7222                 com_core_packet_server_fini(s_info.service_fd);
7223                 s_info.service_fd = -1;
7224         }
7225
7226         return 0;
7227 }
7228
7229 /* End of a file */