1/* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16#include "ns_config.h" 17 18#include <ctype.h> 19#include <stdarg.h> 20 21#include "ld_log.h" 22/*---------------------------- Defines -------------------------------------*/ 23#define MAX_LINE_SIZE (1024) 24#define INI_INVALID_KEY ((char*)-1) 25 26#ifdef UNIT_TEST_STATIC 27 #define UT_STATIC 28#else 29 #define UT_STATIC static 30#endif 31typedef enum _line_status_ { 32 LINE_UNPROCESSED, 33 LINE_ERROR, 34 LINE_EMPTY, 35 LINE_COMMENT, 36 LINE_SECTION, 37 LINE_VALUE 38} line_status; 39 40#define MAX_KEY_LEN 256 41static char g_key[MAX_KEY_LEN + 1] = {0}; 42 43static char *config_key_join(const char *join, bool start) 44{ 45 if (start) g_key[0] = 0; 46 size_t cnt = MAX_KEY_LEN - strlen(g_key); 47 return strncat(g_key, join, cnt); 48} 49 50static int default_error_callback(const char *format, ...) 51{ 52 int ret = 0; 53 va_list argptr; 54 va_start(argptr, format); 55 /* do not print 56 ret = vfprintf(stderr, format, argptr); 57 */ 58 va_end(argptr); 59 return ret; 60} 61 62static int (*config_error_callback)(const char *, ...) = default_error_callback; 63 64static void config_set_error_callback(int (*errback)(const char *, ...)) 65{ 66 if (errback) { 67 config_error_callback = errback; 68 } else { 69 config_error_callback = default_error_callback; 70 } 71} 72 73static line_status config_line(char *line, char *section, char *key, char *value) 74{ 75 size_t len; 76 char *split; 77 78 if ((len = strcspn(line, "#;")) == 0) { 79 /* comment line */ 80 return LINE_COMMENT; 81 } 82 line[len] = 0; 83 if ((len = strtrim(line)) == 0) { 84 /* empty line */ 85 return LINE_EMPTY; 86 } 87 if (line[0] == '[' && line[len - 1] == ']') { 88 /* section name */ 89 memcpy(section, line + 1, len - 2); 90 section[len - 2] = 0; 91 strtrim(section); 92 return LINE_SECTION; 93 } 94 if (split = strchr(line, '=')) { 95 /* key and value */ 96 size_t klen, vlen; 97 klen = split - line; 98 vlen = len - klen - 1; 99 if (klen > 0) memcpy(key, line, klen); 100 if (vlen > 0) memcpy(value, split + 1, vlen); 101 key[klen] = 0; 102 value[vlen] = 0; 103 strtrim(key); 104 strtrim(value); 105 return LINE_VALUE; 106 } 107 return LINE_ERROR; 108} 109 110#define SECTION_DEFAULT_SIZE 16 111#define KV_DEFAULT_SIZE 64 112 113static kvlist * kvlist_alloc(size_t size) 114{ 115 kvlist *kvs; 116 117 if (size < KV_DEFAULT_SIZE) size = KV_DEFAULT_SIZE; 118 119 kvs = (kvlist *)__libc_calloc(1, sizeof *kvs); 120 if (kvs) { 121 kvs->key = (char **)__libc_calloc(size, sizeof *kvs->key); 122 kvs->val = (char **)__libc_calloc(size, sizeof *kvs->val); 123 if (kvs->key && kvs->val) { 124 kvs->size = size; 125 } else { 126 __libc_free(kvs->key); 127 __libc_free(kvs->val); 128 __libc_free(kvs); 129 kvs = NULL; 130 } 131 } 132 return kvs; 133} 134 135UT_STATIC void kvlist_realloc(kvlist *kvs) 136{ 137 if (!kvs) return; 138 size_t size = 2 * kvs->size; 139 if (size) { 140 char **keys, **vals; 141 keys = (char **)__libc_realloc(kvs->key, size * (sizeof *kvs->key)); 142 if (!keys) return; 143 kvs->key = keys; 144 vals = (char **)__libc_realloc(kvs->val, size * (sizeof *kvs->val)); 145 if (!vals) return; 146 kvs->val = vals; 147 kvs->size = size; 148 } 149 150 return; 151} 152 153static void kvlist_free(kvlist *kvs) 154{ 155 size_t i; 156 if (!kvs) return; 157 for (i = 0; i < kvs->num; i++) { 158 __libc_free(kvs->key[i]); 159 __libc_free(kvs->val[i]); 160 } 161 __libc_free(kvs->key); 162 __libc_free(kvs->val); 163 __libc_free(kvs); 164} 165 166static section_list *sections_alloc(size_t size) 167{ 168 section_list *sections; 169 if (size < SECTION_DEFAULT_SIZE) size = SECTION_DEFAULT_SIZE; 170 171 sections = (section_list *)__libc_calloc(1, sizeof *sections); 172 173 if (sections) { 174 sections->names = (char**)__libc_calloc(size, sizeof *sections->names); 175 sections->kvs = (kvlist**)__libc_calloc(size, sizeof *sections->kvs); 176 if (sections->names && sections->kvs) { 177 sections->size = size; 178 } else { 179 __libc_free(sections->names); 180 __libc_free(sections->kvs); 181 __libc_free(sections); 182 sections = NULL; 183 } 184 } 185 return sections; 186} 187 188UT_STATIC void sections_realloc(section_list *sections) 189{ 190 if (!sections) return; 191 size_t size = 2 * sections->size; 192 if (size) { 193 char **names; 194 kvlist **kvs; 195 names = (char **)__libc_realloc(sections->names, size * (sizeof *sections->names)); 196 if (!names) return; 197 sections->names = names; 198 kvs = (kvlist **)__libc_realloc(sections->kvs, size * (sizeof *sections->kvs)); 199 if (!kvs) return; 200 sections->kvs = kvs; 201 sections->size = size; 202 } 203 return; 204} 205 206static void sections_free(section_list *sections) 207{ 208 if (!sections) return; 209 for (size_t i = 0; i < sections->num; i++) { 210 __libc_free(sections->names[i]); 211 kvlist_free(sections->kvs[i]); 212 } 213 __libc_free(sections->names); 214 __libc_free(sections->kvs); 215 __libc_free(sections); 216} 217 218static void kvlist_set(kvlist *kvs, const char *key, const char *val) 219{ 220 size_t i; 221 if (!kvs || !key || !val) return; 222 223 for (i = 0; i < kvs->num; i++) { 224 if (!strcmp(kvs->key[i], key)) { 225 break; 226 } 227 } 228 229 if (i < kvs->num) { 230 char * v = ld_strdup(val); 231 if (v) { 232 __libc_free(kvs->val[i]); 233 kvs->val[i] = v; 234 } 235 return; 236 } 237 if (kvs->num == kvs->size) { 238 kvlist_realloc(kvs); 239 } 240 if (kvs->num < kvs->size) { 241 kvs->key[kvs->num] = ld_strdup(key); 242 kvs->val[kvs->num] = ld_strdup(val); 243 if (kvs->key[kvs->num] && kvs->val[kvs->num]) { 244 kvs->num++; 245 } else { 246 __libc_free(kvs->key[kvs->num]); 247 __libc_free(kvs->val[kvs->num]); 248 } 249 } 250 return; 251} 252 253static void sections_set(section_list *sections, const char *name, const char *key, const char *val) 254{ 255 kvlist* kvs = NULL; 256 if (!sections || !name || !key || !val) return; 257 258 for(size_t i = 0; i < sections->num; i++) { 259 if (!strcmp(sections->names[i], name)) { 260 kvs = sections->kvs[i]; 261 break; 262 } 263 } 264 if (kvs) { 265 kvlist_set(kvs, key, val); 266 return; 267 } 268 269 if (sections->num == sections->size) { 270 sections_realloc(sections); 271 } 272 273 if (sections->num < sections->size) { 274 kvs = kvlist_alloc(0); 275 sections->names[sections->num] = ld_strdup(name); 276 sections->kvs[sections->num] = kvs; 277 if (sections->names[sections->num] && kvs) { 278 sections->num++; 279 kvlist_set(kvs, key, val); 280 } else { 281 __libc_free(sections->names[sections->num]); 282 kvlist_free(kvs); 283 } 284 } 285} 286 287static section_list *config_load(const char *filepath) 288{ 289 FILE *file; 290 char line[MAX_LINE_SIZE + 1]; 291 char section[MAX_LINE_SIZE + 1]; 292 char key[MAX_LINE_SIZE + 1]; 293 char val[MAX_LINE_SIZE + 1]; 294 295 size_t len; 296 int lineno = 0; 297 298 section_list *sections; 299 300 if ((file = fopen(filepath, "r")) == NULL) { 301 config_error_callback("config: cannot open %s\n", filepath); 302 return NULL; 303 } 304 305 sections = sections_alloc(0); 306 if (!sections) { 307 fclose(file); 308 return NULL; 309 } 310 311 memset(line, 0, sizeof line); 312 memset(section, 0, sizeof section); 313 memset(key, 0, sizeof key); 314 memset(val, 0, sizeof val); 315 316 while (fgets(line, sizeof line, file)) { 317 lineno++; 318 len = strlen(line); 319 if (len == 0) continue; 320 321 if (line[len - 1] != '\n' && !feof(file)) { 322 config_error_callback( 323 "config: input line too long in %s (%d)\n", filepath, lineno); 324 sections_free(sections); 325 fclose(file); 326 return NULL; 327 } 328 329 if (line[len - 1] == '\n') { 330 line[len - 1] = 0; 331 len--; 332 } 333 334 switch (config_line(line, section, key, val)) { 335 case LINE_EMPTY: 336 case LINE_COMMENT: 337 case LINE_SECTION: 338 break; 339 case LINE_VALUE: 340 sections_set(sections, section, key, val); 341 break; 342 case LINE_ERROR: 343 config_error_callback( 344 "config: syntax error in %s (%d):\n-> %s\n", 345 filepath, 346 lineno, 347 line); 348 break; 349 default: 350 break; 351 } 352 } 353 fclose(file); 354 return sections; 355} 356 357static ns_configor g_configor; 358 359/* const define */ 360#define CONFIG_DEFAULT_FILE "/etc/ld-musl-namespace-arm.ini" /* default config file pathname */ 361#define SECTION_DIR_MAP "section.dir.map" /* map of section and directory of app */ 362#define ATTR_NS_PREFIX "namespace" /* prefix of namespace attribute */ 363#define ATTR_NS_ASAN "asan" /* asan */ 364#define ATTR_NS_LIB_PATHS "lib.paths" /* library search paths */ 365#define ATTR_NS_PERMITTED_PATHS "permitted.paths" /* when separated, permitted dir paths of libs, including sub dirs */ 366#define ATTR_NS_INHERITS "inherits" /* inherited namespace */ 367#define ATTR_NS_SEPARATED "separated" /* if separated */ 368#define ATTR_ADDED_NSLIST "added.nslist" /* all namespace names except default */ 369#define ATTR_NS_DEFAULT "default" /* default namespace name */ 370#define ATTR_NS_ACQUIESCENCE "acquiescence" /* acquiescence section name */ 371#define ATTR_NS_ALLOWED_LIBS "allowed.libs" /* when separated, allowed library names */ 372#define ATTR_NS_INHERIT_SHARED_LIBS "shared.libs" /* when inherited, shared library names */ 373#define SECTION_DIR_MAP_SYSTEM "system" /* system path */ 374#define SECTION_DIR_MAP_ASAN_SYSTEM "asan_system" /* asan system path */ 375 376/* get key-value list of section */ 377static kvlist *config_get_kvs(const char *sname) 378{ 379 size_t i; 380 for (i = 0; i < g_configor.sections->num; i++) { 381 if (!strcmp(g_configor.sections->names[i], sname)) { 382 return g_configor.sections->kvs[i]; 383 } 384 } 385 return NULL; 386} 387 388/* get value by acquiescence */ 389static char *config_get_value_by_acquiescence(kvlist *acquiescence_kvs, const char *key) 390{ 391 if (!acquiescence_kvs) { 392 return NULL; 393 } 394 size_t i; 395 for (i = 0; i < acquiescence_kvs->num; i++) { 396 if (!strcmp(acquiescence_kvs->key[i], key)) { 397 return acquiescence_kvs->val[i]; 398 } 399 } 400 return NULL; 401} 402 403/* get value by acquiescence lib path */ 404static char *config_get_acquiescence_lib_path(kvlist *acquiescence_kvs) 405{ 406 if (!acquiescence_kvs) { 407 return NULL; 408 } 409 config_key_join(ATTR_NS_PREFIX, true); 410 config_key_join(".", false); 411 config_key_join(ATTR_NS_DEFAULT, false); 412 config_key_join(".", false); 413 char *key = config_key_join(ATTR_NS_LIB_PATHS, false); 414 return config_get_value_by_acquiescence(acquiescence_kvs, key); 415} 416 417/* get value by acquiescence asan lib path */ 418static char *config_get_acquiescence_asan_lib_path(kvlist *acquiescence_kvs) 419{ 420 if (!acquiescence_kvs) { 421 return NULL; 422 } 423 config_key_join(ATTR_NS_PREFIX, true); 424 config_key_join(".", false); 425 config_key_join(ATTR_NS_DEFAULT, false); 426 config_key_join(".", false); 427 config_key_join(ATTR_NS_ASAN, false); 428 config_key_join(".", false); 429 char *key = config_key_join(ATTR_NS_LIB_PATHS, false); 430 return config_get_value_by_acquiescence(acquiescence_kvs, key); 431} 432 433/* get value by key */ 434static char *config_get_value(const char *key) 435{ 436 if (!g_configor.kvs) { 437 return NULL; 438 } 439 size_t i; 440 for (i = 0; i < g_configor.kvs->num; i++) { 441 if (!strcmp(g_configor.kvs->key[i], key)) return g_configor.kvs->val[i]; 442 } 443 return NULL; 444} 445 446/* get library search paths */ 447static char *config_get_lib_paths(const char *ns_name) 448{ 449 if (ns_name == NULL) { 450 return NULL; 451 } 452 config_key_join(ATTR_NS_PREFIX, true); 453 config_key_join(".", false); 454 config_key_join(ns_name, false); 455 config_key_join(".", false); 456 char *key = config_key_join(ATTR_NS_LIB_PATHS, false); 457 return config_get_value(key); 458} 459 460/* get asan library search paths */ 461static char *config_get_asan_lib_paths(const char *ns_name) 462{ 463 if (ns_name == NULL) { 464 return NULL; 465 } 466 config_key_join(ATTR_NS_PREFIX, true); 467 config_key_join(".", false); 468 config_key_join(ns_name, false); 469 config_key_join(".", false); 470 config_key_join(ATTR_NS_ASAN, false); 471 config_key_join(".", false); 472 char *key = config_key_join(ATTR_NS_LIB_PATHS, false); 473 return config_get_value(key); 474} 475 476/* parse config, success 0, failure <0 */ 477static int config_parse(const char *file_path, const char *exe_path) 478{ 479 kvlist* dirkvs; 480 kvlist* acquiescence_kvs; 481 if (!exe_path) return -1; 482 g_configor.exe_path = ld_strdup(exe_path); 483 const char * fpath = CONFIG_DEFAULT_FILE; 484 if (file_path) fpath = file_path; 485 g_configor.file_path = ld_strdup(fpath); 486 g_configor.sections = config_load(fpath); 487 488 if (!g_configor.sections) { 489 LD_LOGD("config_parse load ini config fail!"); 490 return -2; 491 } 492 dirkvs = config_get_kvs(SECTION_DIR_MAP); 493 acquiescence_kvs = config_get_kvs(ATTR_NS_ACQUIESCENCE); 494 if (!dirkvs || !acquiescence_kvs) { 495 LD_LOGD("config_parse get dirkvs or acquiescence_kvs fail!"); 496 return -3; /* no section directory map or acquiescence section found */ 497 } 498 g_configor.config_sys_path = config_get_acquiescence_lib_path(acquiescence_kvs); 499 g_configor.config_asan_sys_path = config_get_acquiescence_asan_lib_path(acquiescence_kvs); 500 size_t i; 501 char * sname = NULL; 502 for (i = 0; i < dirkvs->num; i++) { 503 strlist * paths = strsplit(dirkvs->val[i], ":"); 504 if (paths) { 505 size_t j; 506 for (j = 0; j < paths->num; j++) { 507 if (!strcmp(paths->strs[j], exe_path)) break; 508 } 509 if (j < paths->num) sname = dirkvs->key[i]; 510 } 511 strlist_free(paths); 512 if (sname) break; 513 } 514 if (!sname) { 515 /* No matched section found, use the default section. */ 516 sname = ATTR_NS_ACQUIESCENCE; 517 LD_LOGD("config_parse no section found!"); 518 } 519 if (!(g_configor.kvs = config_get_kvs(sname))) { 520 LD_LOGD("config_parse no section key-value list found!"); 521 return -5;/* no section key-value list found */ 522 } 523 524 char *default_lib_paths = config_get_lib_paths(ATTR_NS_DEFAULT); 525 if (default_lib_paths) { 526 g_configor.config_sys_path = default_lib_paths; 527 } else { 528 LD_LOGW("config_parse get default lib paths fail! Config namespace default lib paths,please!"); 529 } 530 char *default_asan_lib_paths = config_get_asan_lib_paths(ATTR_NS_DEFAULT); 531 if (default_asan_lib_paths) { 532 g_configor.config_asan_sys_path = default_asan_lib_paths; 533 } else { 534 LD_LOGW("config_parse get default asan lib paths fail! Config namespace default asan lib paths,please!"); 535 } 536 return 0; 537} 538 539/* get namespace names except default */ 540static strlist *config_get_namespaces() 541{ 542 char *key = config_key_join(ATTR_ADDED_NSLIST, true); 543 char *val = config_get_value(key); 544 return strsplit(val, ","); 545} 546 547/* get permitted paths */ 548static char *config_get_permitted_paths(const char *ns_name) 549{ 550 if (ns_name == NULL) { 551 return NULL; 552 } 553 config_key_join(ATTR_NS_PREFIX, true); 554 config_key_join(".", false); 555 config_key_join(ns_name, false); 556 config_key_join(".", false); 557 char *key = config_key_join(ATTR_NS_PERMITTED_PATHS, false); 558 return config_get_value(key); 559} 560 561/* get asan permitted paths */ 562static char *config_get_asan_permitted_paths(const char *ns_name) 563{ 564 if (ns_name == NULL) { 565 return NULL; 566 } 567 config_key_join(ATTR_NS_PREFIX, true); 568 config_key_join(".", false); 569 config_key_join(ns_name, false); 570 config_key_join(".", false); 571 config_key_join(ATTR_NS_ASAN, false); 572 config_key_join(".", false); 573 char *key = config_key_join(ATTR_NS_PERMITTED_PATHS, false); 574 return config_get_value(key); 575} 576/* get inherited namespace names */ 577static strlist *config_get_inherits(const char *ns_name) 578{ 579 if (ns_name == NULL) { 580 return NULL; 581 } 582 config_key_join(ATTR_NS_PREFIX, true); 583 config_key_join(".", false); 584 config_key_join(ns_name, false); 585 config_key_join(".", false); 586 char *key = config_key_join(ATTR_NS_INHERITS, false); 587 char *val = config_get_value(key); 588 return strsplit(val, ","); 589} 590/* get separated */ 591static bool config_get_separated(const char *ns_name) 592{ 593 if (ns_name == NULL) { 594 return false; 595 } 596 config_key_join(ATTR_NS_PREFIX, true); 597 config_key_join(".", false); 598 config_key_join(ns_name, false); 599 config_key_join(".", false); 600 char *key = config_key_join(ATTR_NS_SEPARATED, false); 601 char *val = config_get_value(key); 602 strlwc(val); 603 if (val && !strcmp("true", val)) return true; 604 return false; /* default false */ 605} 606 607/* get allowed libs */ 608static char *config_get_allowed_libs(const char *ns_name) 609{ 610 if (ns_name == NULL) { 611 return NULL; 612 } 613 config_key_join(ATTR_NS_PREFIX, true); 614 config_key_join(".", false); 615 config_key_join(ns_name, false); 616 config_key_join(".", false); 617 char *key = config_key_join(ATTR_NS_ALLOWED_LIBS, false); 618 return config_get_value(key); 619} 620/* get shared libs by inherited namespace */ 621static char *config_get_inherit_shared_libs(const char *ns_name, const char *inherited_ns_name) 622{ 623 if (ns_name == NULL || inherited_ns_name == NULL) { 624 return NULL; 625 } 626 config_key_join(ATTR_NS_PREFIX, true); 627 config_key_join(".", false); 628 config_key_join(ns_name, false); 629 config_key_join(".inherit.", false); 630 config_key_join(inherited_ns_name, false); 631 config_key_join(".", false); 632 char *key = config_key_join(ATTR_NS_INHERIT_SHARED_LIBS, false); 633 return config_get_value(key); 634} 635 636/* The call time is after parse */ 637static char *config_get_sys_paths(void) 638{ 639 return g_configor.config_sys_path; 640} 641static char *config_get_asan_sys_paths(void) 642{ 643 return g_configor.config_asan_sys_path; 644} 645ns_configor *configor_init() 646{ 647 memset(&g_configor, 0, sizeof g_configor); 648 g_configor.set_error_callback = config_set_error_callback; 649 g_configor.parse = config_parse; 650 g_configor.get_namespaces = config_get_namespaces; 651 g_configor.get_lib_paths = config_get_lib_paths; 652 g_configor.get_asan_lib_paths = config_get_asan_lib_paths; 653 g_configor.get_permitted_paths = config_get_permitted_paths; 654 g_configor.get_asan_permitted_paths = config_get_asan_permitted_paths; 655 g_configor.get_separated = config_get_separated; 656 g_configor.get_inherits = config_get_inherits; 657 g_configor.get_allowed_libs = config_get_allowed_libs; 658 g_configor.get_inherit_shared_libs = config_get_inherit_shared_libs; 659 g_configor.get_sys_paths = config_get_sys_paths; 660 g_configor.get_asan_sys_paths = config_get_asan_sys_paths; 661 g_configor.config_sys_path = NULL; // init it in config_parse. 662 g_configor.config_asan_sys_path = NULL; // init it in config_parse. 663 return &g_configor; 664} 665 666void configor_free() 667{ 668 if (g_configor.sections) { 669 sections_free(g_configor.sections); 670 g_configor.sections = NULL; 671 } 672 if (g_configor.file_path) { 673 __libc_free(g_configor.file_path); 674 g_configor.file_path = NULL; 675 } 676 if (g_configor.exe_path) { 677 __libc_free(g_configor.exe_path); 678 g_configor.exe_path = NULL; 679 } 680}