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