1 /* GDB routines for supporting auto-loaded scripts. 2 3 Copyright (C) 2012-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "auto-load.h" 22 #include "progspace.h" 23 #include "python/python.h" 24 #include "gdb_regex.h" 25 #include "ui-out.h" 26 #include "filenames.h" 27 #include "command.h" 28 #include "observer.h" 29 #include "objfiles.h" 30 #include "exceptions.h" 31 #include "cli/cli-script.h" 32 #include "gdbcmd.h" 33 #include "cli/cli-decode.h" 34 #include "cli/cli-setshow.h" 35 #include "gdb_vecs.h" 36 #include "readline/tilde.h" 37 #include "completer.h" 38 #include "observer.h" 39 #include "fnmatch.h" 40 #include "top.h" 41 42 /* The suffix of per-objfile scripts to auto-load as non-Python command files. 43 E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb. */ 44 #define GDB_AUTO_FILE_NAME "-gdb.gdb" 45 46 static void source_gdb_script_for_objfile (struct objfile *objfile, FILE *file, 47 const char *filename); 48 49 /* Value of the 'set debug auto-load' configuration variable. */ 50 static int debug_auto_load = 0; 51 52 /* "show" command for the debug_auto_load configuration variable. */ 53 54 static void 55 show_debug_auto_load (struct ui_file *file, int from_tty, 56 struct cmd_list_element *c, const char *value) 57 { 58 fprintf_filtered (file, _("Debugging output for files " 59 "of 'set auto-load ...' is %s.\n"), 60 value); 61 } 62 63 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME 64 scripts: 65 set auto-load gdb-scripts on|off 66 This is true if we should auto-load associated scripts when an objfile 67 is opened, false otherwise. */ 68 static int auto_load_gdb_scripts = 1; 69 70 /* "show" command for the auto_load_gdb_scripts configuration variable. */ 71 72 static void 73 show_auto_load_gdb_scripts (struct ui_file *file, int from_tty, 74 struct cmd_list_element *c, const char *value) 75 { 76 fprintf_filtered (file, _("Auto-loading of canned sequences of commands " 77 "scripts is %s.\n"), 78 value); 79 } 80 81 /* Internal-use flag to enable/disable auto-loading. 82 This is true if we should auto-load python code when an objfile is opened, 83 false otherwise. 84 85 Both auto_load_scripts && global_auto_load must be true to enable 86 auto-loading. 87 88 This flag exists to facilitate deferring auto-loading during start-up 89 until after ./.gdbinit has been read; it may augment the search directories 90 used to find the scripts. */ 91 int global_auto_load = 1; 92 93 /* Auto-load .gdbinit file from the current directory? */ 94 int auto_load_local_gdbinit = 1; 95 96 /* Absolute pathname to the current directory .gdbinit, if it exists. */ 97 char *auto_load_local_gdbinit_pathname = NULL; 98 99 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded. */ 100 int auto_load_local_gdbinit_loaded = 0; 101 102 /* "show" command for the auto_load_local_gdbinit configuration variable. */ 103 104 static void 105 show_auto_load_local_gdbinit (struct ui_file *file, int from_tty, 106 struct cmd_list_element *c, const char *value) 107 { 108 fprintf_filtered (file, _("Auto-loading of .gdbinit script from current " 109 "directory is %s.\n"), 110 value); 111 } 112 113 /* Directory list from which to load auto-loaded scripts. It is not checked 114 for absolute paths but they are strongly recommended. It is initialized by 115 _initialize_auto_load. */ 116 static char *auto_load_dir; 117 118 /* "set" command for the auto_load_dir configuration variable. */ 119 120 static void 121 set_auto_load_dir (char *args, int from_tty, struct cmd_list_element *c) 122 { 123 /* Setting the variable to "" resets it to the compile time defaults. */ 124 if (auto_load_dir[0] == '\0') 125 { 126 xfree (auto_load_dir); 127 auto_load_dir = xstrdup (AUTO_LOAD_DIR); 128 } 129 } 130 131 /* "show" command for the auto_load_dir configuration variable. */ 132 133 static void 134 show_auto_load_dir (struct ui_file *file, int from_tty, 135 struct cmd_list_element *c, const char *value) 136 { 137 fprintf_filtered (file, _("List of directories from which to load " 138 "auto-loaded scripts is %s.\n"), 139 value); 140 } 141 142 /* Directory list safe to hold auto-loaded files. It is not checked for 143 absolute paths but they are strongly recommended. It is initialized by 144 _initialize_auto_load. */ 145 static char *auto_load_safe_path; 146 147 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized 148 by tilde_expand and possibly each entries has added its gdb_realpath 149 counterpart. */ 150 static VEC (char_ptr) *auto_load_safe_path_vec; 151 152 /* Expand $datadir and $debugdir in STRING according to the rules of 153 substitute_path_component. Return vector from dirnames_to_char_ptr_vec, 154 this vector must be freed by free_char_ptr_vec by the caller. */ 155 156 static VEC (char_ptr) * 157 auto_load_expand_dir_vars (const char *string) 158 { 159 VEC (char_ptr) *dir_vec; 160 char *s; 161 162 s = xstrdup (string); 163 substitute_path_component (&s, "$datadir", gdb_datadir); 164 substitute_path_component (&s, "$debugdir", debug_file_directory); 165 166 if (debug_auto_load && strcmp (s, string) != 0) 167 fprintf_unfiltered (gdb_stdlog, 168 _("auto-load: Expanded $-variables to \"%s\".\n"), s); 169 170 dir_vec = dirnames_to_char_ptr_vec (s); 171 xfree(s); 172 173 return dir_vec; 174 } 175 176 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */ 177 178 static void 179 auto_load_safe_path_vec_update (void) 180 { 181 unsigned len; 182 int ix; 183 184 if (debug_auto_load) 185 fprintf_unfiltered (gdb_stdlog, 186 _("auto-load: Updating directories of \"%s\".\n"), 187 auto_load_safe_path); 188 189 free_char_ptr_vec (auto_load_safe_path_vec); 190 191 auto_load_safe_path_vec = auto_load_expand_dir_vars (auto_load_safe_path); 192 len = VEC_length (char_ptr, auto_load_safe_path_vec); 193 194 /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC 195 element. */ 196 for (ix = 0; ix < len; ix++) 197 { 198 char *dir = VEC_index (char_ptr, auto_load_safe_path_vec, ix); 199 char *expanded = tilde_expand (dir); 200 char *real_path = gdb_realpath (expanded); 201 202 /* Ensure the current entry is at least tilde_expand-ed. */ 203 VEC_replace (char_ptr, auto_load_safe_path_vec, ix, expanded); 204 205 if (debug_auto_load) 206 { 207 if (strcmp (expanded, dir) == 0) 208 fprintf_unfiltered (gdb_stdlog, 209 _("auto-load: Using directory \"%s\".\n"), 210 expanded); 211 else 212 fprintf_unfiltered (gdb_stdlog, 213 _("auto-load: Resolved directory \"%s\" " 214 "as \"%s\".\n"), 215 dir, expanded); 216 } 217 xfree (dir); 218 219 /* If gdb_realpath returns a different content, append it. */ 220 if (strcmp (real_path, expanded) == 0) 221 xfree (real_path); 222 else 223 { 224 VEC_safe_push (char_ptr, auto_load_safe_path_vec, real_path); 225 226 if (debug_auto_load) 227 fprintf_unfiltered (gdb_stdlog, 228 _("auto-load: And canonicalized as \"%s\".\n"), 229 real_path); 230 } 231 } 232 } 233 234 /* Variable gdb_datadir has been set. Update content depending on $datadir. */ 235 236 static void 237 auto_load_gdb_datadir_changed (void) 238 { 239 auto_load_safe_path_vec_update (); 240 } 241 242 /* "set" command for the auto_load_safe_path configuration variable. */ 243 244 static void 245 set_auto_load_safe_path (char *args, int from_tty, struct cmd_list_element *c) 246 { 247 /* Setting the variable to "" resets it to the compile time defaults. */ 248 if (auto_load_safe_path[0] == '\0') 249 { 250 xfree (auto_load_safe_path); 251 auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH); 252 } 253 254 auto_load_safe_path_vec_update (); 255 } 256 257 /* "show" command for the auto_load_safe_path configuration variable. */ 258 259 static void 260 show_auto_load_safe_path (struct ui_file *file, int from_tty, 261 struct cmd_list_element *c, const char *value) 262 { 263 const char *cs; 264 265 /* Check if user has entered either "/" or for example ":". 266 But while more complicate content like ":/foo" would still also 267 permit any location do not hide those. */ 268 269 for (cs = value; *cs && (*cs == DIRNAME_SEPARATOR || IS_DIR_SEPARATOR (*cs)); 270 cs++); 271 if (*cs == 0) 272 fprintf_filtered (file, _("Auto-load files are safe to load from any " 273 "directory.\n")); 274 else 275 fprintf_filtered (file, _("List of directories from which it is safe to " 276 "auto-load files is %s.\n"), 277 value); 278 } 279 280 /* "add-auto-load-safe-path" command for the auto_load_safe_path configuration 281 variable. */ 282 283 static void 284 add_auto_load_safe_path (char *args, int from_tty) 285 { 286 char *s; 287 288 if (args == NULL || *args == 0) 289 error (_("\ 290 Directory argument required.\n\ 291 Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\ 292 ")); 293 294 s = xstrprintf ("%s%c%s", auto_load_safe_path, DIRNAME_SEPARATOR, args); 295 xfree (auto_load_safe_path); 296 auto_load_safe_path = s; 297 298 auto_load_safe_path_vec_update (); 299 } 300 301 /* Implementation for filename_is_in_pattern overwriting the caller's FILENAME 302 and PATTERN. */ 303 304 static int 305 filename_is_in_pattern_1 (char *filename, char *pattern) 306 { 307 size_t pattern_len = strlen (pattern); 308 size_t filename_len = strlen (filename); 309 310 if (debug_auto_load) 311 fprintf_unfiltered (gdb_stdlog, _("auto-load: Matching file \"%s\" " 312 "to pattern \"%s\"\n"), 313 filename, pattern); 314 315 /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as 316 trailing slashes are trimmed also from FILENAME it still matches 317 correctly. */ 318 while (pattern_len && IS_DIR_SEPARATOR (pattern[pattern_len - 1])) 319 pattern_len--; 320 pattern[pattern_len] = '\0'; 321 322 /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows 323 platform FILENAME even after gdb_realpath does not have to start with 324 IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */ 325 if (pattern_len == 0) 326 { 327 if (debug_auto_load) 328 fprintf_unfiltered (gdb_stdlog, 329 _("auto-load: Matched - empty pattern\n")); 330 return 1; 331 } 332 333 for (;;) 334 { 335 /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the 336 same way so they will match. */ 337 while (filename_len && IS_DIR_SEPARATOR (filename[filename_len - 1])) 338 filename_len--; 339 filename[filename_len] = '\0'; 340 if (filename_len == 0) 341 { 342 if (debug_auto_load) 343 fprintf_unfiltered (gdb_stdlog, 344 _("auto-load: Not matched - pattern \"%s\".\n"), 345 pattern); 346 return 0; 347 } 348 349 if (gdb_filename_fnmatch (pattern, filename, FNM_FILE_NAME | FNM_NOESCAPE) 350 == 0) 351 { 352 if (debug_auto_load) 353 fprintf_unfiltered (gdb_stdlog, _("auto-load: Matched - file " 354 "\"%s\" to pattern \"%s\".\n"), 355 filename, pattern); 356 return 1; 357 } 358 359 /* Trim trailing FILENAME component. */ 360 while (filename_len > 0 && !IS_DIR_SEPARATOR (filename[filename_len - 1])) 361 filename_len--; 362 } 363 } 364 365 /* Return 1 if FILENAME matches PATTERN or if FILENAME resides in 366 a subdirectory of a directory that matches PATTERN. Return 0 otherwise. 367 gdb_realpath normalization is never done here. */ 368 369 static ATTRIBUTE_PURE int 370 filename_is_in_pattern (const char *filename, const char *pattern) 371 { 372 char *filename_copy, *pattern_copy; 373 374 filename_copy = alloca (strlen (filename) + 1); 375 strcpy (filename_copy, filename); 376 pattern_copy = alloca (strlen (pattern) + 1); 377 strcpy (pattern_copy, pattern); 378 379 return filename_is_in_pattern_1 (filename_copy, pattern_copy); 380 } 381 382 /* Return 1 if FILENAME belongs to one of directory components of 383 AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise. 384 auto_load_safe_path_vec_update is never called. 385 *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be 386 freed by the caller. */ 387 388 static int 389 filename_is_in_auto_load_safe_path_vec (const char *filename, 390 char **filename_realp) 391 { 392 char *pattern; 393 int ix; 394 395 for (ix = 0; VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, pattern); 396 ++ix) 397 if (*filename_realp == NULL && filename_is_in_pattern (filename, pattern)) 398 break; 399 400 if (pattern == NULL) 401 { 402 if (*filename_realp == NULL) 403 { 404 *filename_realp = gdb_realpath (filename); 405 if (debug_auto_load && strcmp (*filename_realp, filename) != 0) 406 fprintf_unfiltered (gdb_stdlog, 407 _("auto-load: Resolved " 408 "file \"%s\" as \"%s\".\n"), 409 filename, *filename_realp); 410 } 411 412 if (strcmp (*filename_realp, filename) != 0) 413 for (ix = 0; 414 VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, pattern); ++ix) 415 if (filename_is_in_pattern (*filename_realp, pattern)) 416 break; 417 } 418 419 if (pattern != NULL) 420 { 421 if (debug_auto_load) 422 fprintf_unfiltered (gdb_stdlog, _("auto-load: File \"%s\" matches " 423 "directory \"%s\".\n"), 424 filename, pattern); 425 return 1; 426 } 427 428 return 0; 429 } 430 431 /* Return 1 if FILENAME is located in one of the directories of 432 AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does 433 not have to be an absolute path. 434 435 Existence of FILENAME is not checked. Function will still give a warning 436 even if the caller would quietly skip non-existing file in unsafe 437 directory. */ 438 439 int 440 file_is_auto_load_safe (const char *filename, const char *debug_fmt, ...) 441 { 442 char *filename_real = NULL; 443 struct cleanup *back_to; 444 static int advice_printed = 0; 445 446 if (debug_auto_load) 447 { 448 va_list debug_args; 449 450 va_start (debug_args, debug_fmt); 451 vfprintf_unfiltered (gdb_stdlog, debug_fmt, debug_args); 452 va_end (debug_args); 453 } 454 455 back_to = make_cleanup (free_current_contents, &filename_real); 456 457 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real)) 458 { 459 do_cleanups (back_to); 460 return 1; 461 } 462 463 auto_load_safe_path_vec_update (); 464 if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real)) 465 { 466 do_cleanups (back_to); 467 return 1; 468 } 469 470 warning (_("File \"%s\" auto-loading has been declined by your " 471 "`auto-load safe-path' set to \"%s\"."), 472 filename_real, auto_load_safe_path); 473 474 if (!advice_printed) 475 { 476 const char *homedir = getenv ("HOME"); 477 char *homeinit; 478 479 if (homedir == NULL) 480 homedir = "$HOME"; 481 homeinit = xstrprintf ("%s/%s", homedir, gdbinit); 482 make_cleanup (xfree, homeinit); 483 484 printf_filtered (_("\ 485 To enable execution of this file add\n\ 486 \tadd-auto-load-safe-path %s\n\ 487 line to your configuration file \"%s\".\n\ 488 To completely disable this security protection add\n\ 489 \tset auto-load safe-path /\n\ 490 line to your configuration file \"%s\".\n\ 491 For more information about this security protection see the\n\ 492 \"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\ 493 \tinfo \"(gdb)Auto-loading safe path\"\n"), 494 filename_real, homeinit, homeinit); 495 advice_printed = 1; 496 } 497 498 do_cleanups (back_to); 499 return 0; 500 } 501 502 /* Definition of script language for GDB canned sequences of commands. */ 503 504 static const struct script_language script_language_gdb 505 = { GDB_AUTO_FILE_NAME, source_gdb_script_for_objfile }; 506 507 static void 508 source_gdb_script_for_objfile (struct objfile *objfile, FILE *file, 509 const char *filename) 510 { 511 int is_safe; 512 struct auto_load_pspace_info *pspace_info; 513 volatile struct gdb_exception e; 514 515 is_safe = file_is_auto_load_safe (filename, _("auto-load: Loading canned " 516 "sequences of commands script " 517 "\"%s\" for objfile \"%s\".\n"), 518 filename, objfile->name); 519 520 /* Add this script to the hash table too so "info auto-load gdb-scripts" 521 can print it. */ 522 pspace_info = get_auto_load_pspace_data_for_loading (current_program_space); 523 maybe_add_script (pspace_info, is_safe, filename, filename, 524 &script_language_gdb); 525 526 if (!is_safe) 527 return; 528 529 TRY_CATCH (e, RETURN_MASK_ALL) 530 { 531 script_from_file (file, filename); 532 } 533 exception_print (gdb_stderr, e); 534 } 535 536 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load 537 the same script. There's no point in loading the script multiple times, 538 and there can be a lot of objfiles and scripts, so we keep track of scripts 539 loaded this way. */ 540 541 struct auto_load_pspace_info 542 { 543 /* For each program space we keep track of loaded scripts. */ 544 struct htab *loaded_scripts; 545 546 /* Non-zero if we've issued the warning about an auto-load script not being 547 found. We only want to issue this warning once. */ 548 int script_not_found_warning_printed; 549 }; 550 551 /* Objects of this type are stored in the loaded script hash table. */ 552 553 struct loaded_script 554 { 555 /* Name as provided by the objfile. */ 556 const char *name; 557 558 /* Full path name or NULL if script wasn't found (or was otherwise 559 inaccessible). */ 560 const char *full_path; 561 562 /* Non-zero if this script has been loaded. */ 563 int loaded; 564 565 const struct script_language *language; 566 }; 567 568 /* Per-program-space data key. */ 569 static const struct program_space_data *auto_load_pspace_data; 570 571 static void 572 auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg) 573 { 574 struct auto_load_pspace_info *info; 575 576 info = program_space_data (pspace, auto_load_pspace_data); 577 if (info != NULL) 578 { 579 if (info->loaded_scripts) 580 htab_delete (info->loaded_scripts); 581 xfree (info); 582 } 583 } 584 585 /* Get the current autoload data. If none is found yet, add it now. This 586 function always returns a valid object. */ 587 588 static struct auto_load_pspace_info * 589 get_auto_load_pspace_data (struct program_space *pspace) 590 { 591 struct auto_load_pspace_info *info; 592 593 info = program_space_data (pspace, auto_load_pspace_data); 594 if (info == NULL) 595 { 596 info = XZALLOC (struct auto_load_pspace_info); 597 set_program_space_data (pspace, auto_load_pspace_data, info); 598 } 599 600 return info; 601 } 602 603 /* Hash function for the loaded script hash. */ 604 605 static hashval_t 606 hash_loaded_script_entry (const void *data) 607 { 608 const struct loaded_script *e = data; 609 610 return htab_hash_string (e->name) ^ htab_hash_pointer (e->language); 611 } 612 613 /* Equality function for the loaded script hash. */ 614 615 static int 616 eq_loaded_script_entry (const void *a, const void *b) 617 { 618 const struct loaded_script *ea = a; 619 const struct loaded_script *eb = b; 620 621 return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language; 622 } 623 624 /* Initialize the table to track loaded scripts. 625 Each entry is hashed by the full path name. */ 626 627 static void 628 init_loaded_scripts_info (struct auto_load_pspace_info *pspace_info) 629 { 630 /* Choose 31 as the starting size of the hash table, somewhat arbitrarily. 631 Space for each entry is obtained with one malloc so we can free them 632 easily. */ 633 634 pspace_info->loaded_scripts = htab_create (31, 635 hash_loaded_script_entry, 636 eq_loaded_script_entry, 637 xfree); 638 639 pspace_info->script_not_found_warning_printed = FALSE; 640 } 641 642 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table 643 for loading scripts. */ 644 645 struct auto_load_pspace_info * 646 get_auto_load_pspace_data_for_loading (struct program_space *pspace) 647 { 648 struct auto_load_pspace_info *info; 649 650 info = get_auto_load_pspace_data (pspace); 651 if (info->loaded_scripts == NULL) 652 init_loaded_scripts_info (info); 653 654 return info; 655 } 656 657 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the 658 script has been (is going to) be loaded, 0 otherwise (such as if it has not 659 been found). FULL_PATH is NULL if the script wasn't found. The result is 660 true if the script was already in the hash table. */ 661 662 int 663 maybe_add_script (struct auto_load_pspace_info *pspace_info, int loaded, 664 const char *name, const char *full_path, 665 const struct script_language *language) 666 { 667 struct htab *htab = pspace_info->loaded_scripts; 668 struct loaded_script **slot, entry; 669 int in_hash_table; 670 671 entry.name = name; 672 entry.language = language; 673 slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT); 674 in_hash_table = *slot != NULL; 675 676 /* If this script is not in the hash table, add it. */ 677 678 if (! in_hash_table) 679 { 680 char *p; 681 682 /* Allocate all space in one chunk so it's easier to free. */ 683 *slot = xmalloc (sizeof (**slot) 684 + strlen (name) + 1 685 + (full_path != NULL ? (strlen (full_path) + 1) : 0)); 686 p = ((char*) *slot) + sizeof (**slot); 687 strcpy (p, name); 688 (*slot)->name = p; 689 if (full_path != NULL) 690 { 691 p += strlen (p) + 1; 692 strcpy (p, full_path); 693 (*slot)->full_path = p; 694 } 695 else 696 (*slot)->full_path = NULL; 697 (*slot)->loaded = loaded; 698 (*slot)->language = language; 699 } 700 701 return in_hash_table; 702 } 703 704 /* Clear the table of loaded section scripts. */ 705 706 static void 707 clear_section_scripts (void) 708 { 709 struct program_space *pspace = current_program_space; 710 struct auto_load_pspace_info *info; 711 712 info = program_space_data (pspace, auto_load_pspace_data); 713 if (info != NULL && info->loaded_scripts != NULL) 714 { 715 htab_delete (info->loaded_scripts); 716 info->loaded_scripts = NULL; 717 info->script_not_found_warning_printed = FALSE; 718 } 719 } 720 721 /* Look for the auto-load script in LANGUAGE associated with OBJFILE where 722 OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any 723 matching script, return 0 otherwise. */ 724 725 static int 726 auto_load_objfile_script_1 (struct objfile *objfile, const char *realname, 727 const struct script_language *language) 728 { 729 char *filename, *debugfile; 730 int len, retval; 731 FILE *input; 732 struct cleanup *cleanups; 733 734 len = strlen (realname); 735 filename = xmalloc (len + strlen (language->suffix) + 1); 736 memcpy (filename, realname, len); 737 strcpy (filename + len, language->suffix); 738 739 cleanups = make_cleanup (xfree, filename); 740 741 input = fopen (filename, "r"); 742 debugfile = filename; 743 if (debug_auto_load) 744 fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file \"%s\" %s.\n"), 745 debugfile, input ? _("exists") : _("does not exist")); 746 747 if (!input) 748 { 749 VEC (char_ptr) *vec; 750 int ix; 751 char *dir; 752 753 /* Also try the same file in a subdirectory of gdb's data 754 directory. */ 755 756 vec = auto_load_expand_dir_vars (auto_load_dir); 757 make_cleanup_free_char_ptr_vec (vec); 758 759 if (debug_auto_load) 760 fprintf_unfiltered (gdb_stdlog, _("auto-load: Searching 'set auto-load " 761 "scripts-directory' path \"%s\".\n"), 762 auto_load_dir); 763 764 for (ix = 0; VEC_iterate (char_ptr, vec, ix, dir); ++ix) 765 { 766 debugfile = xmalloc (strlen (dir) + strlen (filename) + 1); 767 strcpy (debugfile, dir); 768 769 /* FILENAME is absolute, so we don't need a "/" here. */ 770 strcat (debugfile, filename); 771 772 make_cleanup (xfree, debugfile); 773 input = fopen (debugfile, "r"); 774 if (debug_auto_load) 775 fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file " 776 "\"%s\" %s.\n"), 777 debugfile, 778 input ? _("exists") : _("does not exist")); 779 if (input != NULL) 780 break; 781 } 782 } 783 784 if (input) 785 { 786 make_cleanup_fclose (input); 787 788 /* To preserve existing behaviour we don't check for whether the 789 script was already in the table, and always load it. 790 It's highly unlikely that we'd ever load it twice, 791 and these scripts are required to be idempotent under multiple 792 loads anyway. */ 793 language->source_script_for_objfile (objfile, input, debugfile); 794 795 retval = 1; 796 } 797 else 798 retval = 0; 799 800 do_cleanups (cleanups); 801 return retval; 802 } 803 804 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load 805 it. */ 806 807 void 808 auto_load_objfile_script (struct objfile *objfile, 809 const struct script_language *language) 810 { 811 char *realname = gdb_realpath (objfile->name); 812 struct cleanup *cleanups = make_cleanup (xfree, realname); 813 814 if (!auto_load_objfile_script_1 (objfile, realname, language)) 815 { 816 /* For Windows/DOS .exe executables, strip the .exe suffix, so that 817 FOO-gdb.gdb could be used for FOO.exe, and try again. */ 818 819 size_t len = strlen (realname); 820 const size_t lexe = sizeof (".exe") - 1; 821 822 if (len > lexe && strcasecmp (realname + len - lexe, ".exe") == 0) 823 { 824 len -= lexe; 825 realname[len] = '\0'; 826 if (debug_auto_load) 827 fprintf_unfiltered (gdb_stdlog, _("auto-load: Stripped .exe suffix, " 828 "retrying with \"%s\".\n"), 829 realname); 830 auto_load_objfile_script_1 (objfile, realname, language); 831 } 832 } 833 834 do_cleanups (cleanups); 835 } 836 837 /* Load any auto-loaded scripts for OBJFILE. */ 838 839 void 840 load_auto_scripts_for_objfile (struct objfile *objfile) 841 { 842 if (!global_auto_load) 843 return; 844 845 if (auto_load_gdb_scripts) 846 auto_load_objfile_script (objfile, &script_language_gdb); 847 848 gdbpy_load_auto_scripts_for_objfile (objfile); 849 } 850 851 /* This is a new_objfile observer callback to auto-load scripts. 852 853 Two flavors of auto-loaded scripts are supported. 854 1) based on the path to the objfile 855 2) from .debug_gdb_scripts section */ 856 857 static void 858 auto_load_new_objfile (struct objfile *objfile) 859 { 860 if (!objfile) 861 { 862 /* OBJFILE is NULL when loading a new "main" symbol-file. */ 863 clear_section_scripts (); 864 return; 865 } 866 867 load_auto_scripts_for_objfile (objfile); 868 } 869 870 /* Collect scripts to be printed in a vec. */ 871 872 typedef struct loaded_script *loaded_script_ptr; 873 DEF_VEC_P (loaded_script_ptr); 874 875 struct collect_matching_scripts_data 876 { 877 VEC (loaded_script_ptr) **scripts_p; 878 879 const struct script_language *language; 880 }; 881 882 /* Traversal function for htab_traverse. 883 Collect the entry if it matches the regexp. */ 884 885 static int 886 collect_matching_scripts (void **slot, void *info) 887 { 888 struct loaded_script *script = *slot; 889 struct collect_matching_scripts_data *data = info; 890 891 if (script->language == data->language && re_exec (script->name)) 892 VEC_safe_push (loaded_script_ptr, *data->scripts_p, script); 893 894 return 1; 895 } 896 897 /* Print SCRIPT. */ 898 899 static void 900 print_script (struct loaded_script *script) 901 { 902 struct ui_out *uiout = current_uiout; 903 struct cleanup *chain; 904 905 chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 906 907 ui_out_field_string (uiout, "loaded", script->loaded ? "Yes" : "No"); 908 ui_out_field_string (uiout, "script", script->name); 909 ui_out_text (uiout, "\n"); 910 911 /* If the name isn't the full path, print it too. */ 912 if (script->full_path != NULL 913 && strcmp (script->name, script->full_path) != 0) 914 { 915 ui_out_text (uiout, "\tfull name: "); 916 ui_out_field_string (uiout, "full_path", script->full_path); 917 ui_out_text (uiout, "\n"); 918 } 919 920 do_cleanups (chain); 921 } 922 923 /* Helper for info_auto_load_scripts to sort the scripts by name. */ 924 925 static int 926 sort_scripts_by_name (const void *ap, const void *bp) 927 { 928 const struct loaded_script *a = *(const struct loaded_script **) ap; 929 const struct loaded_script *b = *(const struct loaded_script **) bp; 930 931 return FILENAME_CMP (a->name, b->name); 932 } 933 934 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify 935 the "info auto-load XXX" command has been executed through the general 936 "info auto-load" invocation. Extra newline will be printed if needed. */ 937 char auto_load_info_scripts_pattern_nl[] = ""; 938 939 /* Implementation for "info auto-load gdb-scripts" 940 (and "info auto-load python-scripts"). List scripts in LANGUAGE matching 941 PATTERN. FROM_TTY is the usual GDB boolean for user interactivity. */ 942 943 void 944 auto_load_info_scripts (char *pattern, int from_tty, 945 const struct script_language *language) 946 { 947 struct ui_out *uiout = current_uiout; 948 struct auto_load_pspace_info *pspace_info; 949 struct cleanup *script_chain; 950 VEC (loaded_script_ptr) *scripts; 951 int nr_scripts; 952 953 dont_repeat (); 954 955 pspace_info = get_auto_load_pspace_data (current_program_space); 956 957 if (pattern && *pattern) 958 { 959 char *re_err = re_comp (pattern); 960 961 if (re_err) 962 error (_("Invalid regexp: %s"), re_err); 963 } 964 else 965 { 966 re_comp (""); 967 } 968 969 /* We need to know the number of rows before we build the table. 970 Plus we want to sort the scripts by name. 971 So first traverse the hash table collecting the matching scripts. */ 972 973 scripts = VEC_alloc (loaded_script_ptr, 10); 974 script_chain = make_cleanup (VEC_cleanup (loaded_script_ptr), &scripts); 975 976 if (pspace_info != NULL && pspace_info->loaded_scripts != NULL) 977 { 978 struct collect_matching_scripts_data data = { &scripts, language }; 979 980 /* Pass a pointer to scripts as VEC_safe_push can realloc space. */ 981 htab_traverse_noresize (pspace_info->loaded_scripts, 982 collect_matching_scripts, &data); 983 } 984 985 nr_scripts = VEC_length (loaded_script_ptr, scripts); 986 987 /* Table header shifted right by preceding "gdb-scripts: " would not match 988 its columns. */ 989 if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl) 990 ui_out_text (uiout, "\n"); 991 992 make_cleanup_ui_out_table_begin_end (uiout, 2, nr_scripts, 993 "AutoLoadedScriptsTable"); 994 995 ui_out_table_header (uiout, 7, ui_left, "loaded", "Loaded"); 996 ui_out_table_header (uiout, 70, ui_left, "script", "Script"); 997 ui_out_table_body (uiout); 998 999 if (nr_scripts > 0) 1000 { 1001 int i; 1002 loaded_script_ptr script; 1003 1004 qsort (VEC_address (loaded_script_ptr, scripts), 1005 VEC_length (loaded_script_ptr, scripts), 1006 sizeof (loaded_script_ptr), sort_scripts_by_name); 1007 for (i = 0; VEC_iterate (loaded_script_ptr, scripts, i, script); ++i) 1008 print_script (script); 1009 } 1010 1011 do_cleanups (script_chain); 1012 1013 if (nr_scripts == 0) 1014 { 1015 if (pattern && *pattern) 1016 ui_out_message (uiout, 0, "No auto-load scripts matching %s.\n", 1017 pattern); 1018 else 1019 ui_out_message (uiout, 0, "No auto-load scripts.\n"); 1020 } 1021 } 1022 1023 /* Wrapper for "info auto-load gdb-scripts". */ 1024 1025 static void 1026 info_auto_load_gdb_scripts (char *pattern, int from_tty) 1027 { 1028 auto_load_info_scripts (pattern, from_tty, &script_language_gdb); 1029 } 1030 1031 /* Implement 'info auto-load local-gdbinit'. */ 1032 1033 static void 1034 info_auto_load_local_gdbinit (char *args, int from_tty) 1035 { 1036 if (auto_load_local_gdbinit_pathname == NULL) 1037 printf_filtered (_("Local .gdbinit file was not found.\n")); 1038 else if (auto_load_local_gdbinit_loaded) 1039 printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"), 1040 auto_load_local_gdbinit_pathname); 1041 else 1042 printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"), 1043 auto_load_local_gdbinit_pathname); 1044 } 1045 1046 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset 1047 before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED 1048 of PSPACE_INFO. */ 1049 1050 int 1051 script_not_found_warning_print (struct auto_load_pspace_info *pspace_info) 1052 { 1053 int retval = !pspace_info->script_not_found_warning_printed; 1054 1055 pspace_info->script_not_found_warning_printed = 1; 1056 1057 return retval; 1058 } 1059 1060 /* The only valid "set auto-load" argument is off|0|no|disable. */ 1061 1062 static void 1063 set_auto_load_cmd (char *args, int from_tty) 1064 { 1065 struct cmd_list_element *list; 1066 size_t length; 1067 1068 /* See parse_binary_operation in use by the sub-commands. */ 1069 1070 length = args ? strlen (args) : 0; 1071 1072 while (length > 0 && (args[length - 1] == ' ' || args[length - 1] == '\t')) 1073 length--; 1074 1075 if (length == 0 || (strncmp (args, "off", length) != 0 1076 && strncmp (args, "0", length) != 0 1077 && strncmp (args, "no", length) != 0 1078 && strncmp (args, "disable", length) != 0)) 1079 error (_("Valid is only global 'set auto-load no'; " 1080 "otherwise check the auto-load sub-commands.")); 1081 1082 for (list = *auto_load_set_cmdlist_get (); list != NULL; list = list->next) 1083 if (list->var_type == var_boolean) 1084 { 1085 gdb_assert (list->type == set_cmd); 1086 do_set_command (args, from_tty, list); 1087 } 1088 } 1089 1090 /* Initialize "set auto-load " commands prefix and return it. */ 1091 1092 struct cmd_list_element ** 1093 auto_load_set_cmdlist_get (void) 1094 { 1095 static struct cmd_list_element *retval; 1096 1097 if (retval == NULL) 1098 add_prefix_cmd ("auto-load", class_maintenance, set_auto_load_cmd, _("\ 1099 Auto-loading specific settings.\n\ 1100 Configure various auto-load-specific variables such as\n\ 1101 automatic loading of Python scripts."), 1102 &retval, "set auto-load ", 1103 1/*allow-unknown*/, &setlist); 1104 1105 return &retval; 1106 } 1107 1108 /* Command "show auto-load" displays summary of all the current 1109 "show auto-load " settings. */ 1110 1111 static void 1112 show_auto_load_cmd (char *args, int from_tty) 1113 { 1114 cmd_show_list (*auto_load_show_cmdlist_get (), from_tty, ""); 1115 } 1116 1117 /* Initialize "show auto-load " commands prefix and return it. */ 1118 1119 struct cmd_list_element ** 1120 auto_load_show_cmdlist_get (void) 1121 { 1122 static struct cmd_list_element *retval; 1123 1124 if (retval == NULL) 1125 add_prefix_cmd ("auto-load", class_maintenance, show_auto_load_cmd, _("\ 1126 Show auto-loading specific settings.\n\ 1127 Show configuration of various auto-load-specific variables such as\n\ 1128 automatic loading of Python scripts."), 1129 &retval, "show auto-load ", 1130 0/*allow-unknown*/, &showlist); 1131 1132 return &retval; 1133 } 1134 1135 /* Command "info auto-load" displays whether the various auto-load files have 1136 been loaded. This is reimplementation of cmd_show_list which inserts 1137 newlines at proper places. */ 1138 1139 static void 1140 info_auto_load_cmd (char *args, int from_tty) 1141 { 1142 struct cmd_list_element *list; 1143 struct cleanup *infolist_chain; 1144 struct ui_out *uiout = current_uiout; 1145 1146 infolist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "infolist"); 1147 1148 for (list = *auto_load_info_cmdlist_get (); list != NULL; list = list->next) 1149 { 1150 struct cleanup *option_chain 1151 = make_cleanup_ui_out_tuple_begin_end (uiout, "option"); 1152 1153 gdb_assert (!list->prefixlist); 1154 gdb_assert (list->type == not_set_cmd); 1155 1156 ui_out_field_string (uiout, "name", list->name); 1157 ui_out_text (uiout, ": "); 1158 cmd_func (list, auto_load_info_scripts_pattern_nl, from_tty); 1159 1160 /* Close the tuple. */ 1161 do_cleanups (option_chain); 1162 } 1163 1164 /* Close the tuple. */ 1165 do_cleanups (infolist_chain); 1166 } 1167 1168 /* Initialize "info auto-load " commands prefix and return it. */ 1169 1170 struct cmd_list_element ** 1171 auto_load_info_cmdlist_get (void) 1172 { 1173 static struct cmd_list_element *retval; 1174 1175 if (retval == NULL) 1176 add_prefix_cmd ("auto-load", class_info, info_auto_load_cmd, _("\ 1177 Print current status of auto-loaded files.\n\ 1178 Print whether various files like Python scripts or .gdbinit files have been\n\ 1179 found and/or loaded."), 1180 &retval, "info auto-load ", 1181 0/*allow-unknown*/, &infolist); 1182 1183 return &retval; 1184 } 1185 1186 void _initialize_auto_load (void); 1187 1188 void 1189 _initialize_auto_load (void) 1190 { 1191 struct cmd_list_element *cmd; 1192 char *scripts_directory_help; 1193 1194 auto_load_pspace_data 1195 = register_program_space_data_with_cleanup (NULL, 1196 auto_load_pspace_data_cleanup); 1197 1198 observer_attach_new_objfile (auto_load_new_objfile); 1199 1200 add_setshow_boolean_cmd ("gdb-scripts", class_support, 1201 &auto_load_gdb_scripts, _("\ 1202 Enable or disable auto-loading of canned sequences of commands scripts."), _("\ 1203 Show whether auto-loading of canned sequences of commands scripts is enabled."), 1204 _("\ 1205 If enabled, canned sequences of commands are loaded when the debugger reads\n\ 1206 an executable or shared library.\n\ 1207 This options has security implications for untrusted inferiors."), 1208 NULL, show_auto_load_gdb_scripts, 1209 auto_load_set_cmdlist_get (), 1210 auto_load_show_cmdlist_get ()); 1211 1212 add_cmd ("gdb-scripts", class_info, info_auto_load_gdb_scripts, 1213 _("Print the list of automatically loaded sequences of commands.\n\ 1214 Usage: info auto-load gdb-scripts [REGEXP]"), 1215 auto_load_info_cmdlist_get ()); 1216 1217 add_setshow_boolean_cmd ("local-gdbinit", class_support, 1218 &auto_load_local_gdbinit, _("\ 1219 Enable or disable auto-loading of .gdbinit script in current directory."), _("\ 1220 Show whether auto-loading .gdbinit script in current directory is enabled."), 1221 _("\ 1222 If enabled, canned sequences of commands are loaded when debugger starts\n\ 1223 from .gdbinit file in current directory. Such files are deprecated,\n\ 1224 use a script associated with inferior executable file instead.\n\ 1225 This options has security implications for untrusted inferiors."), 1226 NULL, show_auto_load_local_gdbinit, 1227 auto_load_set_cmdlist_get (), 1228 auto_load_show_cmdlist_get ()); 1229 1230 add_cmd ("local-gdbinit", class_info, info_auto_load_local_gdbinit, 1231 _("Print whether current directory .gdbinit file has been loaded.\n\ 1232 Usage: info auto-load local-gdbinit"), 1233 auto_load_info_cmdlist_get ()); 1234 1235 auto_load_dir = xstrdup (AUTO_LOAD_DIR); 1236 scripts_directory_help = xstrprintf ( 1237 #ifdef HAVE_PYTHON 1238 _("\ 1239 Automatically loaded Python scripts (named OBJFILE%s) and GDB scripts\n\ 1240 (named OBJFILE%s) are located in one of the directories listed by this\n\ 1241 option.\n\ 1242 %s"), 1243 GDBPY_AUTO_FILE_NAME, 1244 #else 1245 _("\ 1246 Automatically loaded GDB scripts (named OBJFILE%s) are located in one\n\ 1247 of the directories listed by this option.\n\ 1248 %s"), 1249 #endif 1250 GDB_AUTO_FILE_NAME, 1251 _("\ 1252 This option is ignored for the kinds of scripts \ 1253 having 'set auto-load ... off'.\n\ 1254 Directories listed here need to be present also \ 1255 in the 'set auto-load safe-path'\n\ 1256 option.")); 1257 add_setshow_optional_filename_cmd ("scripts-directory", class_support, 1258 &auto_load_dir, _("\ 1259 Set the list of directories from which to load auto-loaded scripts."), _("\ 1260 Show the list of directories from which to load auto-loaded scripts."), 1261 scripts_directory_help, 1262 set_auto_load_dir, show_auto_load_dir, 1263 auto_load_set_cmdlist_get (), 1264 auto_load_show_cmdlist_get ()); 1265 xfree (scripts_directory_help); 1266 1267 auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH); 1268 auto_load_safe_path_vec_update (); 1269 add_setshow_optional_filename_cmd ("safe-path", class_support, 1270 &auto_load_safe_path, _("\ 1271 Set the list of files and directories that are safe for auto-loading."), _("\ 1272 Show the list of files and directories that are safe for auto-loading."), _("\ 1273 Various files loaded automatically for the 'set auto-load ...' options must\n\ 1274 be located in one of the directories listed by this option. Warning will be\n\ 1275 printed and file will not be used otherwise.\n\ 1276 You can mix both directory and filename entries.\n\ 1277 Setting this parameter to an empty list resets it to its default value.\n\ 1278 Setting this parameter to '/' (without the quotes) allows any file\n\ 1279 for the 'set auto-load ...' options. Each path entry can be also shell\n\ 1280 wildcard pattern; '*' does not match directory separator.\n\ 1281 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\ 1282 This options has security implications for untrusted inferiors."), 1283 set_auto_load_safe_path, 1284 show_auto_load_safe_path, 1285 auto_load_set_cmdlist_get (), 1286 auto_load_show_cmdlist_get ()); 1287 observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed); 1288 1289 cmd = add_cmd ("add-auto-load-safe-path", class_support, 1290 add_auto_load_safe_path, 1291 _("Add entries to the list of directories from which it is safe " 1292 "to auto-load files.\n\ 1293 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\ 1294 access the current full list setting."), 1295 &cmdlist); 1296 set_cmd_completer (cmd, filename_completer); 1297 1298 add_setshow_boolean_cmd ("auto-load", class_maintenance, 1299 &debug_auto_load, _("\ 1300 Set auto-load verifications debugging."), _("\ 1301 Show auto-load verifications debugging."), _("\ 1302 When non-zero, debugging output for files of 'set auto-load ...'\n\ 1303 is displayed."), 1304 NULL, show_debug_auto_load, 1305 &setdebuglist, &showdebuglist); 1306 } 1307