src/notification_ipc.c

   1 /*
   2  *  libnotification
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Seungtaek Chung <seungtaek.chung@samsung.com>, Mi-Ju Lee <miju52.lee@samsung.com>, Xi Zhichan <zhichan.xi@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <stdlib.h>
  25 #include <errno.h>
  26
  27 #include <vconf.h>
  28
  29 #include <packet.h>
  30 #include <com-core.h>
  31 #include <com-core_packet.h>
  32
  33 #include <notification_ipc.h>
  34 #include <notification_db.h>
  35 #include <notification_type.h>
  36 #include <notification_private.h>
  37 #include <notification_debug.h>
  38 #include <notification_setting_internal.h>
  39
  40 #define NOTIFICATION_IPC_TIMEOUT 0.0
  41
  42 #if !defined(VCONFKEY_MASTER_STARTED)
  43 #define VCONFKEY_MASTER_STARTED "memory/data-provider-master/started"
  44 #endif
  45
  46 static struct info {
  47         int server_fd;
  48         int server_cl_fd;
  49         int server_cl_fd_ref_cnt;
  50         int client_fd;
  51         const char *socket_file;
  52         struct {
  53                 int (*request_cb)(const char *appid, const char *name, int type, const char *content, const char *icon, pid_t pid, double period, int allow_duplicate, void *data);
  54                 void *data;
  55         } server_cb;
  56         int initialized;
  57         int is_started_cb_set_svc;
  58         int is_started_cb_set_task;
  59 } s_info = {
  60         .server_fd = -1,
  61         .server_cl_fd = -1,
  62         .server_cl_fd_ref_cnt = 0,
  63         .client_fd = -1,
  64         .socket_file = NOTIFICATION_ADDR,
  65         .initialized = 0,
  66         .is_started_cb_set_svc = 0,
  67         .is_started_cb_set_task = 0,
  68 };
  69
  70 typedef struct _task_list task_list;
  71 struct _task_list {
  72         task_list *prev;
  73         task_list *next;
  74
  75         void (*task_cb) (void *data);
  76         void *data;
  77 };
  78
  79 typedef struct _result_cb_item {
  80         void (*result_cb)(int priv_id, int result, void *data);
  81         void *data;
  82 } result_cb_item;
  83
  84 static task_list *g_task_list;
  85
  86 static int notification_ipc_monitor_register(void);
  87 static int notification_ipc_monitor_deregister(void);
  88 static void _do_deffered_task(void);
  89 static void _master_started_cb_task(keynode_t *node, void *data);
  90
  91 static inline char *_string_get(char *string)
  92 {
  93         if (string == NULL) {
  94                 return NULL;
  95         }
  96         if (string[0] == '\0') {
  97                 return NULL;
  98         }
  99
 100         return string;
 101 }
 102
 103 /*!
 104  * functions to check state of master
 105  */
 106 static inline void _set_master_started_cb(vconf_callback_fn cb) {
 107         int ret = -1;
 108
 109         ret = vconf_notify_key_changed(VCONFKEY_MASTER_STARTED,
 110                         cb, NULL);
 111         if (ret != 0) {
 112                 NOTIFICATION_ERR("failed to notify key(%s) : %d",
 113                                 VCONFKEY_MASTER_STARTED, ret);
 114         }
 115 }
 116
 117 static inline void _unset_master_started_cb(vconf_callback_fn cb) {
 118         int ret = -1;
 119
 120         ret = vconf_ignore_key_changed(VCONFKEY_MASTER_STARTED,
 121                         cb);
 122         if (ret != 0) {
 123                 NOTIFICATION_ERR("failed to notify key(%s) : %d",
 124                                 VCONFKEY_MASTER_STARTED, ret);
 125         }
 126 }
 127
 128 int notification_ipc_is_master_ready(void)
 129 {
 130         int ret = -1, is_master_started = 0;
 131
 132         ret = vconf_get_bool(VCONFKEY_MASTER_STARTED, &is_master_started);
 133         if (ret == 0 && is_master_started == 1) {
 134                 NOTIFICATION_ERR("the master has been started");
 135         } else {
 136                 is_master_started = 0;
 137                 NOTIFICATION_ERR("the master has been stopped");
 138         }
 139
 140         return is_master_started;
 141 }
 142
 143 int
 144 notification_ipc_add_deffered_task(
 145                 void (*deferred_task_cb)(void *data),
 146                 void *user_data)
 147 {
 148         task_list *list = NULL;
 149         task_list *list_new = NULL;
 150
 151         list_new =
 152             (task_list *) malloc(sizeof(task_list));
 153
 154         if (list_new == NULL) {
 155                 return NOTIFICATION_ERROR_OUT_OF_MEMORY;
 156         }
 157
 158         if (s_info.is_started_cb_set_task == 0) {
 159                 _set_master_started_cb(_master_started_cb_task);
 160                 s_info.is_started_cb_set_task = 1;
 161         }
 162
 163         list_new->next = NULL;
 164         list_new->prev = NULL;
 165
 166         list_new->task_cb = deferred_task_cb;
 167         list_new->data = user_data;
 168
 169         if (g_task_list == NULL) {
 170                 g_task_list = list_new;
 171         } else {
 172                 list = g_task_list;
 173
 174                 while (list->next != NULL) {
 175                         list = list->next;
 176                 }
 177
 178                 list->next = list_new;
 179                 list_new->prev = list;
 180         }
 181         return NOTIFICATION_ERROR_NONE;
 182 }
 183
 184 int
 185 notification_ipc_del_deffered_task(
 186                 void (*deferred_task_cb)(void *data))
 187 {
 188         task_list *list_del = NULL;
 189         task_list *list_prev = NULL;
 190         task_list *list_next = NULL;
 191
 192         list_del = g_task_list;
 193
 194         if (list_del == NULL) {
 195                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
 196         }
 197
 198         while (list_del->prev != NULL) {
 199                 list_del = list_del->prev;
 200         }
 201
 202         do {
 203                 if (list_del->task_cb == deferred_task_cb) {
 204                         list_prev = list_del->prev;
 205                         list_next = list_del->next;
 206
 207                         if (list_prev == NULL) {
 208                                 g_task_list = list_next;
 209                         } else {
 210                                 list_prev->next = list_next;
 211                         }
 212
 213                         if (list_next == NULL) {
 214                                 if (list_prev != NULL) {
 215                                         list_prev->next = NULL;
 216                                 }
 217                         } else {
 218                                 list_next->prev = list_prev;
 219                         }
 220
 221                         free(list_del);
 222
 223                         if (g_task_list == NULL) {
 224                                 if (s_info.is_started_cb_set_task == 1) {
 225                                         _unset_master_started_cb(_master_started_cb_task);
 226                                         s_info.is_started_cb_set_task = 0;
 227                                 }
 228                         }
 229
 230                         return NOTIFICATION_ERROR_NONE;
 231                 }
 232                 list_del = list_del->next;
 233         } while (list_del != NULL);
 234
 235         return NOTIFICATION_ERROR_INVALID_PARAMETER;
 236 }
 237
 238 static void _do_deffered_task(void) {
 239         task_list *list_do = NULL;
 240         task_list *list_temp = NULL;
 241
 242         if (g_task_list == NULL) {
 243                 return;
 244         }
 245
 246         list_do = g_task_list;
 247         g_task_list = NULL;
 248         if (s_info.is_started_cb_set_task == 1) {
 249                 _unset_master_started_cb(_master_started_cb_task);
 250                 s_info.is_started_cb_set_task = 0;
 251         }
 252
 253         while (list_do->prev != NULL) {
 254                 list_do = list_do->prev;
 255         }
 256
 257         while (list_do != NULL) {
 258                 if (list_do->task_cb != NULL) {
 259                         list_do->task_cb(list_do->data);
 260                         NOTIFICATION_DBG("called:%p", list_do->task_cb);
 261                 }
 262                 list_temp = list_do->next;
 263                 free(list_do);
 264                 list_do = list_temp;
 265         }
 266 }
 267
 268 static void _master_started_cb_service(keynode_t *node,
 269                 void *data) {
 270         int ret = NOTIFICATION_ERROR_NONE;
 271
 272         if (notification_ipc_is_master_ready()) {
 273                 NOTIFICATION_ERR("try to register a notification service");
 274                 ret = notification_ipc_monitor_deregister();
 275                 if (ret != NOTIFICATION_ERROR_NONE) {
 276                         NOTIFICATION_ERR("failed to unregister a monitor");
 277                 }
 278                 ret = notification_ipc_monitor_register();
 279                 if (ret != NOTIFICATION_ERROR_NONE) {
 280                         NOTIFICATION_ERR("failed to register a monitor");
 281                 }
 282         } else {
 283                 NOTIFICATION_ERR("try to unregister a notification service");
 284                 ret = notification_ipc_monitor_deregister();
 285                 if (ret != NOTIFICATION_ERROR_NONE) {
 286                         NOTIFICATION_ERR("failed to deregister a monitor");
 287                 }
 288         }
 289 }
 290
 291 static void _master_started_cb_task(keynode_t *node,
 292                 void *data) {
 293
 294         if (notification_ipc_is_master_ready()) {
 295                 _do_deffered_task();
 296         }
 297 }
 298
 299 /*!
 300  * functions to create operation list
 301  */
 302 notification_op *notification_ipc_create_op(notification_op_type_e type, int num_op, int *list_priv_id, int num_priv_id, notification_h *noti_list)
 303 {
 304         int i = 0;
 305         notification_op *op_list = NULL;
 306
 307         if (num_op <= 0) {
 308                 return NULL;
 309         }
 310
 311         op_list = (notification_op *)malloc(sizeof(notification_op) * num_op);
 312         memset(op_list, 0x0, sizeof(notification_op) * num_op);
 313
 314         for (i = 0; i < num_op; i++) {
 315                 (op_list + i)->type = type;
 316                 if (list_priv_id != NULL) {
 317                         (op_list + i)->priv_id = *(list_priv_id + i);
 318                 }
 319                 if (noti_list != NULL) {
 320                         (op_list + i)->noti = *(noti_list + i);
 321                 }
 322         }
 323
 324         return op_list;
 325 }
 326
 327 /*!
 328  * utility functions creating notification packet
 329  */
 330 static inline char *_dup_string(const char *string)
 331 {
 332         char *ret;
 333
 334         if (string == NULL) {
 335                 return NULL;
 336         }
 337         if (string[0] == '\0') {
 338                 return NULL;
 339         }
 340
 341         ret = strdup(string);
 342         if (!ret)
 343                 NOTIFICATION_ERR("Error: %s\n", strerror(errno));
 344
 345         return ret;
 346 }
 347
 348 static inline bundle *_create_bundle_from_string(unsigned char *string)
 349 {
 350         if (string == NULL) {
 351                 return NULL;
 352         }
 353         if (string[0] == '\0') {
 354                 return NULL;
 355         }
 356
 357         return bundle_decode(string, strlen((char *)string));
 358 }
 359
 360 /*!
 361  * functions creating notification packet
 362  */
 363 EXPORT_API int notification_ipc_make_noti_from_packet(notification_h noti, const struct packet *packet)
 364 {
 365         int i = 0;
 366         int ret = 0;
 367         int type;
 368         int layout;
 369         int group_id;
 370         int internal_group_id;
 371         int priv_id;
 372         char *caller_pkgname = NULL;
 373         char *launch_pkgname = NULL;
 374         unsigned char *args = NULL;
 375         unsigned char *group_args = NULL;
 376         unsigned char *b_execute_option = NULL;
 377         unsigned char *b_service_responding = NULL;
 378         unsigned char *b_service_single_launch = NULL;
 379         unsigned char *b_service_multi_launch = NULL;
 380         unsigned char *b_event_handler[NOTIFICATION_EVENT_TYPE_MAX] = { NULL, };
 381         char *domain = NULL;
 382         char *dir = NULL;
 383         unsigned char *b_text = NULL;
 384         unsigned char *b_key = NULL;
 385         unsigned char *b_format_args = NULL;
 386         int num_format_args;
 387         unsigned char *b_image_path = NULL;
 388         int sound_type;
 389         char *sound_path = NULL;
 390         int vibration_type;
 391         char *vibration_path = NULL;
 392         int led_operation;
 393         int led_argb;
 394         int led_on_ms;
 395         int led_off_ms;
 396         time_t time;
 397         time_t insert_time;
 398         int flags_for_property;
 399         int display_applist;
 400         double progress_size;
 401         double progress_percentage;
 402         char *app_icon_path = NULL;
 403         char *app_name = NULL;
 404         char *temp_title = NULL;
 405         char *temp_content = NULL;
 406         char *tag = NULL;
 407
 408         if (noti == NULL) {
 409                 NOTIFICATION_ERR("invalid data");
 410                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
 411         }
 412
 413         ret = packet_get(packet,
 414                         "iiiiisssssssssssssssssssssisisisiiiiiiiiddsssss",
 415                         &type,
 416                         &layout,
 417                         &group_id,
 418                         &internal_group_id,
 419                         &priv_id,
 420                         &caller_pkgname,
 421                         &launch_pkgname,
 422                         &args,
 423                         &group_args,
 424                         &b_execute_option,
 425                         &b_service_responding,
 426                         &b_service_single_launch,
 427                         &b_service_multi_launch,
 428                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1],
 429                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_2],
 430                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_3],
 431                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_4],
 432                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_5],
 433                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_6],
 434                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_ICON],
 435                         &b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_THUMBNAIL],
 436                         &domain,
 437                         &dir,
 438                         &b_text,
 439                         &b_key,
 440                         &b_format_args,
 441                         &num_format_args,
 442                         &b_image_path,
 443                         &sound_type,
 444                         &sound_path,
 445                         &vibration_type,
 446                         &vibration_path,
 447                         &led_operation,
 448                         &led_argb,
 449                         &led_on_ms,
 450                         &led_off_ms,
 451                         &time,
 452                         &insert_time,
 453                         &flags_for_property,
 454                         &display_applist,
 455                         &progress_size,
 456                         &progress_percentage,
 457                         &app_icon_path,
 458                         &app_name,
 459                         &temp_title,
 460                         &temp_content,
 461                         &tag);
 462
 463         if (ret != 47) {
 464                 NOTIFICATION_ERR("failed to create a noti from packet");
 465                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
 466         }
 467
 468         /*!
 469          * This is already allocated from the notification_create function.
 470          * Before reallocate string to here.
 471          * We have to release old one first.
 472          */
 473         free(noti->caller_pkgname);
 474         noti->caller_pkgname = _dup_string(caller_pkgname);
 475         noti->launch_pkgname = _dup_string(launch_pkgname);
 476         noti->args = _create_bundle_from_string(args);
 477         noti->group_args = _create_bundle_from_string(group_args);
 478         noti->b_execute_option = _create_bundle_from_string(b_execute_option);
 479         noti->b_service_responding = _create_bundle_from_string(b_service_responding);
 480         noti->b_service_single_launch = _create_bundle_from_string(b_service_single_launch);
 481         noti->b_service_multi_launch = _create_bundle_from_string(b_service_multi_launch);
 482         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
 483                 noti->b_event_handler[i] = _create_bundle_from_string(b_event_handler[i]);
 484         }
 485         noti->domain = _dup_string(domain);
 486         noti->dir = _dup_string(dir);
 487         noti->b_text = _create_bundle_from_string(b_text);
 488         noti->b_key = _create_bundle_from_string(b_key);
 489         noti->b_format_args = _create_bundle_from_string(b_format_args);
 490         noti->b_image_path = _create_bundle_from_string(b_image_path);
 491         noti->sound_path = _dup_string(sound_path);
 492         noti->vibration_path = _dup_string(vibration_path);
 493         noti->app_icon_path = _dup_string(app_icon_path);
 494         noti->app_name = _dup_string(app_name);
 495         noti->temp_title = _dup_string(temp_title);
 496         noti->temp_content = _dup_string(temp_content);
 497
 498         noti->type = type;
 499         noti->layout = layout;
 500         noti->group_id = group_id;
 501         noti->internal_group_id = internal_group_id;
 502         noti->priv_id = priv_id;
 503         noti->num_format_args = num_format_args;
 504         noti->sound_type = sound_type;
 505         noti->vibration_type = vibration_type;
 506         noti->led_operation = led_operation;
 507         noti->led_argb = led_argb;
 508         noti->led_on_ms = led_on_ms;
 509         noti->led_off_ms = led_off_ms;
 510         noti->time = time;
 511         noti->insert_time = insert_time;
 512         noti->flags_for_property = flags_for_property;
 513         noti->display_applist = display_applist;
 514         noti->progress_size = progress_size;
 515         noti->progress_percentage = progress_percentage;
 516         noti->tag = _dup_string(tag);
 517
 518         return NOTIFICATION_ERROR_NONE;
 519 }
 520
 521 EXPORT_API struct packet *notification_ipc_make_packet_from_noti(notification_h noti, const char *command, int packet_type)
 522 {
 523         int i = 0;
 524         int b_encode_len = 0;
 525         struct packet *result = NULL;
 526         char *args = NULL;
 527         char *group_args = NULL;
 528         char *b_image_path = NULL;
 529         char *b_execute_option = NULL;
 530         char *b_service_responding = NULL;
 531         char *b_service_single_launch = NULL;
 532         char *b_service_multi_launch = NULL;
 533         char *b_event_handler[NOTIFICATION_EVENT_TYPE_MAX] = { NULL , };
 534         char *b_text = NULL;
 535         char *b_key = NULL;
 536         char *b_format_args = NULL;
 537         struct packet *(*func_to_create_packet)(const char *command, const char *fmt, ...);
 538         const char *title_key = NULL;
 539         char buf_key[32] = { 0, };
 540
 541         /* Decode bundle to insert DB */
 542         if (noti->args) {
 543                 bundle_encode(noti->args, (bundle_raw **) & args, NULL);
 544         }
 545         if (noti->group_args) {
 546                 bundle_encode(noti->group_args, (bundle_raw **) & group_args,
 547                               &b_encode_len);
 548         }
 549
 550         if (noti->b_execute_option) {
 551                 bundle_encode(noti->b_execute_option,
 552                               (bundle_raw **) & b_execute_option, &b_encode_len);
 553         }
 554         if (noti->b_service_responding) {
 555                 bundle_encode(noti->b_service_responding,
 556                               (bundle_raw **) & b_service_responding, &b_encode_len);
 557         }
 558         if (noti->b_service_single_launch) {
 559                 bundle_encode(noti->b_service_single_launch,
 560                               (bundle_raw **) & b_service_single_launch, &b_encode_len);
 561         }
 562         if (noti->b_service_multi_launch) {
 563                 bundle_encode(noti->b_service_multi_launch,
 564                               (bundle_raw **) & b_service_multi_launch, &b_encode_len);
 565         }
 566
 567         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
 568                 if (noti->b_event_handler[i]) {
 569                         bundle_encode(noti->b_event_handler[i],
 570                                         (bundle_raw **) & b_event_handler[i], &b_encode_len);
 571                 }
 572         }
 573
 574         if (noti->b_text) {
 575                 bundle_encode(noti->b_text, (bundle_raw **) & b_text, &b_encode_len);
 576         }
 577         if (noti->b_key) {
 578                 bundle_encode(noti->b_key, (bundle_raw **) & b_key, &b_encode_len);
 579         }
 580         if (noti->b_format_args) {
 581                 bundle_encode(noti->b_format_args,
 582                               (bundle_raw **) & b_format_args, &b_encode_len);
 583         }
 584
 585         if (noti->b_image_path) {
 586                 bundle_encode(noti->b_image_path,
 587                               (bundle_raw **) & b_image_path, &b_encode_len);
 588         }
 589
 590         if (noti->b_key != NULL) {
 591                 snprintf(buf_key, sizeof(buf_key), "%d",
 592                          NOTIFICATION_TEXT_TYPE_TITLE);
 593
 594                 title_key = bundle_get_val(noti->b_key, buf_key);
 595         }
 596
 597         if (title_key == NULL && noti->b_text != NULL) {
 598                 snprintf(buf_key, sizeof(buf_key), "%d",
 599                          NOTIFICATION_TEXT_TYPE_TITLE);
 600
 601                 title_key = bundle_get_val(noti->b_text, buf_key);
 602         }
 603
 604         if (title_key == NULL) {
 605                 title_key = noti->caller_pkgname;
 606         }
 607
 608         if (packet_type == 1)
 609                 func_to_create_packet = packet_create;
 610         else if (packet_type == 2)
 611                 func_to_create_packet = packet_create_noack;
 612         else {
 613                 goto out;
 614         }
 615
 616         result = func_to_create_packet(command,
 617                         "iiiiisssssssssssssssssssssisisisiiiiiiiiddsssss",
 618                         noti->type,
 619                         noti->layout,
 620                         noti->group_id,
 621                         noti->internal_group_id,
 622                         noti->priv_id,
 623                         NOTIFICATION_CHECK_STR(noti->caller_pkgname),
 624                         NOTIFICATION_CHECK_STR(noti->launch_pkgname),
 625                         NOTIFICATION_CHECK_STR(args),
 626                         NOTIFICATION_CHECK_STR(group_args),
 627                         NOTIFICATION_CHECK_STR(b_execute_option),
 628                         NOTIFICATION_CHECK_STR(b_service_responding),
 629                         NOTIFICATION_CHECK_STR(b_service_single_launch),
 630                         NOTIFICATION_CHECK_STR(b_service_multi_launch),
 631                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1]),
 632                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_2]),
 633                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_3]),
 634                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_4]),
 635                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_5]),
 636                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_6]),
 637                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_ICON]),
 638                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_THUMBNAIL]),
 639                         NOTIFICATION_CHECK_STR(noti->domain),
 640                         NOTIFICATION_CHECK_STR(noti->dir),
 641                         NOTIFICATION_CHECK_STR(b_text),
 642                         NOTIFICATION_CHECK_STR(b_key),
 643                         NOTIFICATION_CHECK_STR(b_format_args),
 644                         noti->num_format_args,
 645                         NOTIFICATION_CHECK_STR(b_image_path),
 646                         noti->sound_type,
 647                         NOTIFICATION_CHECK_STR(noti->sound_path),
 648                         noti->vibration_type,
 649                         NOTIFICATION_CHECK_STR(noti->vibration_path),
 650                         noti->led_operation,
 651                         noti->led_argb,
 652                         noti->led_on_ms,
 653                         noti->led_off_ms,
 654                         noti->time,
 655                         noti->insert_time,
 656                         noti->flags_for_property,
 657                         noti->display_applist,
 658                         noti->progress_size,
 659                         noti->progress_percentage,
 660                         NOTIFICATION_CHECK_STR(noti->app_icon_path),
 661                         NOTIFICATION_CHECK_STR(noti->app_name),
 662                         NOTIFICATION_CHECK_STR(noti->temp_title),
 663                         NOTIFICATION_CHECK_STR(noti->temp_content),
 664                         NOTIFICATION_CHECK_STR(noti->tag));
 665
 666 out:
 667         /* Free decoded data */
 668         if (args) {
 669                 free(args);
 670         }
 671         if (group_args) {
 672                 free(group_args);
 673         }
 674
 675         if (b_execute_option) {
 676                 free(b_execute_option);
 677         }
 678         if (b_service_responding) {
 679                 free(b_service_responding);
 680         }
 681         if (b_service_single_launch) {
 682                 free(b_service_single_launch);
 683         }
 684         if (b_service_multi_launch) {
 685                 free(b_service_multi_launch);
 686         }
 687
 688         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
 689                 if (b_event_handler[i]) {
 690                         free(b_event_handler[i]);
 691                 }
 692         }
 693
 694         if (b_text) {
 695                 free(b_text);
 696         }
 697         if (b_key) {
 698                 free(b_key);
 699         }
 700         if (b_format_args) {
 701                 free(b_format_args);
 702         }
 703
 704         if (b_image_path) {
 705                 free(b_image_path);
 706         }
 707
 708         return result;
 709 }
 710
 711 EXPORT_API struct packet *notification_ipc_make_reply_packet_from_noti(notification_h noti, struct packet *packet)
 712 {
 713         int i = 0;
 714         int b_encode_len = 0;
 715         struct packet *result = NULL;
 716         char *args = NULL;
 717         char *group_args = NULL;
 718         char *b_image_path = NULL;
 719         char *b_execute_option = NULL;
 720         char *b_service_responding = NULL;
 721         char *b_service_single_launch = NULL;
 722         char *b_service_multi_launch = NULL;
 723         char *b_event_handler[NOTIFICATION_EVENT_TYPE_MAX] = { NULL , };
 724         char *b_text = NULL;
 725         char *b_key = NULL;
 726         char *b_format_args = NULL;
 727         const char *title_key = NULL;
 728         char buf_key[32] = { 0, };
 729
 730         /* Decode bundle to insert DB */
 731         if (noti->args) {
 732                 bundle_encode(noti->args, (bundle_raw **) & args, &b_encode_len);
 733         }
 734         if (noti->group_args) {
 735                 bundle_encode(noti->group_args, (bundle_raw **) & group_args,
 736                               &b_encode_len);
 737         }
 738
 739         if (noti->b_execute_option) {
 740                 bundle_encode(noti->b_execute_option,
 741                               (bundle_raw **) & b_execute_option, &b_encode_len);
 742         }
 743         if (noti->b_service_responding) {
 744                 bundle_encode(noti->b_service_responding,
 745                               (bundle_raw **) & b_service_responding, &b_encode_len);
 746         }
 747         if (noti->b_service_single_launch) {
 748                 bundle_encode(noti->b_service_single_launch,
 749                               (bundle_raw **) & b_service_single_launch, &b_encode_len);
 750         }
 751         if (noti->b_service_multi_launch) {
 752                 bundle_encode(noti->b_service_multi_launch,
 753                               (bundle_raw **) & b_service_multi_launch, &b_encode_len);
 754         }
 755
 756         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
 757                 if (noti->b_event_handler[i]) {
 758                         bundle_encode(noti->b_event_handler[i],
 759                                         (bundle_raw **) & b_event_handler[i], &b_encode_len);
 760                 }
 761         }
 762
 763         if (noti->b_text) {
 764                 bundle_encode(noti->b_text, (bundle_raw **) & b_text, &b_encode_len);
 765         }
 766         if (noti->b_key) {
 767                 bundle_encode(noti->b_key, (bundle_raw **) & b_key, &b_encode_len);
 768         }
 769         if (noti->b_format_args) {
 770                 bundle_encode(noti->b_format_args,
 771                               (bundle_raw **) & b_format_args, &b_encode_len);
 772         }
 773
 774         if (noti->b_image_path) {
 775                 bundle_encode(noti->b_image_path,
 776                               (bundle_raw **) & b_image_path, &b_encode_len);
 777         }
 778
 779         if (noti->b_key != NULL) {
 780                 snprintf(buf_key, sizeof(buf_key), "%d",
 781                          NOTIFICATION_TEXT_TYPE_TITLE);
 782
 783                 title_key = bundle_get_val(noti->b_key, buf_key);
 784         }
 785
 786         if (title_key == NULL && noti->b_text != NULL) {
 787                 snprintf(buf_key, sizeof(buf_key), "%d",
 788                          NOTIFICATION_TEXT_TYPE_TITLE);
 789
 790                 title_key = bundle_get_val(noti->b_text, buf_key);
 791         }
 792
 793         if (title_key == NULL) {
 794                 title_key = noti->caller_pkgname;
 795         }
 796
 797         result = packet_create_reply(packet,
 798                         "iiiiisssssssssssssssssssssisisisiiiiiiiiddsssss",
 799                         noti->type,
 800                         noti->layout,
 801                         noti->group_id,
 802                         noti->internal_group_id,
 803                         noti->priv_id,
 804                         NOTIFICATION_CHECK_STR(noti->caller_pkgname),
 805                         NOTIFICATION_CHECK_STR(noti->launch_pkgname),
 806                         NOTIFICATION_CHECK_STR(args),
 807                         NOTIFICATION_CHECK_STR(group_args),
 808                         NOTIFICATION_CHECK_STR(b_execute_option),
 809                         NOTIFICATION_CHECK_STR(b_service_responding),
 810                         NOTIFICATION_CHECK_STR(b_service_single_launch),
 811                         NOTIFICATION_CHECK_STR(b_service_multi_launch),
 812                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_1]),
 813                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_2]),
 814                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_3]),
 815                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_4]),
 816                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_5]),
 817                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_BUTTON_6]),
 818                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_ICON]),
 819                         NOTIFICATION_CHECK_STR(b_event_handler[NOTIFICATION_EVENT_TYPE_CLICK_ON_THUMBNAIL]),
 820                         NOTIFICATION_CHECK_STR(noti->domain),
 821                         NOTIFICATION_CHECK_STR(noti->dir),
 822                         NOTIFICATION_CHECK_STR(b_text),
 823                         NOTIFICATION_CHECK_STR(b_key),
 824                         NOTIFICATION_CHECK_STR(b_format_args),
 825                         noti->num_format_args,
 826                         NOTIFICATION_CHECK_STR(b_image_path),
 827                         noti->sound_type,
 828                         NOTIFICATION_CHECK_STR(noti->sound_path),
 829                         noti->vibration_type,
 830                         NOTIFICATION_CHECK_STR(noti->vibration_path),
 831                         noti->led_operation,
 832                         noti->led_argb,
 833                         noti->led_on_ms,
 834                         noti->led_off_ms,
 835                         noti->time,
 836                         noti->insert_time,
 837                         noti->flags_for_property,
 838                         noti->display_applist,
 839                         noti->progress_size,
 840                         noti->progress_percentage,
 841                         NOTIFICATION_CHECK_STR(noti->app_icon_path),
 842                         NOTIFICATION_CHECK_STR(noti->app_name),
 843                         NOTIFICATION_CHECK_STR(noti->temp_title),
 844                         NOTIFICATION_CHECK_STR(noti->temp_content),
 845                         NOTIFICATION_CHECK_STR(noti->tag));
 846
 847         /* Free decoded data */
 848         if (args) {
 849                 free(args);
 850         }
 851         if (group_args) {
 852                 free(group_args);
 853         }
 854
 855         if (b_execute_option) {
 856                 free(b_execute_option);
 857         }
 858         if (b_service_responding) {
 859                 free(b_service_responding);
 860         }
 861         if (b_service_single_launch) {
 862                 free(b_service_single_launch);
 863         }
 864         if (b_service_multi_launch) {
 865                 free(b_service_multi_launch);
 866         }
 867
 868         for (i = 0; i < NOTIFICATION_EVENT_TYPE_MAX; i++) {
 869                 if (b_event_handler[i]) {
 870                         free(b_event_handler[i]);
 871                 }
 872         }
 873
 874         if (b_text) {
 875                 free(b_text);
 876         }
 877         if (b_key) {
 878                 free(b_key);
 879         }
 880         if (b_format_args) {
 881                 free(b_format_args);
 882         }
 883
 884         if (b_image_path) {
 885                 free(b_image_path);
 886         }
 887
 888         return result;
 889 }
 890
 891 /*!
 892  * functions to handler services
 893  */
 894 static struct packet *_handler_insert(pid_t pid, int handle, const struct packet *packet)
 895 {
 896         notification_h noti = NULL;
 897
 898         if (!packet) {
 899                 NOTIFICATION_ERR("a packet is null");
 900                 return NULL;
 901         }
 902         noti = notification_create(NOTIFICATION_TYPE_NOTI);
 903         if (!noti) {
 904                 NOTIFICATION_ERR("failed to create a notification");
 905                 return NULL;
 906         }
 907         notification_ipc_make_noti_from_packet(noti, packet);
 908
 909         if (noti->flags_for_property
 910                 & NOTIFICATION_PROP_DISABLE_UPDATE_ON_INSERT) {
 911                 /* Disable changed cb */
 912         } else {
 913                 /* Enable changed cb */
 914                 notification_op *noti_op = notification_ipc_create_op(NOTIFICATION_OP_INSERT, 1, &(noti->priv_id), 1, &noti);
 915                 if (noti_op != NULL) {
 916                         notification_call_changed_cb(noti_op, 1);
 917                         free(noti_op);
 918                 }
 919         }
 920         notification_free(noti);
 921
 922         return NULL;
 923 }
 924
 925 static struct packet *_handler_update(pid_t pid, int handle, const struct packet *packet)
 926 {
 927         notification_h noti = NULL;
 928
 929         if (!packet) {
 930                 NOTIFICATION_ERR("a packet is null");
 931                 return NULL;
 932         }
 933
 934         noti = notification_create(NOTIFICATION_TYPE_NOTI);
 935         if (!noti) {
 936                 NOTIFICATION_ERR("failed to create a notification");
 937                 return NULL;
 938         }
 939
 940         notification_ipc_make_noti_from_packet(noti, packet);
 941
 942         notification_op *noti_op = notification_ipc_create_op(NOTIFICATION_OP_UPDATE, 1, &(noti->priv_id), 1, &noti);
 943         if (noti_op != NULL) {
 944                 notification_call_changed_cb(noti_op, 1);
 945                 free(noti_op);
 946         }
 947
 948         notification_free(noti);
 949
 950         return NULL;
 951 }
 952
 953 static struct packet *_handler_refresh(pid_t pid, int handle, const struct packet *packet)
 954 {
 955         if (!packet) {
 956                 NOTIFICATION_ERR("a packet is null");
 957                 return NULL;
 958         }
 959         notification_op *noti_op = notification_ipc_create_op(NOTIFICATION_OP_REFRESH, 1, NULL, 0, NULL);
 960         if (noti_op != NULL) {
 961                 notification_call_changed_cb(noti_op, 1);
 962                 free(noti_op);
 963         }
 964
 965         return NULL;
 966 }
 967
 968 static struct packet *_handler_delete_single(pid_t pid, int handle, const struct packet *packet)
 969 {
 970         int num_deleted = 0;
 971         int priv_id = NOTIFICATION_PRIV_ID_NONE;
 972
 973         if (!packet) {
 974                 NOTIFICATION_ERR("a packet is null");
 975                 return NULL;
 976         }
 977         if (packet_get(packet, "ii", &num_deleted, &priv_id) == 2) {
 978                 notification_op *noti_op = notification_ipc_create_op(NOTIFICATION_OP_DELETE, 1, &priv_id, 1, NULL);
 979                 if (noti_op != NULL) {
 980                         notification_call_changed_cb(noti_op, 1);
 981                         free(noti_op);
 982                 }
 983         }
 984
 985         return NULL;
 986 }
 987
 988 static struct packet *_handler_delete_multiple(pid_t pid, int handle, const struct packet *packet)
 989 {
 990         int ret = 0;
 991         int buf[10] = {0,};
 992         int num_deleted = 0;
 993
 994         NOTIFICATION_ERR("delete_noti_multiple");
 995
 996         if (!packet) {
 997                 NOTIFICATION_ERR("a packet is null");
 998                 return NULL;
 999         }
1000         ret = packet_get(packet, "iiiiiiiiiii", &num_deleted,
1001                         &(buf[0]),
1002                         &(buf[1]),
1003                         &(buf[2]),
1004                         &(buf[3]),
1005                         &(buf[4]),
1006                         &(buf[5]),
1007                         &(buf[6]),
1008                         &(buf[7]),
1009                         &(buf[8]),
1010                         &(buf[9]));
1011
1012         NOTIFICATION_ERR("packet data count:%d", ret);
1013         NOTIFICATION_ERR("packet data num deleted:%d", num_deleted);
1014
1015         int i = 0;
1016         for (i = 0 ; i < 10 ; i++) {
1017                 NOTIFICATION_ERR("packet data[%d]:%d",i, buf[i]);
1018         }
1019
1020         if (ret == 11) {
1021                 notification_op *noti_op = notification_ipc_create_op(
1022                                 NOTIFICATION_OP_DELETE, num_deleted, buf, num_deleted, NULL);
1023                 if (noti_op != NULL) {
1024                         notification_call_changed_cb(noti_op, num_deleted);
1025                         free(noti_op);
1026                 }
1027         }
1028
1029         return NULL;
1030 }
1031
1032 static int _handler_service_register(pid_t pid, int handle, const struct packet *packet, void *data)
1033 {
1034         int ret;
1035
1036         if (!packet) {
1037                 NOTIFICATION_ERR("Packet is not valid\n");
1038                 ret = NOTIFICATION_ERROR_INVALID_PARAMETER;
1039         } else if (packet_get(packet, "i", &ret) != 1) {
1040                 NOTIFICATION_ERR("Packet is not valid\n");
1041                 ret = NOTIFICATION_ERROR_INVALID_PARAMETER;
1042         } else {
1043                 if (ret == 0) {
1044                         notification_op *noti_op = notification_ipc_create_op(NOTIFICATION_OP_SERVICE_READY, 1, NULL, 1, NULL);
1045                         if (noti_op != NULL) {
1046                                 notification_call_changed_cb(noti_op, 1);
1047                                 free(noti_op);
1048                         }
1049                 }
1050         }
1051         return ret;
1052 }
1053
1054 /*!
1055  * functions to initialize and register a monitor
1056  */
1057 static int notification_ipc_monitor_register(void)
1058 {
1059         int ret;
1060         struct packet *packet;
1061         static struct method service_table[] = {
1062                 {
1063                         .cmd = "add_noti",
1064                         .handler = _handler_insert,
1065                 },
1066                 {
1067                         .cmd = "update_noti",
1068                         .handler = _handler_update,
1069                 },
1070                 {
1071                         .cmd = "refresh_noti",
1072                         .handler = _handler_refresh,
1073                 },
1074                 {
1075                         .cmd = "del_noti_single",
1076                         .handler = _handler_delete_single,
1077                 },
1078                 {
1079                         .cmd = "del_noti_multiple",
1080                         .handler = _handler_delete_multiple,
1081                 },
1082                 {
1083                         .cmd = NULL,
1084                         .handler = NULL,
1085                 },
1086         };
1087
1088         if (s_info.initialized == 1) {
1089                 return NOTIFICATION_ERROR_NONE;
1090         } else {
1091                 s_info.initialized = 1;
1092         }
1093
1094         NOTIFICATION_ERR("register a service\n");
1095
1096         com_core_packet_use_thread(1);
1097         s_info.server_fd = com_core_packet_client_init(s_info.socket_file, 0, service_table);
1098         if (s_info.server_fd < 0) {
1099                 NOTIFICATION_ERR("Failed to make a connection to the master\n");
1100                 return NOTIFICATION_ERROR_IO_ERROR;
1101         }
1102
1103         packet = packet_create("service_register", "");
1104         if (!packet) {
1105                 NOTIFICATION_ERR("Failed to build a packet\n");
1106                 com_core_packet_client_fini(s_info.server_fd);
1107                 return NOTIFICATION_ERROR_IO_ERROR;
1108         }
1109
1110         ret = com_core_packet_async_send(s_info.server_fd, packet, 1.0, _handler_service_register, NULL);
1111         NOTIFICATION_DBG("Service register sent: %d\n", ret);
1112         packet_destroy(packet);
1113         if (ret != 0) {
1114                 com_core_packet_client_fini(s_info.server_fd);
1115                 s_info.server_fd = NOTIFICATION_ERROR_INVALID_PARAMETER;
1116                 ret = NOTIFICATION_ERROR_IO_ERROR;
1117         } else {
1118                 ret = NOTIFICATION_ERROR_NONE;
1119         }
1120
1121         NOTIFICATION_DBG("Server FD: %d\n", s_info.server_fd);
1122         return ret;
1123 }
1124
1125 int notification_ipc_monitor_deregister(void)
1126 {
1127         if (s_info.initialized == 0) {
1128                 return NOTIFICATION_ERROR_NONE;
1129         }
1130
1131         com_core_packet_client_fini(s_info.server_fd);
1132         s_info.server_fd = NOTIFICATION_ERROR_INVALID_PARAMETER;
1133
1134         s_info.initialized = 0;
1135
1136         return NOTIFICATION_ERROR_NONE;
1137 }
1138
1139 int notification_ipc_monitor_init(void)
1140 {
1141         int ret = NOTIFICATION_ERROR_NONE;
1142
1143         if (notification_ipc_is_master_ready()) {
1144                 ret = notification_ipc_monitor_register();
1145         }
1146
1147         if (s_info.is_started_cb_set_svc == 0) {
1148                 _set_master_started_cb(_master_started_cb_service);
1149                 s_info.is_started_cb_set_svc = 1;
1150         }
1151
1152         return ret;
1153 }
1154
1155 int notification_ipc_monitor_fini(void)
1156 {
1157         int ret = NOTIFICATION_ERROR_NONE;
1158
1159         if (s_info.is_started_cb_set_svc == 1) {
1160                 _unset_master_started_cb(_master_started_cb_service);
1161                 s_info.is_started_cb_set_svc = 0;
1162         }
1163
1164         ret = notification_ipc_monitor_deregister();
1165
1166         return ret;
1167 }
1168
1169 /*!
1170  * functions to request the service
1171  */
1172 int notification_ipc_request_insert(notification_h noti, int *priv_id)
1173 {
1174         int status = 0;
1175         int id = NOTIFICATION_PRIV_ID_NONE;
1176         struct packet *packet;
1177         struct packet *result;
1178
1179         /* Initialize private ID */
1180         noti->priv_id = NOTIFICATION_PRIV_ID_NONE;
1181         noti->group_id = NOTIFICATION_GROUP_ID_NONE;
1182         noti->internal_group_id = NOTIFICATION_GROUP_ID_NONE;
1183
1184         packet = notification_ipc_make_packet_from_noti(noti, "add_noti", 1);
1185         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1186                         packet,
1187                         NOTIFICATION_IPC_TIMEOUT);
1188         packet_destroy(packet);
1189
1190         if (result != NULL) {
1191                 if (packet_get(result, "ii", &status, &id) != 2) {
1192                         NOTIFICATION_ERR("Failed to get a result packet");
1193                         packet_unref(result);
1194                         return NOTIFICATION_ERROR_IO_ERROR;
1195                 }
1196
1197                 if (status != NOTIFICATION_ERROR_NONE) {
1198                         packet_unref(result);
1199                         return status;
1200                 }
1201                 packet_unref(result);
1202         } else {
1203                 NOTIFICATION_ERR("failed to receive answer(insert)");
1204                 if (notification_ipc_is_master_ready() == 1) {
1205                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1206                 }
1207                 else {
1208                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1209                 }
1210         }
1211
1212         if (priv_id != NULL) {
1213                 *priv_id = id;
1214         }
1215
1216         return NOTIFICATION_ERROR_NONE;
1217 }
1218
1219 int notification_ipc_request_delete_single(notification_type_e type, char *pkgname, int priv_id)
1220 {
1221         int status = 0;
1222         int id = NOTIFICATION_PRIV_ID_NONE;
1223         struct packet *packet;
1224         struct packet *result;
1225
1226         packet = packet_create("del_noti_single", "si", pkgname, priv_id);
1227         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1228                         packet,
1229                         NOTIFICATION_IPC_TIMEOUT);
1230         packet_destroy(packet);
1231
1232         if (result != NULL) {
1233                 if (packet_get(result, "ii", &status, &id) != 2) {
1234                         NOTIFICATION_ERR("Failed to get a result packet");
1235                         packet_unref(result);
1236                         return NOTIFICATION_ERROR_IO_ERROR;
1237                 }
1238                 packet_unref(result);
1239         } else {
1240                 NOTIFICATION_ERR("failed to receive answer(delete)");
1241                 if (notification_ipc_is_master_ready() == 1) {
1242                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1243                 }
1244                 else {
1245                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1246                 }
1247         }
1248
1249         return status;
1250 }
1251
1252 int notification_ipc_request_delete_multiple(notification_type_e type, char *pkgname)
1253 {
1254         int status = 0;
1255         int num_deleted = 0;
1256         struct packet *packet;
1257         struct packet *result;
1258
1259         packet = packet_create("del_noti_multiple", "si", pkgname, type);
1260         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1261                         packet,
1262                         NOTIFICATION_IPC_TIMEOUT);
1263         packet_destroy(packet);
1264
1265         if (result != NULL) {
1266                 if (packet_get(result, "ii", &status, &num_deleted) != 2) {
1267                         NOTIFICATION_ERR("Failed to get a result packet");
1268                         packet_unref(result);
1269                         return NOTIFICATION_ERROR_IO_ERROR;
1270                 }
1271                 NOTIFICATION_ERR("num deleted:%d", num_deleted);
1272                 packet_unref(result);
1273         } else {
1274                 NOTIFICATION_ERR("failed to receive answer(delete multiple)");
1275                 if (notification_ipc_is_master_ready() == 1) {
1276                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1277                 }
1278                 else {
1279                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1280                 }
1281         }
1282
1283         return status;
1284 }
1285
1286 int notification_ipc_request_update(notification_h noti)
1287 {
1288         int status = 0;
1289         int id = NOTIFICATION_PRIV_ID_NONE;
1290         struct packet *packet;
1291         struct packet *result;
1292
1293         packet = notification_ipc_make_packet_from_noti(noti, "update_noti", 1);
1294         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1295                         packet,
1296                         NOTIFICATION_IPC_TIMEOUT);
1297         packet_destroy(packet);
1298
1299         if (result != NULL) {
1300                 if (packet_get(result, "ii", &status, &id) != 2) {
1301                         NOTIFICATION_ERR("Failed to get a result packet");
1302                         packet_unref(result);
1303                         return NOTIFICATION_ERROR_IO_ERROR;
1304                 }
1305                 packet_unref(result);
1306         } else {
1307                 NOTIFICATION_ERR("failed to receive answer(update)");
1308                 if (notification_ipc_is_master_ready() == 1) {
1309                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1310                 }
1311                 else {
1312                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1313                 }
1314         }
1315
1316         return status;
1317 }
1318
1319 static int _notification_ipc_update_cb(pid_t pid, int handle, const struct packet *packet, void *data)
1320 {
1321         int status = 0;
1322         int id = NOTIFICATION_PRIV_ID_NONE;
1323         result_cb_item *cb_item = (result_cb_item *)data;
1324
1325         if (cb_item == NULL) {
1326                 NOTIFICATION_ERR("Failed to get a callback item");
1327                 return NOTIFICATION_ERROR_INVALID_PARAMETER;
1328         }
1329         s_info.server_cl_fd_ref_cnt = (s_info.server_cl_fd_ref_cnt <= 1) ? 0 : s_info.server_cl_fd_ref_cnt - 1;
1330         if (s_info.server_cl_fd_ref_cnt <= 0) {
1331                 NOTIFICATION_DBG("REFCNT: %d (fd: %d)", s_info.server_cl_fd_ref_cnt, s_info.server_cl_fd);
1332                 int fd_temp = s_info.server_cl_fd;
1333                 s_info.server_cl_fd = -1;
1334                 com_core_packet_client_fini(fd_temp);
1335                 NOTIFICATION_DBG("FD(%d) finalized", fd_temp);
1336         }
1337
1338         if (packet != NULL) {
1339                 if (packet_get(packet, "ii", &status, &id) != 2) {
1340                         NOTIFICATION_ERR("Failed to get a result packet");
1341                         status = NOTIFICATION_ERROR_IO_ERROR;
1342                 }
1343         }
1344
1345         if (cb_item->result_cb != NULL) {
1346                 cb_item->result_cb(id, status, cb_item->data);
1347         }
1348         free(cb_item);
1349
1350         return status;
1351 }
1352
1353 int notification_ipc_request_update_async(notification_h noti,
1354                 void (*result_cb)(int priv_id, int result, void *data), void *user_data)
1355 {
1356         int ret = NOTIFICATION_ERROR_NONE;
1357         int ret_con = 0;
1358         struct packet *packet = NULL;
1359         result_cb_item *cb_item = NULL;
1360
1361         packet = notification_ipc_make_packet_from_noti(noti, "update_noti", 1);
1362         if (packet == NULL) {
1363                 ret = NOTIFICATION_ERROR_INVALID_PARAMETER;
1364                 goto fail;
1365         }
1366
1367         cb_item = calloc(1, sizeof(result_cb_item));
1368         if (cb_item == NULL) {
1369                 ret = NOTIFICATION_ERROR_OUT_OF_MEMORY;
1370                 goto fail;
1371         }
1372
1373         if (s_info.server_cl_fd < 0) {
1374                 com_core_packet_use_thread(1);
1375                 s_info.server_cl_fd = com_core_packet_client_init(s_info.socket_file, 0, NULL);
1376                 if (s_info.server_cl_fd < 0) {
1377                         NOTIFICATION_DBG("Failed to init client: %d", s_info.server_cl_fd);
1378                 if (notification_ipc_is_master_ready() == 1) {
1379                         ret = NOTIFICATION_ERROR_PERMISSION_DENIED;
1380                 }
1381                 else {
1382                         ret =  NOTIFICATION_ERROR_SERVICE_NOT_READY;
1383                 }
1384                         goto fail;
1385                 }
1386                 s_info.server_cl_fd_ref_cnt = 1;
1387         } else {
1388                 s_info.server_cl_fd_ref_cnt++;
1389         }
1390
1391         cb_item->result_cb = result_cb;
1392         cb_item->data = user_data;
1393
1394         NOTIFICATION_INFO("Connection count:%d, fd:%d", s_info.server_cl_fd_ref_cnt, s_info.server_cl_fd);
1395
1396         ret_con = com_core_packet_async_send(s_info.server_cl_fd, packet, 0.0f,
1397                         _notification_ipc_update_cb, cb_item);
1398         if (ret_con < 0) {
1399                 NOTIFICATION_ERR("Failed to request update, %d\n", ret_con);
1400                 s_info.server_cl_fd_ref_cnt = (s_info.server_cl_fd_ref_cnt <= 1) ? 0 : s_info.server_cl_fd_ref_cnt - 1;
1401                 if (s_info.server_cl_fd_ref_cnt <= 0) {
1402                         int fd_temp = s_info.server_cl_fd;
1403                         s_info.server_cl_fd = -1;
1404                         com_core_packet_client_fini(fd_temp);
1405                         NOTIFICATION_INFO("FD(%d) finalized", fd_temp);
1406                 }
1407                 ret = NOTIFICATION_ERROR_IO_ERROR;
1408                 goto fail;
1409         } else {
1410                 ret = NOTIFICATION_ERROR_NONE;
1411                 goto success;
1412         }
1413
1414 fail:
1415         if (cb_item) free(cb_item);
1416         NOTIFICATION_ERR("Err: %d\n", ret);
1417
1418 success:
1419         if (packet) packet_destroy(packet);
1420
1421         return ret;
1422 }
1423
1424 int notification_ipc_request_refresh(void)
1425 {
1426         int status = 0;
1427         struct packet *packet;
1428         struct packet *result;
1429
1430         packet = packet_create("refresh_noti", "i", NOTIFICATION_OP_REFRESH);
1431         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1432                         packet,
1433                         NOTIFICATION_IPC_TIMEOUT);
1434         packet_destroy(packet);
1435
1436         if (result != NULL) {
1437                 if (packet_get(result, "i", &status) != 1) {
1438                         NOTIFICATION_ERR("Failed to get a result packet");
1439                         packet_unref(result);
1440                         return NOTIFICATION_ERROR_IO_ERROR;
1441                 }
1442                 packet_unref(result);
1443         } else {
1444                 NOTIFICATION_ERR("failed to receive answer(refresh)");
1445                 if (notification_ipc_is_master_ready() == 1) {
1446                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1447                 }
1448                 else {
1449                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1450                 }
1451         }
1452
1453         return status;
1454 }
1455
1456
1457 int notification_ipc_update_setting(notification_setting_h setting)
1458 {
1459         int status = 0;
1460         int ret = 0;
1461         struct packet *packet;
1462         struct packet *result;
1463
1464         packet = packet_create("update_noti_setting", "siii", setting->package_name, (int)setting->allow_to_notify, (int)setting->do_not_disturb_except, (int)setting->visibility_class);
1465         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1466                 packet,
1467                 NOTIFICATION_IPC_TIMEOUT);
1468         packet_destroy(packet);
1469
1470         if (result != NULL) {
1471                 if (packet_get(result, "ii", &status, &ret) != 2) {
1472                         NOTIFICATION_ERR("Failed to get a result packet");
1473                         packet_unref(result);
1474                         return NOTIFICATION_ERROR_IO_ERROR;
1475                 }
1476                 packet_unref(result);
1477         } else {
1478                 NOTIFICATION_ERR("failed to receive answer(delete)");
1479                 if (notification_ipc_is_master_ready() == 1) {
1480                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1481                 }
1482                 else {
1483                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1484                 }
1485         }
1486
1487         return status;
1488 }
1489
1490 int notification_ipc_noti_setting_property_set(const char *pkgname, const char *property, const char *value)
1491 {
1492         int status = 0;
1493         int ret = 0;
1494         struct packet *packet;
1495         struct packet *result;
1496
1497         packet = packet_create("set_noti_property", "sss", pkgname, property, value);
1498         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1499                         packet,
1500                         NOTIFICATION_IPC_TIMEOUT);
1501         packet_destroy(packet);
1502
1503         if (result != NULL) {
1504                 if (packet_get(result, "ii", &status, &ret) != 2) {
1505                         NOTIFICATION_ERR("Failed to get a result packet");
1506                         packet_unref(result);
1507                         return NOTIFICATION_ERROR_IO_ERROR;
1508                 }
1509                 packet_unref(result);
1510         } else {
1511                 NOTIFICATION_ERR("failed to receive answer(delete)");
1512                 if (notification_ipc_is_master_ready() == 1) {
1513                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1514                 }
1515                 else {
1516                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1517                 }
1518         }
1519
1520         return status;
1521 }
1522
1523 int notification_ipc_noti_setting_property_get(const char *pkgname, const char *property, char **value)
1524 {
1525         int status = 0;
1526         char *ret = NULL;
1527         struct packet *packet;
1528         struct packet *result;
1529
1530         packet = packet_create("get_noti_property", "ss", pkgname, property);
1531         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1532                         packet,
1533                         NOTIFICATION_IPC_TIMEOUT);
1534         packet_destroy(packet);
1535
1536         if (result != NULL) {
1537                 if (packet_get(result, "is", &status, &ret) != 2) {
1538                         NOTIFICATION_ERR("Failed to get a result packet");
1539                         packet_unref(result);
1540                         return NOTIFICATION_ERROR_IO_ERROR;
1541                 }
1542                 if (status == NOTIFICATION_ERROR_NONE && ret != NULL) {
1543                         *value = strdup(ret);
1544                 }
1545                 packet_unref(result);
1546         } else {
1547                 NOTIFICATION_ERR("failed to receive answer(delete)");
1548                 if (notification_ipc_is_master_ready() == 1) {
1549                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1550                 }
1551                 else {
1552                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1553                 }
1554         }
1555
1556         return status;
1557 }
1558
1559 int notification_ipc_request_load_noti_by_tag(notification_h noti, const char *pkgname, const char *tag)
1560 {
1561         struct packet *packet;
1562         struct packet *result;
1563
1564         packet = packet_create("load_noti_by_tag", "ss", pkgname, tag);
1565         result = com_core_packet_oneshot_send(NOTIFICATION_ADDR,
1566                         packet,
1567                         NOTIFICATION_IPC_TIMEOUT);
1568         packet_destroy(packet);
1569
1570         if (result != NULL) {
1571                 if (notification_ipc_make_noti_from_packet(noti, result) != NOTIFICATION_ERROR_NONE) {
1572                         NOTIFICATION_ERR("Failed to get a result packet");
1573                         packet_unref(result);
1574                         return NOTIFICATION_ERROR_IO_ERROR;
1575                 }
1576
1577                 packet_unref(result);
1578         } else {
1579                 NOTIFICATION_ERR("failed to receive answer(load noti by tag)");
1580                 if (notification_ipc_is_master_ready() == 1) {
1581                         return NOTIFICATION_ERROR_PERMISSION_DENIED;
1582                 }
1583                 else {
1584                         return NOTIFICATION_ERROR_SERVICE_NOT_READY;
1585                 }
1586         }
1587
1588         return NOTIFICATION_ERROR_NONE;
1589 }
1590