src/conf.c

   1 /*
   2  * Copyright 2012  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 <Ecore_X.h>
  18 #include <ctype.h>
  19
  20 #include <dlog.h>
  21
  22 #include "conf.h"
  23 #include "util.h"
  24 #include "debug.h"
  25
  26 HAPI struct conf g_conf = {
  27         .width = 0,
  28         .height = 0,
  29
  30         .base_width = 720,
  31         .base_height = 1280,
  32
  33         .minimum_period = 1.0f,
  34
  35         .default_conf.script = "edje",
  36         .default_conf.abi = "c",
  37         .default_conf.pd_group = "disclosure",
  38         .default_conf.period = -1.0f,
  39
  40         .launch_key.name = "name",
  41         .launch_key.secured = "secured",
  42         .launch_key.abi = "abi",
  43
  44         .default_packet_time = 0.0001f,
  45
  46         .empty_content = "",
  47         .empty_title = "",
  48
  49         .default_content = "default",
  50         .default_title = "",
  51
  52         .minimum_space = 5242880,
  53
  54         .replace_tag = "/APPID/",
  55
  56         .slave_ttl = 30.0f,
  57
  58         .max_log_line = 1000,
  59         .max_log_file = 3,
  60
  61         .sqlite_flush_max = 1048576,
  62
  63         .path = {
  64                 .conf = "/opt/usr/live/%s/etc/%s.conf",
  65                 .image = "/opt/usr/share/live_magazine/",
  66                 .slave_log = "/opt/usr/share/live_magazine/log",
  67                 .script = "/opt/usr/live/%s/res/script/%s.edj",
  68                 .root = "/opt/usr/live/",
  69                 .script_port = "/opt/usr/live/script_port/",
  70                 .db = "/opt/dbspace/.livebox.db",
  71         },
  72
  73         .ping_time = 240.0f,
  74         .slave_max_load = 30,
  75         .vconf_sys_cluster = "file/private/org.tizen.data-provider-master/cluster",
  76         .max_pended_ctx_events = 256,
  77
  78         .use_sw_backend = 0,
  79         .provider_method = "pixmap",
  80         .debug_mode = 0,
  81         .overwrite_content = 0,
  82         .com_core_thread = 1,
  83 };
  84
  85 static void conf_update_size(void)
  86 {
  87         ecore_x_window_size_get(0, &g_conf.width, &g_conf.height);
  88 }
  89
  90 static void use_sw_backend_handler(char *buffer)
  91 {
  92         g_conf.use_sw_backend = !strcasecmp(buffer, "true");
  93         DbgPrint("SW Backend: %d\n", g_conf.use_sw_backend);
  94 }
  95
  96 static void provider_method_handler(char *buffer)
  97 {
  98         g_conf.provider_method = strdup(buffer);
  99         if (!g_conf.provider_method)
 100                 ErrPrint("Heap: %s\n", strerror(errno));
 101
 102         DbgPrint("Method: %s\n", g_conf.provider_method);
 103 }
 104
 105 static void debug_mode_handler(char *buffer)
 106 {
 107         g_conf.debug_mode = !strcasecmp(buffer, "true");
 108         DbgPrint("Debug mode: %d\n", g_conf.debug_mode);
 109 }
 110
 111 static void overwrite_content_handler(char *buffer)
 112 {
 113         g_conf.overwrite_content = !strcasecmp(buffer, "true");
 114         DbgPrint("Overwrite Content: %d\n", g_conf.overwrite_content);
 115 }
 116
 117 static void com_core_thread_handler(char *buffer)
 118 {
 119         g_conf.com_core_thread = !strcasecmp(buffer, "true");
 120         DbgPrint("Com core thread: %d\n", g_conf.com_core_thread);
 121 }
 122
 123 static void base_width_handler(char *buffer)
 124 {
 125         if (sscanf(buffer, "%d", &g_conf.base_width) != 1)
 126                 ErrPrint("Failed to parse the base_width\n");
 127
 128         DbgPrint("Base width: %d\n", g_conf.base_width);
 129 }
 130
 131 static void base_height_handler(char *buffer)
 132 {
 133         if (sscanf(buffer, "%d", &g_conf.base_height) != 1)
 134                 ErrPrint("Failed to parse the base_height\n");
 135         DbgPrint("Base height: %d\n", g_conf.base_height);
 136 }
 137
 138 static void minimum_period_handler(char *buffer)
 139 {
 140         if (sscanf(buffer, "%lf", &g_conf.minimum_period) != 1)
 141                 ErrPrint("Failed to parse the minimum_period\n");
 142         DbgPrint("Minimum period: %lf\n", g_conf.minimum_period);
 143 }
 144
 145 static void script_handler(char *buffer)
 146 {
 147         g_conf.default_conf.script = strdup(buffer);
 148         if (!g_conf.default_conf.script)
 149                 ErrPrint("Heap: %s\n", strerror(errno));
 150         DbgPrint("Default script: %s\n", g_conf.default_conf.script);
 151 }
 152
 153 static void default_abi_handler(char *buffer)
 154 {
 155         g_conf.default_conf.abi = strdup(buffer);
 156         if (!g_conf.default_conf.abi)
 157                 ErrPrint("Heap: %s\n", strerror(errno));
 158         DbgPrint("Default ABI: %s\n", g_conf.default_conf.abi);
 159 }
 160
 161 static void default_group_handler(char *buffer)
 162 {
 163         g_conf.default_conf.pd_group = strdup(buffer);
 164         if (!g_conf.default_conf.pd_group)
 165                 ErrPrint("Heap: %s\n", strerror(errno));
 166         DbgPrint("Default PD Group: %s\n", g_conf.default_conf.pd_group);
 167 }
 168
 169 static void default_period_handler(char *buffer)
 170 {
 171         if (sscanf(buffer, "%lf", &g_conf.default_conf.period) != 1)
 172                 ErrPrint("Failed to parse the default_period\n");
 173         DbgPrint("Default Period: %lf\n", g_conf.default_conf.period);
 174 }
 175
 176 static void default_packet_time_handler(char *buffer)
 177 {
 178         if (sscanf(buffer, "%lf", &g_conf.default_packet_time) != 1)
 179                 ErrPrint("Failed to parse the default_packet_time\n");
 180         DbgPrint("Default packet time: %lf\n", g_conf.default_packet_time);
 181 }
 182
 183 static void default_content_handler(char *buffer)
 184 {
 185         g_conf.default_content = strdup(buffer);
 186         if (!g_conf.default_content)
 187                 ErrPrint("Heap: %s\n", strerror(errno));
 188         DbgPrint("Default content: %s\n", g_conf.default_content);
 189 }
 190
 191 static void default_title_handler(char *buffer)
 192 {
 193         g_conf.default_title = strdup(buffer);
 194         if (!g_conf.default_title)
 195                 ErrPrint("Heap: %s\n", strerror(errno));
 196         DbgPrint("Default title: %s\n", g_conf.default_title);
 197 }
 198
 199 static void minimum_space_handler(char *buffer)
 200 {
 201         if (sscanf(buffer, "%lu", &g_conf.minimum_space) != 1)
 202                 ErrPrint("Failed to parse the minimum_space\n");
 203         DbgPrint("Minimum space: %lu\n", g_conf.minimum_space);
 204 }
 205
 206 static void replace_tag_handler(char *buffer)
 207 {
 208         g_conf.replace_tag = strdup(buffer);
 209         if (!g_conf.replace_tag)
 210                 ErrPrint("Heap: %s\n", strerror(errno));
 211         DbgPrint("Replace Tag: %s\n", g_conf.replace_tag);
 212 }
 213
 214 static void slave_ttl_handler(char *buffer)
 215 {
 216         if (sscanf(buffer, "%lf", &g_conf.slave_ttl) != 1)
 217                 ErrPrint("Failed to parse the slave_ttl\n");
 218         DbgPrint("Slave TTL: %s\n", g_conf.slave_ttl);
 219 }
 220
 221 static void max_log_line_handler(char *buffer)
 222 {
 223         if (sscanf(buffer, "%d", &g_conf.max_log_line) != 1)
 224                 ErrPrint("Failed to parse the max_log_line\n");
 225         DbgPrint("Max log line: %d\n", g_conf.max_log_line);
 226 }
 227
 228 static void max_log_file_handler(char *buffer)
 229 {
 230         if (sscanf(buffer, "%d", &g_conf.max_log_file) != 1)
 231                 ErrPrint("Failed to parse the max_log_file\n");
 232         DbgPrint("Max log file: %d\n", g_conf.max_log_file);
 233 }
 234
 235 static void sqlite_flush_max_handler(char *buffer)
 236 {
 237         if (sscanf(buffer, "%lu", &g_conf.sqlite_flush_max) != 1)
 238                 ErrPrint("Failed to parse the sqlite_flush_max\n");
 239         DbgPrint("Flush size: %lu\n", g_conf.sqlite_flush_max);
 240 }
 241
 242 static void db_path_handler(char *buffer)
 243 {
 244         g_conf.path.db = strdup(buffer);
 245         if (!g_conf.path.db)
 246                 ErrPrint("Heap: %s\n", strerror(errno));
 247         DbgPrint("DB Path: %s\n", g_conf.path.db);
 248 }
 249
 250 static void log_path_handler(char *buffer)
 251 {
 252         g_conf.path.slave_log = strdup(buffer);
 253         if (!g_conf.path.slave_log)
 254                 ErrPrint("Heap: %s\n", strerror(errno));
 255         DbgPrint("LOG Path: %s\n", g_conf.path.slave_log);
 256 }
 257
 258 static void script_port_path_handler(char *buffer)
 259 {
 260         g_conf.path.script_port = strdup(buffer);
 261         if (!g_conf.path.script_port)
 262                 ErrPrint("Heap: %s\n", strerror(errno));
 263         DbgPrint("Script Port PATH: %s\n", g_conf.path.script_port);
 264 }
 265
 266 static void share_path_handler(char *buffer)
 267 {
 268         g_conf.path.image = strdup(buffer);
 269         if (!g_conf.path.image)
 270                 ErrPrint("Heap: %s\n", strerror(errno));
 271         DbgPrint("Shared folder: %s\n", g_conf.path.image);
 272 }
 273
 274 static void ping_time_handler(char *buffer)
 275 {
 276         if (sscanf(buffer, "%lf", &g_conf.ping_time) != 1)
 277                 ErrPrint("Failed to parse the ping_time\n");
 278         DbgPrint("Default ping time: %lf\n", g_conf.ping_time);
 279 }
 280
 281 static void slave_max_loader(char *buffer)
 282 {
 283         if (sscanf(buffer, "%d", &g_conf.slave_max_load) != 1)
 284                 ErrPrint("Failed to parse the slave_max_load\n");
 285         DbgPrint("Max load: %d\n", g_conf.slave_max_load);
 286 }
 287
 288 static void vconf_sys_cluster_handler(char *buffer)
 289 {
 290         g_conf.vconf_sys_cluster = strdup(buffer);
 291         if (!g_conf.vconf_sys_cluster)
 292                 ErrPrint("Heap %s\n", strerror(errno));
 293         DbgPrint("System cluster vconf key: %s\n", g_conf.vconf_sys_cluster);
 294 }
 295
 296 static void max_pended_ctx_event_handler(char *buffer)
 297 {
 298         if (sscanf(buffer, "%d", &g_conf.max_pended_ctx_events) != 1)
 299                 ErrPrint("Failed to parse the max_pended_ctx_events\n");
 300         DbgPrint("Maximum pended event: %d\n", g_conf.max_pended_ctx_events);
 301 }
 302
 303 HAPI int conf_loader(void)
 304 {
 305         FILE *fp;
 306         int c;
 307         enum state {
 308                 START,
 309                 SPACE,
 310                 TOKEN,
 311                 VALUE,
 312                 ERROR,
 313                 COMMENT,
 314                 END,
 315         } state;
 316         int ch_idx;
 317         int token_idx;
 318         int buffer_idx;
 319         int quote;
 320         int linelen;
 321         char buffer[256];
 322         static const struct token_parser {
 323                 const char *name;
 324                 void (*handler)(char *buffer);
 325         } token_handler[] = {
 326                 {
 327                         .name = "base_width",
 328                         .handler = base_width_handler,
 329                 },
 330                 {
 331                         .name = "base_height",
 332                         .handler = base_height_handler,
 333                 },
 334                 {
 335                         .name = "minimum_period",
 336                         .handler = minimum_period_handler,
 337                 },
 338                 {
 339                         .name = "script",
 340                         .handler = script_handler,
 341                 },
 342                 {
 343                         .name = "default_abi",
 344                         .handler = default_abi_handler,
 345                 },
 346                 {
 347                         .name = "default_group",
 348                         .handler = default_group_handler,
 349                 },
 350                 {
 351                         .name = "default_period",
 352                         .handler = default_period_handler,
 353                 },
 354                 {
 355                         .name = "default_packet_time",
 356                         .handler = default_packet_time_handler,
 357                 },
 358                 {
 359                         .name = "default_content",
 360                         .handler = default_content_handler,
 361                 },
 362                 {
 363                         .name = "default_title",
 364                         .handler = default_title_handler,
 365                 },
 366                 {
 367                         .name = "minimum_space",
 368                         .handler = minimum_space_handler,
 369                 },
 370                 {
 371                         .name = "replace_tag",
 372                         .handler = replace_tag_handler,
 373                 },
 374                 {
 375                         .name = "slave_ttl",
 376                         .handler = slave_ttl_handler,
 377                 },
 378                 {
 379                         .name = "max_log_line",
 380                         .handler = max_log_line_handler,
 381                 },
 382                 {
 383                         .name = "max_log_file",
 384                         .handler = max_log_file_handler,
 385                 },
 386                 {
 387                         .name = "sqilte_flush_max",
 388                         .handler = sqlite_flush_max_handler,
 389                 },
 390                 {
 391                         .name = "db_path",
 392                         .handler = db_path_handler,
 393                 },
 394                 {
 395                         .name = "log_path",
 396                         .handler = log_path_handler,
 397                 },
 398                 {
 399                         .name = "share_path",
 400                         .handler = share_path_handler,
 401                 },
 402                 {
 403                         .name = "script_port_path",
 404                         .handler = script_port_path_handler,
 405                 },
 406                 {
 407                         .name = "ping_interval",
 408                         .handler = ping_time_handler,
 409                 },
 410                 {
 411                         .name = "slave_max_load",
 412                         .handler = slave_max_loader,
 413                 },
 414                 {
 415                         .name = "vconf_sys_cluster",
 416                         .handler = vconf_sys_cluster_handler,
 417                 },
 418                 {
 419                         .name = "max_pended_ctx_event",
 420                         .handler = max_pended_ctx_event_handler,
 421                 },
 422                 {
 423                         .name = "use_sw_backend",
 424                         .handler = use_sw_backend_handler,
 425                 },
 426                 {
 427                         .name = "provider_method",
 428                         .handler = provider_method_handler,
 429                 },
 430                 {
 431                         .name = "debug_mode",
 432                         .handler = debug_mode_handler,
 433                 },
 434                 {
 435                         .name = "overwrite_content",
 436                         .handler = overwrite_content_handler,
 437                 },
 438                 {
 439                         .name = "com_core_thread",
 440                         .handler = com_core_thread_handler,
 441                 },
 442                 {
 443                         .name = NULL,
 444                         .handler = NULL,
 445                 },
 446         };
 447
 448         conf_update_size();
 449
 450         fp = fopen("/usr/share/data-provider-master/conf.ini", "rt");
 451         if (!fp) {
 452                 ErrPrint("Error: %s\n", strerror(errno));
 453                 return -EIO;
 454         }
 455
 456         state = START;
 457         ch_idx = 0;
 458         token_idx = -1;
 459         buffer_idx = 0;
 460         quote = 0;
 461         linelen = 0;
 462         do {
 463                 c = getc(fp);
 464                 if ((c == EOF) && (state == VALUE)) {
 465                         LOGD("[%s:%d] VALUE state EOF\n", __func__, __LINE__);
 466                         state = END;
 467                 }
 468
 469                 switch (state) {
 470                 case COMMENT:
 471                         if (c == CR || c == LF || c == EOF) {
 472                                 buffer[buffer_idx] = '\0';
 473
 474                                 state = START;
 475                                 token_idx = -1;
 476                                 ch_idx = 0;
 477                                 buffer_idx = 0;
 478                                 linelen = -1; /* Will be ZERO by follwing increment code */
 479                                 quote = 0;
 480                         } else {
 481                                 buffer[buffer_idx++] = c;
 482                                 if (buffer_idx == (sizeof(buffer) - 1)) {
 483                                         buffer[buffer_idx] = '\0';
 484                                         buffer_idx = 0;
 485                                 }
 486                         }
 487                         break;
 488                 case START:
 489                         if (linelen == 0 && c == '#') {
 490                                 state = COMMENT;
 491                         } else if (isspace(c)) {
 492                                 /* Ignore empty space */
 493                         } else {
 494                                 state = TOKEN;
 495                                 ungetc(c, fp);
 496                         }
 497                         break;
 498                 case SPACE:
 499                         if (c == '=')
 500                                 state = VALUE;
 501                         else if (!isspace(c))
 502                                 state = ERROR;
 503                         break;
 504                 case VALUE:
 505                         if (c == '"') {
 506                                 if (quote == 1) {
 507                                         buffer[buffer_idx] = '\0';
 508                                         state = END;
 509                                 } else if (buffer_idx != 0) {
 510                                         buffer[buffer_idx++] = c;
 511                                         if (buffer_idx >= sizeof(buffer))
 512                                                 state = ERROR;
 513                                 } else {
 514                                         quote = 1;
 515                                 }
 516                         } else if (isspace(c)) {
 517                                 if (buffer_idx == 0) {
 518                                         /* Ignore */
 519                                 } else if (quote == 1) {
 520                                         buffer[buffer_idx++] = c;
 521                                         if (buffer_idx >= sizeof(buffer))
 522                                                 state = ERROR;
 523                                 } else {
 524                                         buffer[buffer_idx] = '\0';
 525                                         ungetc(c, fp);
 526                                         state = END;
 527                                 }
 528                         } else {
 529                                 buffer[buffer_idx++] = c;
 530                                 if (buffer_idx >= sizeof(buffer))
 531                                         state = ERROR;
 532                         }
 533                         break;
 534                 case TOKEN:
 535                         if (c == '=') {
 536                                 if (token_idx < 0)
 537                                         state = ERROR;
 538                                 else
 539                                         state = VALUE;
 540                         } else if (isspace(c)) {
 541                                 if (token_idx < 0)
 542                                         break;
 543
 544                                 if (token_handler[token_idx].name[ch_idx] != '\0')
 545                                         state = ERROR;
 546                                 else
 547                                         state = SPACE;
 548                         } else  {
 549                                 if (token_idx < 0) {
 550                                         /* Now start to find a token! */
 551                                         token_idx = 0;
 552                                 }
 553
 554                                 if (token_handler[token_idx].name[ch_idx] == c) {
 555                                         ch_idx++;
 556                                 } else {
 557                                         ungetc(c, fp);
 558                                         while (ch_idx-- > 0)
 559                                                 ungetc(token_handler[token_idx].name[ch_idx], fp);
 560
 561                                         token_idx++;
 562
 563                                         if (token_handler[token_idx].name == NULL)
 564                                                 state = ERROR;
 565                                         else
 566                                                 ch_idx = 0;
 567                                 }
 568                         }
 569                         break;
 570                 case ERROR:
 571                         if (c == CR || c == LF || c == EOF) {
 572                                 state = START;
 573                                 token_idx = -1;
 574                                 buffer_idx = 0;
 575                                 ch_idx = 0;
 576                                 linelen = -1;
 577                                 quote = 0;
 578                         }
 579                         break;
 580                 case END:
 581                         if (c == LF || c == CR || c == EOF) {
 582                                 state = START;
 583
 584                                 if (token_idx >= 0 && token_handler[token_idx].handler) {
 585                                         buffer[buffer_idx] = '\0';
 586                                         DbgPrint("BUFFER: [%s]\n", buffer);
 587                                         token_handler[token_idx].handler(buffer);
 588                                 }
 589
 590                                 token_idx = -1;
 591                                 ch_idx = 0;
 592                                 buffer_idx = 0;
 593                                 linelen = -1;
 594                                 quote = 0;
 595                                 /* Finish */
 596                         } else if (isspace(c)) {
 597                                 /* ignore */
 598                         } else {
 599                                 state = ERROR;
 600                         }
 601                         break;
 602                 default:
 603                         /* ?? */
 604                         break;
 605                 }
 606
 607                 linelen++;
 608          } while (c != EOF);
 609
 610         fclose(fp);
 611         return 0;
 612 }
 613
 614 /* End of a file */