/* GDB routines for supporting auto-loaded scripts.
- Copyright (C) 2012 Free Software Foundation, Inc.
+ Copyright (C) 2012-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "auto-load.h"
#include "progspace.h"
-#include "python/python.h"
#include "gdb_regex.h"
#include "ui-out.h"
#include "filenames.h"
#include "command.h"
#include "observer.h"
#include "objfiles.h"
-#include "exceptions.h"
#include "cli/cli-script.h"
#include "gdbcmd.h"
+#include "cli/cli-cmds.h"
#include "cli/cli-decode.h"
#include "cli/cli-setshow.h"
+#include "gdb_vecs.h"
+#include "readline/tilde.h"
+#include "completer.h"
+#include "fnmatch.h"
+#include "top.h"
+#include "filestuff.h"
+#include "extension.h"
+#include "gdb/section-scripts.h"
-/* The suffix of per-objfile scripts to auto-load as non-Python command files.
- E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb. */
-#define GDB_AUTO_FILE_NAME "-gdb.gdb"
+/* The section to look in for auto-loaded scripts (in file formats that
+ support sections).
+ Each entry in this section is a record that begins with a leading byte
+ identifying the record type.
+ At the moment we only support one record type: A leading byte of 1,
+ followed by the path of a python script to load. */
+#define AUTO_SECTION_NAME ".debug_gdb_scripts"
-static void source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
- const char *filename);
+static int maybe_add_script (struct auto_load_pspace_info *pspace_info,
+ int loaded, const char *name,
+ const char *full_path,
+ const struct extension_language_defn *language);
+
+static int unsupported_script_warning_print (struct auto_load_pspace_info *);
+
+static int script_not_found_warning_print (struct auto_load_pspace_info *);
+
+/* Value of the 'set debug auto-load' configuration variable. */
+static int debug_auto_load = 0;
+
+/* "show" command for the debug_auto_load configuration variable. */
+
+static void
+show_debug_auto_load (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Debugging output for files "
+ "of 'set auto-load ...' is %s.\n"),
+ value);
+}
/* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
scripts:
value);
}
+/* Return non-zero if auto-loading gdb scripts is enabled. */
+
+int
+auto_load_gdb_scripts_enabled (const struct extension_language_defn *extlang)
+{
+ return auto_load_gdb_scripts;
+}
+
/* Internal-use flag to enable/disable auto-loading.
This is true if we should auto-load python code when an objfile is opened,
false otherwise.
value);
}
-/* Definition of script language for GDB canned sequences of commands. */
+/* Directory list from which to load auto-loaded scripts. It is not checked
+ for absolute paths but they are strongly recommended. It is initialized by
+ _initialize_auto_load. */
+static char *auto_load_dir;
-static const struct script_language script_language_gdb
- = { GDB_AUTO_FILE_NAME, source_gdb_script_for_objfile };
+/* "set" command for the auto_load_dir configuration variable. */
static void
-source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
- const char *filename)
+set_auto_load_dir (char *args, int from_tty, struct cmd_list_element *c)
{
- struct auto_load_pspace_info *pspace_info;
- volatile struct gdb_exception e;
+ /* Setting the variable to "" resets it to the compile time defaults. */
+ if (auto_load_dir[0] == '\0')
+ {
+ xfree (auto_load_dir);
+ auto_load_dir = xstrdup (AUTO_LOAD_DIR);
+ }
+}
- /* Add this script to the hash table too so "info auto-load gdb-scripts"
- can print it. */
- pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
- maybe_add_script (pspace_info, filename, filename, &script_language_gdb);
+/* "show" command for the auto_load_dir configuration variable. */
+
+static void
+show_auto_load_dir (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("List of directories from which to load "
+ "auto-loaded scripts is %s.\n"),
+ value);
+}
+
+/* Directory list safe to hold auto-loaded files. It is not checked for
+ absolute paths but they are strongly recommended. It is initialized by
+ _initialize_auto_load. */
+static char *auto_load_safe_path;
+
+/* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
+ by tilde_expand and possibly each entries has added its gdb_realpath
+ counterpart. */
+static VEC (char_ptr) *auto_load_safe_path_vec;
+
+/* Expand $datadir and $debugdir in STRING according to the rules of
+ substitute_path_component. Return vector from dirnames_to_char_ptr_vec,
+ this vector must be freed by free_char_ptr_vec by the caller. */
+
+static VEC (char_ptr) *
+auto_load_expand_dir_vars (const char *string)
+{
+ VEC (char_ptr) *dir_vec;
+ char *s;
+
+ s = xstrdup (string);
+ substitute_path_component (&s, "$datadir", gdb_datadir);
+ substitute_path_component (&s, "$debugdir", debug_file_directory);
+
+ if (debug_auto_load && strcmp (s, string) != 0)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Expanded $-variables to \"%s\".\n"), s);
+
+ dir_vec = dirnames_to_char_ptr_vec (s);
+ xfree(s);
+
+ return dir_vec;
+}
+
+/* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH. */
+
+static void
+auto_load_safe_path_vec_update (void)
+{
+ unsigned len;
+ int ix;
+
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Updating directories of \"%s\".\n"),
+ auto_load_safe_path);
+
+ free_char_ptr_vec (auto_load_safe_path_vec);
+
+ auto_load_safe_path_vec = auto_load_expand_dir_vars (auto_load_safe_path);
+ len = VEC_length (char_ptr, auto_load_safe_path_vec);
+
+ /* Apply tilde_expand and gdb_realpath to each AUTO_LOAD_SAFE_PATH_VEC
+ element. */
+ for (ix = 0; ix < len; ix++)
+ {
+ char *dir = VEC_index (char_ptr, auto_load_safe_path_vec, ix);
+ char *expanded = tilde_expand (dir);
+ char *real_path = gdb_realpath (expanded);
+
+ /* Ensure the current entry is at least tilde_expand-ed. */
+ VEC_replace (char_ptr, auto_load_safe_path_vec, ix, expanded);
+
+ if (debug_auto_load)
+ {
+ if (strcmp (expanded, dir) == 0)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Using directory \"%s\".\n"),
+ expanded);
+ else
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Resolved directory \"%s\" "
+ "as \"%s\".\n"),
+ dir, expanded);
+ }
+ xfree (dir);
+
+ /* If gdb_realpath returns a different content, append it. */
+ if (strcmp (real_path, expanded) == 0)
+ xfree (real_path);
+ else
+ {
+ VEC_safe_push (char_ptr, auto_load_safe_path_vec, real_path);
+
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: And canonicalized as \"%s\".\n"),
+ real_path);
+ }
+ }
+}
+
+/* Variable gdb_datadir has been set. Update content depending on $datadir. */
+
+static void
+auto_load_gdb_datadir_changed (void)
+{
+ auto_load_safe_path_vec_update ();
+}
+
+/* "set" command for the auto_load_safe_path configuration variable. */
+
+static void
+set_auto_load_safe_path (char *args, int from_tty, struct cmd_list_element *c)
+{
+ /* Setting the variable to "" resets it to the compile time defaults. */
+ if (auto_load_safe_path[0] == '\0')
+ {
+ xfree (auto_load_safe_path);
+ auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH);
+ }
+
+ auto_load_safe_path_vec_update ();
+}
+
+/* "show" command for the auto_load_safe_path configuration variable. */
+
+static void
+show_auto_load_safe_path (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ const char *cs;
+
+ /* Check if user has entered either "/" or for example ":".
+ But while more complicate content like ":/foo" would still also
+ permit any location do not hide those. */
+
+ for (cs = value; *cs && (*cs == DIRNAME_SEPARATOR || IS_DIR_SEPARATOR (*cs));
+ cs++);
+ if (*cs == 0)
+ fprintf_filtered (file, _("Auto-load files are safe to load from any "
+ "directory.\n"));
+ else
+ fprintf_filtered (file, _("List of directories from which it is safe to "
+ "auto-load files is %s.\n"),
+ value);
+}
+
+/* "add-auto-load-safe-path" command for the auto_load_safe_path configuration
+ variable. */
+
+static void
+add_auto_load_safe_path (char *args, int from_tty)
+{
+ char *s;
+
+ if (args == NULL || *args == 0)
+ error (_("\
+Directory argument required.\n\
+Use 'set auto-load safe-path /' for disabling the auto-load safe-path security.\
+"));
+
+ s = xstrprintf ("%s%c%s", auto_load_safe_path, DIRNAME_SEPARATOR, args);
+ xfree (auto_load_safe_path);
+ auto_load_safe_path = s;
+
+ auto_load_safe_path_vec_update ();
+}
+
+/* "add-auto-load-scripts-directory" command for the auto_load_dir configuration
+ variable. */
+
+static void
+add_auto_load_dir (char *args, int from_tty)
+{
+ char *s;
+
+ if (args == NULL || *args == 0)
+ error (_("Directory argument required."));
+
+ s = xstrprintf ("%s%c%s", auto_load_dir, DIRNAME_SEPARATOR, args);
+ xfree (auto_load_dir);
+ auto_load_dir = s;
+}
+
+/* Implementation for filename_is_in_pattern overwriting the caller's FILENAME
+ and PATTERN. */
+
+static int
+filename_is_in_pattern_1 (char *filename, char *pattern)
+{
+ size_t pattern_len = strlen (pattern);
+ size_t filename_len = strlen (filename);
+
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: Matching file \"%s\" "
+ "to pattern \"%s\"\n"),
+ filename, pattern);
+
+ /* Trim trailing slashes ("/") from PATTERN. Even for "d:\" paths as
+ trailing slashes are trimmed also from FILENAME it still matches
+ correctly. */
+ while (pattern_len && IS_DIR_SEPARATOR (pattern[pattern_len - 1]))
+ pattern_len--;
+ pattern[pattern_len] = '\0';
+
+ /* Ensure auto_load_safe_path "/" matches any FILENAME. On MS-Windows
+ platform FILENAME even after gdb_realpath does not have to start with
+ IS_DIR_SEPARATOR character, such as the 'C:\x.exe' filename. */
+ if (pattern_len == 0)
+ {
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Matched - empty pattern\n"));
+ return 1;
+ }
+
+ for (;;)
+ {
+ /* Trim trailing slashes ("/"). PATTERN also has slashes trimmed the
+ same way so they will match. */
+ while (filename_len && IS_DIR_SEPARATOR (filename[filename_len - 1]))
+ filename_len--;
+ filename[filename_len] = '\0';
+ if (filename_len == 0)
+ {
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Not matched - pattern \"%s\".\n"),
+ pattern);
+ return 0;
+ }
+
+ if (gdb_filename_fnmatch (pattern, filename, FNM_FILE_NAME | FNM_NOESCAPE)
+ == 0)
+ {
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: Matched - file "
+ "\"%s\" to pattern \"%s\".\n"),
+ filename, pattern);
+ return 1;
+ }
+
+ /* Trim trailing FILENAME component. */
+ while (filename_len > 0 && !IS_DIR_SEPARATOR (filename[filename_len - 1]))
+ filename_len--;
+ }
+}
+
+/* Return 1 if FILENAME matches PATTERN or if FILENAME resides in
+ a subdirectory of a directory that matches PATTERN. Return 0 otherwise.
+ gdb_realpath normalization is never done here. */
+
+static ATTRIBUTE_PURE int
+filename_is_in_pattern (const char *filename, const char *pattern)
+{
+ char *filename_copy, *pattern_copy;
+
+ filename_copy = alloca (strlen (filename) + 1);
+ strcpy (filename_copy, filename);
+ pattern_copy = alloca (strlen (pattern) + 1);
+ strcpy (pattern_copy, pattern);
+
+ return filename_is_in_pattern_1 (filename_copy, pattern_copy);
+}
+
+/* Return 1 if FILENAME belongs to one of directory components of
+ AUTO_LOAD_SAFE_PATH_VEC. Return 0 otherwise.
+ auto_load_safe_path_vec_update is never called.
+ *FILENAME_REALP may be updated by gdb_realpath of FILENAME - it has to be
+ freed by the caller. */
+
+static int
+filename_is_in_auto_load_safe_path_vec (const char *filename,
+ char **filename_realp)
+{
+ char *pattern;
+ int ix;
+
+ for (ix = 0; VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, pattern);
+ ++ix)
+ if (*filename_realp == NULL && filename_is_in_pattern (filename, pattern))
+ break;
+
+ if (pattern == NULL)
+ {
+ if (*filename_realp == NULL)
+ {
+ *filename_realp = gdb_realpath (filename);
+ if (debug_auto_load && strcmp (*filename_realp, filename) != 0)
+ fprintf_unfiltered (gdb_stdlog,
+ _("auto-load: Resolved "
+ "file \"%s\" as \"%s\".\n"),
+ filename, *filename_realp);
+ }
+
+ if (strcmp (*filename_realp, filename) != 0)
+ for (ix = 0;
+ VEC_iterate (char_ptr, auto_load_safe_path_vec, ix, pattern); ++ix)
+ if (filename_is_in_pattern (*filename_realp, pattern))
+ break;
+ }
+
+ if (pattern != NULL)
+ {
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: File \"%s\" matches "
+ "directory \"%s\".\n"),
+ filename, pattern);
+ return 1;
+ }
+
+ return 0;
+}
- TRY_CATCH (e, RETURN_MASK_ALL)
+/* Return 1 if FILENAME is located in one of the directories of
+ AUTO_LOAD_SAFE_PATH. Otherwise call warning and return 0. FILENAME does
+ not have to be an absolute path.
+
+ Existence of FILENAME is not checked. Function will still give a warning
+ even if the caller would quietly skip non-existing file in unsafe
+ directory. */
+
+int
+file_is_auto_load_safe (const char *filename, const char *debug_fmt, ...)
+{
+ char *filename_real = NULL;
+ struct cleanup *back_to;
+ static int advice_printed = 0;
+
+ if (debug_auto_load)
+ {
+ va_list debug_args;
+
+ va_start (debug_args, debug_fmt);
+ vfprintf_unfiltered (gdb_stdlog, debug_fmt, debug_args);
+ va_end (debug_args);
+ }
+
+ back_to = make_cleanup (free_current_contents, &filename_real);
+
+ if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
+ {
+ do_cleanups (back_to);
+ return 1;
+ }
+
+ auto_load_safe_path_vec_update ();
+ if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
+ {
+ do_cleanups (back_to);
+ return 1;
+ }
+
+ warning (_("File \"%s\" auto-loading has been declined by your "
+ "`auto-load safe-path' set to \"%s\"."),
+ filename_real, auto_load_safe_path);
+
+ if (!advice_printed)
{
- script_from_file (file, filename);
+ const char *homedir = getenv ("HOME");
+ char *homeinit;
+
+ if (homedir == NULL)
+ homedir = "$HOME";
+ homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
+ make_cleanup (xfree, homeinit);
+
+ printf_filtered (_("\
+To enable execution of this file add\n\
+\tadd-auto-load-safe-path %s\n\
+line to your configuration file \"%s\".\n\
+To completely disable this security protection add\n\
+\tset auto-load safe-path /\n\
+line to your configuration file \"%s\".\n\
+For more information about this security protection see the\n\
+\"Auto-loading safe path\" section in the GDB manual. E.g., run from the shell:\n\
+\tinfo \"(gdb)Auto-loading safe path\"\n"),
+ filename_real, homeinit, homeinit);
+ advice_printed = 1;
}
- exception_print (gdb_stderr, e);
+
+ do_cleanups (back_to);
+ return 0;
}
/* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
/* For each program space we keep track of loaded scripts. */
struct htab *loaded_scripts;
+ /* Non-zero if we've issued the warning about an auto-load script not being
+ supported. We only want to issue this warning once. */
+ int unsupported_script_warning_printed;
+
/* Non-zero if we've issued the warning about an auto-load script not being
found. We only want to issue this warning once. */
int script_not_found_warning_printed;
inaccessible). */
const char *full_path;
- const struct script_language *language;
+ /* Non-zero if this script has been loaded. */
+ int loaded;
+
+ const struct extension_language_defn *language;
};
/* Per-program-space data key. */
static void
auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
{
- struct auto_load_pspace_info *info;
+ struct auto_load_pspace_info *info = arg;
- info = program_space_data (pspace, auto_load_pspace_data);
- if (info != NULL)
- {
- if (info->loaded_scripts)
- htab_delete (info->loaded_scripts);
- xfree (info);
- }
+ if (info->loaded_scripts)
+ htab_delete (info->loaded_scripts);
+ xfree (info);
}
/* Get the current autoload data. If none is found yet, add it now. This
info = program_space_data (pspace, auto_load_pspace_data);
if (info == NULL)
{
- info = XZALLOC (struct auto_load_pspace_info);
+ info = XCNEW (struct auto_load_pspace_info);
set_program_space_data (pspace, auto_load_pspace_data, info);
}
eq_loaded_script_entry,
xfree);
+ pspace_info->unsupported_script_warning_printed = FALSE;
pspace_info->script_not_found_warning_printed = FALSE;
}
return info;
}
-/* Add script NAME in LANGUAGE to hash table of PSPACE_INFO.
- FULL_PATH is NULL if the script wasn't found. The result is
+/* Add script NAME in LANGUAGE to hash table of PSPACE_INFO. LOADED 1 if the
+ script has been (is going to) be loaded, 0 otherwise (such as if it has not
+ been found). FULL_PATH is NULL if the script wasn't found. The result is
true if the script was already in the hash table. */
-int
-maybe_add_script (struct auto_load_pspace_info *pspace_info,
+static int
+maybe_add_script (struct auto_load_pspace_info *pspace_info, int loaded,
const char *name, const char *full_path,
- const struct script_language *language)
+ const struct extension_language_defn *language)
{
struct htab *htab = pspace_info->loaded_scripts;
struct loaded_script **slot, entry;
}
else
(*slot)->full_path = NULL;
+ (*slot)->loaded = loaded;
(*slot)->language = language;
}
{
htab_delete (info->loaded_scripts);
info->loaded_scripts = NULL;
+ info->unsupported_script_warning_printed = FALSE;
info->script_not_found_warning_printed = FALSE;
}
}
-/* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
- it. */
+/* Look for the auto-load script in LANGUAGE associated with OBJFILE where
+ OBJFILE's gdb_realpath is REALNAME and load it. Return 1 if we found any
+ matching script, return 0 otherwise. */
-void
-auto_load_objfile_script (struct objfile *objfile,
- const struct script_language *language)
+static int
+auto_load_objfile_script_1 (struct objfile *objfile, const char *realname,
+ const struct extension_language_defn *language)
{
- char *realname;
char *filename, *debugfile;
- int len;
+ int len, retval;
FILE *input;
struct cleanup *cleanups;
+ const char *suffix = ext_lang_auto_load_suffix (language);
- realname = gdb_realpath (objfile->name);
len = strlen (realname);
- filename = xmalloc (len + strlen (language->suffix) + 1);
+ filename = xmalloc (len + strlen (suffix) + 1);
memcpy (filename, realname, len);
- strcpy (filename + len, language->suffix);
+ strcpy (filename + len, suffix);
cleanups = make_cleanup (xfree, filename);
- make_cleanup (xfree, realname);
- input = fopen (filename, "r");
+ input = gdb_fopen_cloexec (filename, "r");
debugfile = filename;
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file \"%s\" %s.\n"),
+ debugfile, input ? _("exists") : _("does not exist"));
- if (!input && debug_file_directory)
+ if (!input)
{
- /* Also try the same file in the separate debug info directory. */
- debugfile = xmalloc (strlen (filename)
- + strlen (debug_file_directory) + 1);
- strcpy (debugfile, debug_file_directory);
- /* FILENAME is absolute, so we don't need a "/" here. */
- strcat (debugfile, filename);
-
- make_cleanup (xfree, debugfile);
- input = fopen (debugfile, "r");
- }
+ VEC (char_ptr) *vec;
+ int ix;
+ char *dir;
- if (!input && gdb_datadir)
- {
/* Also try the same file in a subdirectory of gdb's data
directory. */
- debugfile = xmalloc (strlen (gdb_datadir) + strlen (filename)
- + strlen ("/auto-load") + 1);
- strcpy (debugfile, gdb_datadir);
- strcat (debugfile, "/auto-load");
- /* FILENAME is absolute, so we don't need a "/" here. */
- strcat (debugfile, filename);
-
- make_cleanup (xfree, debugfile);
- input = fopen (debugfile, "r");
+
+ vec = auto_load_expand_dir_vars (auto_load_dir);
+ make_cleanup_free_char_ptr_vec (vec);
+
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: Searching 'set auto-load "
+ "scripts-directory' path \"%s\".\n"),
+ auto_load_dir);
+
+ for (ix = 0; VEC_iterate (char_ptr, vec, ix, dir); ++ix)
+ {
+ debugfile = xmalloc (strlen (dir) + strlen (filename) + 1);
+ strcpy (debugfile, dir);
+
+ /* FILENAME is absolute, so we don't need a "/" here. */
+ strcat (debugfile, filename);
+
+ make_cleanup (xfree, debugfile);
+ input = gdb_fopen_cloexec (debugfile, "r");
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file "
+ "\"%s\" %s.\n"),
+ debugfile,
+ input ? _("exists") : _("does not exist"));
+ if (input != NULL)
+ break;
+ }
}
if (input)
{
+ int is_safe;
+ struct auto_load_pspace_info *pspace_info;
+
make_cleanup_fclose (input);
+ is_safe
+ = file_is_auto_load_safe (debugfile,
+ _("auto-load: Loading %s script \"%s\""
+ " by extension for objfile \"%s\".\n"),
+ ext_lang_name (language),
+ debugfile, objfile_name (objfile));
+
+ /* Add this script to the hash table too so
+ "info auto-load ${lang}-scripts" can print it. */
+ pspace_info
+ = get_auto_load_pspace_data_for_loading (current_program_space);
+ maybe_add_script (pspace_info, is_safe, debugfile, debugfile, language);
+
/* To preserve existing behaviour we don't check for whether the
script was already in the table, and always load it.
It's highly unlikely that we'd ever load it twice,
and these scripts are required to be idempotent under multiple
loads anyway. */
- language->source_script_for_objfile (objfile, input, debugfile);
+ if (is_safe)
+ {
+ objfile_script_sourcer_func *sourcer
+ = ext_lang_objfile_script_sourcer (language);
+
+ /* We shouldn't get here if support for the language isn't
+ compiled in. And the extension language is required to implement
+ this function. */
+ gdb_assert (sourcer != NULL);
+ sourcer (language, objfile, input, debugfile);
+ }
+
+ retval = 1;
+ }
+ else
+ retval = 0;
+
+ do_cleanups (cleanups);
+ return retval;
+}
+
+/* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
+ it. */
+
+void
+auto_load_objfile_script (struct objfile *objfile,
+ const struct extension_language_defn *language)
+{
+ char *realname = gdb_realpath (objfile_name (objfile));
+ struct cleanup *cleanups = make_cleanup (xfree, realname);
+
+ if (!auto_load_objfile_script_1 (objfile, realname, language))
+ {
+ /* For Windows/DOS .exe executables, strip the .exe suffix, so that
+ FOO-gdb.gdb could be used for FOO.exe, and try again. */
+
+ size_t len = strlen (realname);
+ const size_t lexe = sizeof (".exe") - 1;
+
+ if (len > lexe && strcasecmp (realname + len - lexe, ".exe") == 0)
+ {
+ len -= lexe;
+ realname[len] = '\0';
+ if (debug_auto_load)
+ fprintf_unfiltered (gdb_stdlog, _("auto-load: Stripped .exe suffix, "
+ "retrying with \"%s\".\n"),
+ realname);
+ auto_load_objfile_script_1 (objfile, realname, language);
+ }
}
do_cleanups (cleanups);
}
+/* Load scripts specified in OBJFILE.
+ START,END delimit a buffer containing a list of nul-terminated
+ file names.
+ SECTION_NAME is used in error messages.
+
+ Scripts are found per normal "source -s" command processing.
+ First the script is looked for in $cwd. If not found there the
+ source search path is used.
+
+ The section contains a list of path names of script files to load.
+ Each path is null-terminated. */
+
+static void
+source_section_scripts (struct objfile *objfile, const char *section_name,
+ const char *start, const char *end)
+{
+ const char *p;
+ struct auto_load_pspace_info *pspace_info;
+
+ pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
+
+ for (p = start; p < end; ++p)
+ {
+ const char *file;
+ FILE *stream;
+ char *full_path;
+ int opened, in_hash_table;
+ struct cleanup *back_to;
+ const struct extension_language_defn *language;
+ objfile_script_sourcer_func *sourcer;
+
+ switch (*p)
+ {
+ case SECTION_SCRIPT_ID_PYTHON_FILE:
+ language = get_ext_lang_defn (EXT_LANG_PYTHON);
+ break;
+ case SECTION_SCRIPT_ID_SCHEME_FILE:
+ language = get_ext_lang_defn (EXT_LANG_GUILE);
+ break;
+ default:
+ warning (_("Invalid entry in %s section"), section_name);
+ /* We could try various heuristics to find the next valid entry,
+ but it's safer to just punt. */
+ return;
+ }
+ file = ++p;
+
+ while (p < end && *p != '\0')
+ ++p;
+ if (p == end)
+ {
+ char *buf = alloca (p - file + 1);
+
+ memcpy (buf, file, p - file);
+ buf[p - file] = '\0';
+ warning (_("Non-null-terminated path in %s: %s"),
+ section_name, buf);
+ /* Don't load it. */
+ break;
+ }
+ if (p == file)
+ {
+ warning (_("Empty path in %s"), section_name);
+ continue;
+ }
+
+ /* Until we support more types of records in .debug_gdb_scripts we do
+ all the processing here. The expectation is to add a new
+ extension_language_script_ops "method" that handles all the records
+ for the language. For now we can just use
+ extension_language_script_ops.objfile_script_sourcer. */
+
+ /* Skip this script if support is not compiled in. */
+ sourcer = ext_lang_objfile_script_sourcer (language);
+ if (sourcer == NULL)
+ {
+ /* We don't throw an error, the program is still debuggable. */
+ if (!unsupported_script_warning_print (pspace_info))
+ {
+ warning (_("Unsupported auto-load scripts referenced in"
+ " %s section\n"
+ "of file %s.\n"
+ "Use `info auto-load %s-scripts [REGEXP]'"
+ " to list them."),
+ section_name, objfile_name (objfile),
+ ext_lang_name (language));
+ }
+ /* We *could* still try to open it, but there's no point. */
+ maybe_add_script (pspace_info, 0, file, NULL, language);
+ continue;
+ }
+
+ /* Skip this script if auto-loading it has been disabled. */
+ if (!ext_lang_auto_load_enabled (language))
+ {
+ /* No message is printed, just skip it. */
+ continue;
+ }
+
+ opened = find_and_open_script (file, 1 /*search_path*/,
+ &stream, &full_path);
+
+ back_to = make_cleanup (null_cleanup, NULL);
+ if (opened)
+ {
+ make_cleanup_fclose (stream);
+ make_cleanup (xfree, full_path);
+
+ if (!file_is_auto_load_safe (full_path,
+ _("auto-load: Loading %s script "
+ "\"%s\" from section \"%s\" of "
+ "objfile \"%s\".\n"),
+ ext_lang_name (language), full_path,
+ section_name, objfile_name (objfile)))
+ opened = 0;
+ }
+ else
+ {
+ full_path = NULL;
+
+ /* If one script isn't found it's not uncommon for more to not be
+ found either. We don't want to print a message for each script,
+ too much noise. Instead, we print the warning once and tell the
+ user how to find the list of scripts that weren't loaded.
+ We don't throw an error, the program is still debuggable.
+
+ IWBN if complaints.c were more general-purpose. */
+
+ if (script_not_found_warning_print (pspace_info))
+ warning (_("Missing auto-load scripts referenced in section %s\n\
+of file %s\n\
+Use `info auto-load %s-scripts [REGEXP]' to list them."),
+ section_name, objfile_name (objfile),
+ ext_lang_name (language));
+ }
+
+ in_hash_table = maybe_add_script (pspace_info, opened, file, full_path,
+ language);
+
+ /* If this file is not currently loaded, load it. */
+ if (opened && !in_hash_table)
+ sourcer (language, objfile, stream, full_path);
+
+ do_cleanups (back_to);
+ }
+}
+
+/* Load scripts specified in section SECTION_NAME of OBJFILE. */
+
+static void
+auto_load_section_scripts (struct objfile *objfile, const char *section_name)
+{
+ bfd *abfd = objfile->obfd;
+ asection *scripts_sect;
+ bfd_byte *data = NULL;
+
+ scripts_sect = bfd_get_section_by_name (abfd, section_name);
+ if (scripts_sect == NULL)
+ return;
+
+ if (!bfd_get_full_section_contents (abfd, scripts_sect, &data))
+ warning (_("Couldn't read %s section of %s"),
+ section_name, bfd_get_filename (abfd));
+ else
+ {
+ struct cleanup *cleanups;
+ char *p = (char *) data;
+
+ cleanups = make_cleanup (xfree, p);
+ source_section_scripts (objfile, section_name, p,
+ p + bfd_get_section_size (scripts_sect));
+ do_cleanups (cleanups);
+ }
+}
+
/* Load any auto-loaded scripts for OBJFILE. */
void
load_auto_scripts_for_objfile (struct objfile *objfile)
{
- if (!global_auto_load)
+ /* Return immediately if auto-loading has been globally disabled.
+ This is to handle sequencing of operations during gdb startup.
+ Also return immediately if OBJFILE is not actually a file. */
+ if (!global_auto_load || (objfile->flags & OBJF_NOT_FILENAME) != 0)
return;
- if (auto_load_gdb_scripts)
- auto_load_objfile_script (objfile, &script_language_gdb);
+ /* Load any extension language scripts for this objfile.
+ E.g., foo-gdb.gdb, foo-gdb.py. */
+ auto_load_ext_lang_scripts_for_objfile (objfile);
- gdbpy_load_auto_scripts_for_objfile (objfile);
+ /* Load any scripts mentioned in AUTO_SECTION_NAME (.debug_gdb_scripts). */
+ auto_load_section_scripts (objfile, AUTO_SECTION_NAME);
}
/* This is a new_objfile observer callback to auto-load scripts.
{
VEC (loaded_script_ptr) **scripts_p;
- const struct script_language *language;
+ const struct extension_language_defn *language;
};
/* Traversal function for htab_traverse.
chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_string (uiout, "loaded", script->full_path ? "Yes" : "Missing");
+ ui_out_field_string (uiout, "loaded", script->loaded ? "Yes" : "No");
ui_out_field_string (uiout, "script", script->name);
ui_out_text (uiout, "\n");
void
auto_load_info_scripts (char *pattern, int from_tty,
- const struct script_language *language)
+ const struct extension_language_defn *language)
{
struct ui_out *uiout = current_uiout;
struct auto_load_pspace_info *pspace_info;
{
struct collect_matching_scripts_data data = { &scripts, language };
- immediate_quit++;
/* Pass a pointer to scripts as VEC_safe_push can realloc space. */
htab_traverse_noresize (pspace_info->loaded_scripts,
collect_matching_scripts, &data);
- immediate_quit--;
}
nr_scripts = VEC_length (loaded_script_ptr, scripts);
static void
info_auto_load_gdb_scripts (char *pattern, int from_tty)
{
- auto_load_info_scripts (pattern, from_tty, &script_language_gdb);
+ auto_load_info_scripts (pattern, from_tty, &extension_language_gdb);
}
/* Implement 'info auto-load local-gdbinit'. */
auto_load_local_gdbinit_pathname);
}
+/* Return non-zero if UNSUPPORTED_SCRIPT_WARNING_PRINTED of PSPACE_INFO was
+ unset before calling this function. Always set
+ UNSUPPORTED_SCRIPT_WARNING_PRINTED of PSPACE_INFO. */
+
+static int
+unsupported_script_warning_print (struct auto_load_pspace_info *pspace_info)
+{
+ int retval = !pspace_info->unsupported_script_warning_printed;
+
+ pspace_info->unsupported_script_warning_printed = 1;
+
+ return retval;
+}
+
/* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
before calling this function. Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
of PSPACE_INFO. */
-int
+static int
script_not_found_warning_print (struct auto_load_pspace_info *pspace_info)
{
int retval = !pspace_info->script_not_found_warning_printed;
if (list->var_type == var_boolean)
{
gdb_assert (list->type == set_cmd);
- do_setshow_command (args, from_tty, list);
+ do_set_command (args, from_tty, list);
}
}
void
_initialize_auto_load (void)
{
+ struct cmd_list_element *cmd;
+ char *scripts_directory_help, *gdb_name_help, *python_name_help;
+ char *guile_name_help;
+ const char *suffix;
+
auto_load_pspace_data
- = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup);
+ = register_program_space_data_with_cleanup (NULL,
+ auto_load_pspace_data_cleanup);
observer_attach_new_objfile (auto_load_new_objfile);
_("Print whether current directory .gdbinit file has been loaded.\n\
Usage: info auto-load local-gdbinit"),
auto_load_info_cmdlist_get ());
+
+ auto_load_dir = xstrdup (AUTO_LOAD_DIR);
+
+ suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GDB));
+ gdb_name_help
+ = xstrprintf (_("\
+GDB scripts: OBJFILE%s\n"),
+ suffix);
+ python_name_help = NULL;
+#ifdef HAVE_PYTHON
+ suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_PYTHON));
+ python_name_help
+ = xstrprintf (_("\
+Python scripts: OBJFILE%s\n"),
+ suffix);
+#endif
+ guile_name_help = NULL;
+#ifdef HAVE_GUILE
+ suffix = ext_lang_auto_load_suffix (get_ext_lang_defn (EXT_LANG_GUILE));
+ guile_name_help
+ = xstrprintf (_("\
+Guile scripts: OBJFILE%s\n"),
+ suffix);
+#endif
+ scripts_directory_help
+ = xstrprintf (_("\
+Automatically loaded scripts are located in one of the directories listed\n\
+by this option.\n\
+\n\
+Script names:\n\
+%s%s%s\
+\n\
+This option is ignored for the kinds of scripts \
+having 'set auto-load ... off'.\n\
+Directories listed here need to be present also \
+in the 'set auto-load safe-path'\n\
+option."),
+ gdb_name_help,
+ python_name_help ? python_name_help : "",
+ guile_name_help ? guile_name_help : "");
+
+ add_setshow_optional_filename_cmd ("scripts-directory", class_support,
+ &auto_load_dir, _("\
+Set the list of directories from which to load auto-loaded scripts."), _("\
+Show the list of directories from which to load auto-loaded scripts."),
+ scripts_directory_help,
+ set_auto_load_dir, show_auto_load_dir,
+ auto_load_set_cmdlist_get (),
+ auto_load_show_cmdlist_get ());
+ xfree (scripts_directory_help);
+ xfree (python_name_help);
+ xfree (gdb_name_help);
+ xfree (guile_name_help);
+
+ auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH);
+ auto_load_safe_path_vec_update ();
+ add_setshow_optional_filename_cmd ("safe-path", class_support,
+ &auto_load_safe_path, _("\
+Set the list of files and directories that are safe for auto-loading."), _("\
+Show the list of files and directories that are safe for auto-loading."), _("\
+Various files loaded automatically for the 'set auto-load ...' options must\n\
+be located in one of the directories listed by this option. Warning will be\n\
+printed and file will not be used otherwise.\n\
+You can mix both directory and filename entries.\n\
+Setting this parameter to an empty list resets it to its default value.\n\
+Setting this parameter to '/' (without the quotes) allows any file\n\
+for the 'set auto-load ...' options. Each path entry can be also shell\n\
+wildcard pattern; '*' does not match directory separator.\n\
+This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
+This options has security implications for untrusted inferiors."),
+ set_auto_load_safe_path,
+ show_auto_load_safe_path,
+ auto_load_set_cmdlist_get (),
+ auto_load_show_cmdlist_get ());
+ observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed);
+
+ cmd = add_cmd ("add-auto-load-safe-path", class_support,
+ add_auto_load_safe_path,
+ _("Add entries to the list of directories from which it is safe "
+ "to auto-load files.\n\
+See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
+access the current full list setting."),
+ &cmdlist);
+ set_cmd_completer (cmd, filename_completer);
+
+ cmd = add_cmd ("add-auto-load-scripts-directory", class_support,
+ add_auto_load_dir,
+ _("Add entries to the list of directories from which to load "
+ "auto-loaded scripts.\n\
+See the commands 'set auto-load scripts-directory' and\n\
+'show auto-load scripts-directory' to access the current full list setting."),
+ &cmdlist);
+ set_cmd_completer (cmd, filename_completer);
+
+ add_setshow_boolean_cmd ("auto-load", class_maintenance,
+ &debug_auto_load, _("\
+Set auto-load verifications debugging."), _("\
+Show auto-load verifications debugging."), _("\
+When non-zero, debugging output for files of 'set auto-load ...'\n\
+is displayed."),
+ NULL, show_debug_auto_load,
+ &setdebuglist, &showdebuglist);
}
projects / deliverable / binutils-gdb.git / blobdiff