src/server.c

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