gdb/
[external/binutils.git] / gdb / auto-load.c
1 /* GDB routines for supporting auto-loaded scripts.
2
3    Copyright (C) 2012 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
41 /* The suffix of per-objfile scripts to auto-load as non-Python command files.
42    E.g. When the program loads libfoo.so, look for libfoo-gdb.gdb.  */
43 #define GDB_AUTO_FILE_NAME "-gdb.gdb"
44
45 static void source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
46                                            const char *filename);
47
48 /* Value of the 'set debug auto-load' configuration variable.  */
49 static int debug_auto_load = 0;
50
51 /* "show" command for the debug_auto_load configuration variable.  */
52
53 static void
54 show_debug_auto_load (struct ui_file *file, int from_tty,
55                       struct cmd_list_element *c, const char *value)
56 {
57   fprintf_filtered (file, _("Debugging output for files "
58                             "of 'set auto-load ...' is %s.\n"),
59                     value);
60 }
61
62 /* User-settable option to enable/disable auto-loading of GDB_AUTO_FILE_NAME
63    scripts:
64    set auto-load gdb-scripts on|off
65    This is true if we should auto-load associated scripts when an objfile
66    is opened, false otherwise.  */
67 static int auto_load_gdb_scripts = 1;
68
69 /* "show" command for the auto_load_gdb_scripts configuration variable.  */
70
71 static void
72 show_auto_load_gdb_scripts (struct ui_file *file, int from_tty,
73                             struct cmd_list_element *c, const char *value)
74 {
75   fprintf_filtered (file, _("Auto-loading of canned sequences of commands "
76                             "scripts is %s.\n"),
77                     value);
78 }
79
80 /* Internal-use flag to enable/disable auto-loading.
81    This is true if we should auto-load python code when an objfile is opened,
82    false otherwise.
83
84    Both auto_load_scripts && global_auto_load must be true to enable
85    auto-loading.
86
87    This flag exists to facilitate deferring auto-loading during start-up
88    until after ./.gdbinit has been read; it may augment the search directories
89    used to find the scripts.  */
90 int global_auto_load = 1;
91
92 /* Auto-load .gdbinit file from the current directory?  */
93 int auto_load_local_gdbinit = 1;
94
95 /* Absolute pathname to the current directory .gdbinit, if it exists.  */
96 char *auto_load_local_gdbinit_pathname = NULL;
97
98 /* Boolean value if AUTO_LOAD_LOCAL_GDBINIT_PATHNAME has been loaded.  */
99 int auto_load_local_gdbinit_loaded = 0;
100
101 /* "show" command for the auto_load_local_gdbinit configuration variable.  */
102
103 static void
104 show_auto_load_local_gdbinit (struct ui_file *file, int from_tty,
105                               struct cmd_list_element *c, const char *value)
106 {
107   fprintf_filtered (file, _("Auto-loading of .gdbinit script from current "
108                             "directory is %s.\n"),
109                     value);
110 }
111
112 /* Directory list from which to load auto-loaded scripts.  It is not checked
113    for absolute paths but they are strongly recommended.  It is initialized by
114    _initialize_auto_load.  */
115 static char *auto_load_dir;
116
117 /* "set" command for the auto_load_dir configuration variable.  */
118
119 static void
120 set_auto_load_dir (char *args, int from_tty, struct cmd_list_element *c)
121 {
122   /* Setting the variable to "" resets it to the compile time defaults.  */
123   if (auto_load_dir[0] == '\0')
124     {
125       xfree (auto_load_dir);
126       auto_load_dir = xstrdup (AUTO_LOAD_DIR);
127     }
128 }
129
130 /* "show" command for the auto_load_dir configuration variable.  */
131
132 static void
133 show_auto_load_dir (struct ui_file *file, int from_tty,
134                     struct cmd_list_element *c, const char *value)
135 {
136   fprintf_filtered (file, _("List of directories from which to load "
137                             "auto-loaded scripts is %s.\n"),
138                     value);
139 }
140
141 /* Directory list safe to hold auto-loaded files.  It is not checked for
142    absolute paths but they are strongly recommended.  It is initialized by
143    _initialize_auto_load.  */
144 static char *auto_load_safe_path;
145
146 /* Vector of directory elements of AUTO_LOAD_SAFE_PATH with each one normalized
147    by tilde_expand and possibly each entries has added its gdb_realpath
148    counterpart.  */
149 static VEC (char_ptr) *auto_load_safe_path_vec;
150
151 /* Expand $datadir and $debugdir in STRING according to the rules of
152    substitute_path_component.  Return vector from dirnames_to_char_ptr_vec,
153    this vector must be freed by free_char_ptr_vec by the caller.  */
154
155 static VEC (char_ptr) *
156 auto_load_expand_dir_vars (const char *string)
157 {
158   VEC (char_ptr) *dir_vec;
159   char *s;
160
161   s = xstrdup (string);
162   substitute_path_component (&s, "$datadir", gdb_datadir);
163   substitute_path_component (&s, "$debugdir", debug_file_directory);
164
165   if (debug_auto_load && strcmp (s, string) != 0)
166     fprintf_unfiltered (gdb_stdlog,
167                         _("auto-load: Expanded $-variables to \"%s\".\n"), s);
168
169   dir_vec = dirnames_to_char_ptr_vec (s);
170   xfree(s);
171
172   return dir_vec;
173 }
174
175 /* Update auto_load_safe_path_vec from current AUTO_LOAD_SAFE_PATH.  */
176
177 static void
178 auto_load_safe_path_vec_update (void)
179 {
180   VEC (char_ptr) *dir_vec = NULL;
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
445   if (debug_auto_load)
446     {
447       va_list debug_args;
448
449       va_start (debug_args, debug_fmt);
450       vfprintf_unfiltered (gdb_stdlog, debug_fmt, debug_args);
451       va_end (debug_args);
452     }
453
454   back_to = make_cleanup (free_current_contents, &filename_real);
455
456   if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
457     {
458       do_cleanups (back_to);
459       return 1;
460     }
461
462   auto_load_safe_path_vec_update ();
463   if (filename_is_in_auto_load_safe_path_vec (filename, &filename_real))
464     {
465       do_cleanups (back_to);
466       return 1;
467     }
468
469   warning (_("File \"%s\" auto-loading has been declined by your "
470              "`auto-load safe-path' set to \"%s\"."),
471            filename_real, auto_load_safe_path);
472
473   do_cleanups (back_to);
474   return 0;
475 }
476
477 /* Definition of script language for GDB canned sequences of commands.  */
478
479 static const struct script_language script_language_gdb
480   = { GDB_AUTO_FILE_NAME, source_gdb_script_for_objfile };
481
482 static void
483 source_gdb_script_for_objfile (struct objfile *objfile, FILE *file,
484                                const char *filename)
485 {
486   int is_safe;
487   struct auto_load_pspace_info *pspace_info;
488   volatile struct gdb_exception e;
489
490   is_safe = file_is_auto_load_safe (filename, _("auto-load: Loading canned "
491                                                 "sequences of commands script "
492                                                 "\"%s\" for objfile \"%s\".\n"),
493                                     filename, objfile->name);
494
495   /* Add this script to the hash table too so "info auto-load gdb-scripts"
496      can print it.  */
497   pspace_info = get_auto_load_pspace_data_for_loading (current_program_space);
498   maybe_add_script (pspace_info, is_safe, filename, filename,
499                     &script_language_gdb);
500
501   if (!is_safe)
502     return;
503
504   TRY_CATCH (e, RETURN_MASK_ALL)
505     {
506       script_from_file (file, filename);
507     }
508   exception_print (gdb_stderr, e);
509 }
510
511 /* For scripts specified in .debug_gdb_scripts, multiple objfiles may load
512    the same script.  There's no point in loading the script multiple times,
513    and there can be a lot of objfiles and scripts, so we keep track of scripts
514    loaded this way.  */
515
516 struct auto_load_pspace_info
517 {
518   /* For each program space we keep track of loaded scripts.  */
519   struct htab *loaded_scripts;
520
521   /* Non-zero if we've issued the warning about an auto-load script not being
522      found.  We only want to issue this warning once.  */
523   int script_not_found_warning_printed;
524 };
525
526 /* Objects of this type are stored in the loaded script hash table.  */
527
528 struct loaded_script
529 {
530   /* Name as provided by the objfile.  */
531   const char *name;
532
533   /* Full path name or NULL if script wasn't found (or was otherwise
534      inaccessible).  */
535   const char *full_path;
536
537   /* Non-zero if this script has been loaded.  */
538   int loaded;
539
540   const struct script_language *language;
541 };
542
543 /* Per-program-space data key.  */
544 static const struct program_space_data *auto_load_pspace_data;
545
546 static void
547 auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
548 {
549   struct auto_load_pspace_info *info;
550
551   info = program_space_data (pspace, auto_load_pspace_data);
552   if (info != NULL)
553     {
554       if (info->loaded_scripts)
555         htab_delete (info->loaded_scripts);
556       xfree (info);
557     }
558 }
559
560 /* Get the current autoload data.  If none is found yet, add it now.  This
561    function always returns a valid object.  */
562
563 static struct auto_load_pspace_info *
564 get_auto_load_pspace_data (struct program_space *pspace)
565 {
566   struct auto_load_pspace_info *info;
567
568   info = program_space_data (pspace, auto_load_pspace_data);
569   if (info == NULL)
570     {
571       info = XZALLOC (struct auto_load_pspace_info);
572       set_program_space_data (pspace, auto_load_pspace_data, info);
573     }
574
575   return info;
576 }
577
578 /* Hash function for the loaded script hash.  */
579
580 static hashval_t
581 hash_loaded_script_entry (const void *data)
582 {
583   const struct loaded_script *e = data;
584
585   return htab_hash_string (e->name) ^ htab_hash_pointer (e->language);
586 }
587
588 /* Equality function for the loaded script hash.  */
589
590 static int
591 eq_loaded_script_entry (const void *a, const void *b)
592 {
593   const struct loaded_script *ea = a;
594   const struct loaded_script *eb = b;
595
596   return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language;
597 }
598
599 /* Initialize the table to track loaded scripts.
600    Each entry is hashed by the full path name.  */
601
602 static void
603 init_loaded_scripts_info (struct auto_load_pspace_info *pspace_info)
604 {
605   /* Choose 31 as the starting size of the hash table, somewhat arbitrarily.
606      Space for each entry is obtained with one malloc so we can free them
607      easily.  */
608
609   pspace_info->loaded_scripts = htab_create (31,
610                                              hash_loaded_script_entry,
611                                              eq_loaded_script_entry,
612                                              xfree);
613
614   pspace_info->script_not_found_warning_printed = FALSE;
615 }
616
617 /* Wrapper on get_auto_load_pspace_data to also allocate the hash table
618    for loading scripts.  */
619
620 struct auto_load_pspace_info *
621 get_auto_load_pspace_data_for_loading (struct program_space *pspace)
622 {
623   struct auto_load_pspace_info *info;
624
625   info = get_auto_load_pspace_data (pspace);
626   if (info->loaded_scripts == NULL)
627     init_loaded_scripts_info (info);
628
629   return info;
630 }
631
632 /* Add script NAME in LANGUAGE to hash table of PSPACE_INFO.  LOADED 1 if the
633    script has been (is going to) be loaded, 0 otherwise (such as if it has not
634    been found).  FULL_PATH is NULL if the script wasn't found.  The result is
635    true if the script was already in the hash table.  */
636
637 int
638 maybe_add_script (struct auto_load_pspace_info *pspace_info, int loaded,
639                   const char *name, const char *full_path,
640                   const struct script_language *language)
641 {
642   struct htab *htab = pspace_info->loaded_scripts;
643   struct loaded_script **slot, entry;
644   int in_hash_table;
645
646   entry.name = name;
647   entry.language = language;
648   slot = (struct loaded_script **) htab_find_slot (htab, &entry, INSERT);
649   in_hash_table = *slot != NULL;
650
651   /* If this script is not in the hash table, add it.  */
652
653   if (! in_hash_table)
654     {
655       char *p;
656
657       /* Allocate all space in one chunk so it's easier to free.  */
658       *slot = xmalloc (sizeof (**slot)
659                        + strlen (name) + 1
660                        + (full_path != NULL ? (strlen (full_path) + 1) : 0));
661       p = ((char*) *slot) + sizeof (**slot);
662       strcpy (p, name);
663       (*slot)->name = p;
664       if (full_path != NULL)
665         {
666           p += strlen (p) + 1;
667           strcpy (p, full_path);
668           (*slot)->full_path = p;
669         }
670       else
671         (*slot)->full_path = NULL;
672       (*slot)->loaded = loaded;
673       (*slot)->language = language;
674     }
675
676   return in_hash_table;
677 }
678
679 /* Clear the table of loaded section scripts.  */
680
681 static void
682 clear_section_scripts (void)
683 {
684   struct program_space *pspace = current_program_space;
685   struct auto_load_pspace_info *info;
686
687   info = program_space_data (pspace, auto_load_pspace_data);
688   if (info != NULL && info->loaded_scripts != NULL)
689     {
690       htab_delete (info->loaded_scripts);
691       info->loaded_scripts = NULL;
692       info->script_not_found_warning_printed = FALSE;
693     }
694 }
695
696 /* Look for the auto-load script in LANGUAGE associated with OBJFILE and load
697    it.  */
698
699 void
700 auto_load_objfile_script (struct objfile *objfile,
701                           const struct script_language *language)
702 {
703   char *realname;
704   char *filename, *debugfile;
705   int len;
706   FILE *input;
707   struct cleanup *cleanups;
708
709   realname = gdb_realpath (objfile->name);
710   len = strlen (realname);
711   filename = xmalloc (len + strlen (language->suffix) + 1);
712   memcpy (filename, realname, len);
713   strcpy (filename + len, language->suffix);
714
715   cleanups = make_cleanup (xfree, filename);
716   make_cleanup (xfree, realname);
717
718   input = fopen (filename, "r");
719   debugfile = filename;
720   if (debug_auto_load)
721     fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file \"%s\" %s.\n"),
722                         debugfile, input ? _("exists") : _("does not exist"));
723
724   if (!input)
725     {
726       VEC (char_ptr) *vec;
727       int ix;
728       char *dir;
729
730       /* Also try the same file in a subdirectory of gdb's data
731          directory.  */
732
733       vec = auto_load_expand_dir_vars (auto_load_dir);
734       make_cleanup_free_char_ptr_vec (vec);
735
736       if (debug_auto_load)
737         fprintf_unfiltered (gdb_stdlog, _("auto-load: Searching 'set auto-load "
738                                           "scripts-directory' path \"%s\".\n"),
739                             auto_load_dir);
740
741       for (ix = 0; VEC_iterate (char_ptr, vec, ix, dir); ++ix)
742         {
743           debugfile = xmalloc (strlen (dir) + strlen (filename) + 1);
744           strcpy (debugfile, dir);
745
746           /* FILENAME is absolute, so we don't need a "/" here.  */
747           strcat (debugfile, filename);
748
749           make_cleanup (xfree, debugfile);
750           input = fopen (debugfile, "r");
751           if (debug_auto_load)
752             fprintf_unfiltered (gdb_stdlog, _("auto-load: Attempted file "
753                                               "\"%s\" %s.\n"),
754                                 debugfile,
755                                 input ? _("exists") : _("does not exist"));
756           if (input != NULL)
757             break;
758         }
759     }
760
761   if (input)
762     {
763       make_cleanup_fclose (input);
764
765       /* To preserve existing behaviour we don't check for whether the
766          script was already in the table, and always load it.
767          It's highly unlikely that we'd ever load it twice,
768          and these scripts are required to be idempotent under multiple
769          loads anyway.  */
770       language->source_script_for_objfile (objfile, input, debugfile);
771     }
772
773   do_cleanups (cleanups);
774 }
775
776 /* Load any auto-loaded scripts for OBJFILE.  */
777
778 void
779 load_auto_scripts_for_objfile (struct objfile *objfile)
780 {
781   if (!global_auto_load)
782     return;
783
784   if (auto_load_gdb_scripts)
785     auto_load_objfile_script (objfile, &script_language_gdb);
786
787   gdbpy_load_auto_scripts_for_objfile (objfile);
788 }
789
790 /* This is a new_objfile observer callback to auto-load scripts.
791
792    Two flavors of auto-loaded scripts are supported.
793    1) based on the path to the objfile
794    2) from .debug_gdb_scripts section  */
795
796 static void
797 auto_load_new_objfile (struct objfile *objfile)
798 {
799   if (!objfile)
800     {
801       /* OBJFILE is NULL when loading a new "main" symbol-file.  */
802       clear_section_scripts ();
803       return;
804     }
805
806   load_auto_scripts_for_objfile (objfile);
807 }
808
809 /* Collect scripts to be printed in a vec.  */
810
811 typedef struct loaded_script *loaded_script_ptr;
812 DEF_VEC_P (loaded_script_ptr);
813
814 struct collect_matching_scripts_data
815 {
816   VEC (loaded_script_ptr) **scripts_p;
817
818   const struct script_language *language;
819 };
820
821 /* Traversal function for htab_traverse.
822    Collect the entry if it matches the regexp.  */
823
824 static int
825 collect_matching_scripts (void **slot, void *info)
826 {
827   struct loaded_script *script = *slot;
828   struct collect_matching_scripts_data *data = info;
829
830   if (script->language == data->language && re_exec (script->name))
831     VEC_safe_push (loaded_script_ptr, *data->scripts_p, script);
832
833   return 1;
834 }
835
836 /* Print SCRIPT.  */
837
838 static void
839 print_script (struct loaded_script *script)
840 {
841   struct ui_out *uiout = current_uiout;
842   struct cleanup *chain;
843
844   chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
845
846   ui_out_field_string (uiout, "loaded", script->loaded ? "Yes" : "No");
847   ui_out_field_string (uiout, "script", script->name);
848   ui_out_text (uiout, "\n");
849
850   /* If the name isn't the full path, print it too.  */
851   if (script->full_path != NULL
852       && strcmp (script->name, script->full_path) != 0)
853     {
854       ui_out_text (uiout, "\tfull name: ");
855       ui_out_field_string (uiout, "full_path", script->full_path);
856       ui_out_text (uiout, "\n");
857     }
858
859   do_cleanups (chain);
860 }
861
862 /* Helper for info_auto_load_scripts to sort the scripts by name.  */
863
864 static int
865 sort_scripts_by_name (const void *ap, const void *bp)
866 {
867   const struct loaded_script *a = *(const struct loaded_script **) ap;
868   const struct loaded_script *b = *(const struct loaded_script **) bp;
869
870   return FILENAME_CMP (a->name, b->name);
871 }
872
873 /* Special internal GDB value of auto_load_info_scripts's PATTERN identify
874    the "info auto-load XXX" command has been executed through the general
875    "info auto-load" invocation.  Extra newline will be printed if needed.  */
876 char auto_load_info_scripts_pattern_nl[] = "";
877
878 /* Implementation for "info auto-load gdb-scripts"
879    (and "info auto-load python-scripts").  List scripts in LANGUAGE matching
880    PATTERN.  FROM_TTY is the usual GDB boolean for user interactivity.  */
881
882 void
883 auto_load_info_scripts (char *pattern, int from_tty,
884                         const struct script_language *language)
885 {
886   struct ui_out *uiout = current_uiout;
887   struct auto_load_pspace_info *pspace_info;
888   struct cleanup *script_chain;
889   VEC (loaded_script_ptr) *scripts;
890   int nr_scripts;
891
892   dont_repeat ();
893
894   pspace_info = get_auto_load_pspace_data (current_program_space);
895
896   if (pattern && *pattern)
897     {
898       char *re_err = re_comp (pattern);
899
900       if (re_err)
901         error (_("Invalid regexp: %s"), re_err);
902     }
903   else
904     {
905       re_comp ("");
906     }
907
908   /* We need to know the number of rows before we build the table.
909      Plus we want to sort the scripts by name.
910      So first traverse the hash table collecting the matching scripts.  */
911
912   scripts = VEC_alloc (loaded_script_ptr, 10);
913   script_chain = make_cleanup (VEC_cleanup (loaded_script_ptr), &scripts);
914
915   if (pspace_info != NULL && pspace_info->loaded_scripts != NULL)
916     {
917       struct collect_matching_scripts_data data = { &scripts, language };
918
919       /* Pass a pointer to scripts as VEC_safe_push can realloc space.  */
920       htab_traverse_noresize (pspace_info->loaded_scripts,
921                               collect_matching_scripts, &data);
922     }
923
924   nr_scripts = VEC_length (loaded_script_ptr, scripts);
925
926   /* Table header shifted right by preceding "gdb-scripts:  " would not match
927      its columns.  */
928   if (nr_scripts > 0 && pattern == auto_load_info_scripts_pattern_nl)
929     ui_out_text (uiout, "\n");
930
931   make_cleanup_ui_out_table_begin_end (uiout, 2, nr_scripts,
932                                        "AutoLoadedScriptsTable");
933
934   ui_out_table_header (uiout, 7, ui_left, "loaded", "Loaded");
935   ui_out_table_header (uiout, 70, ui_left, "script", "Script");
936   ui_out_table_body (uiout);
937
938   if (nr_scripts > 0)
939     {
940       int i;
941       loaded_script_ptr script;
942
943       qsort (VEC_address (loaded_script_ptr, scripts),
944              VEC_length (loaded_script_ptr, scripts),
945              sizeof (loaded_script_ptr), sort_scripts_by_name);
946       for (i = 0; VEC_iterate (loaded_script_ptr, scripts, i, script); ++i)
947         print_script (script);
948     }
949
950   do_cleanups (script_chain);
951
952   if (nr_scripts == 0)
953     {
954       if (pattern && *pattern)
955         ui_out_message (uiout, 0, "No auto-load scripts matching %s.\n",
956                         pattern);
957       else
958         ui_out_message (uiout, 0, "No auto-load scripts.\n");
959     }
960 }
961
962 /* Wrapper for "info auto-load gdb-scripts".  */
963
964 static void
965 info_auto_load_gdb_scripts (char *pattern, int from_tty)
966 {
967   auto_load_info_scripts (pattern, from_tty, &script_language_gdb);
968 }
969
970 /* Implement 'info auto-load local-gdbinit'.  */
971
972 static void
973 info_auto_load_local_gdbinit (char *args, int from_tty)
974 {
975   if (auto_load_local_gdbinit_pathname == NULL)
976     printf_filtered (_("Local .gdbinit file was not found.\n"));
977   else if (auto_load_local_gdbinit_loaded)
978     printf_filtered (_("Local .gdbinit file \"%s\" has been loaded.\n"),
979                      auto_load_local_gdbinit_pathname);
980   else
981     printf_filtered (_("Local .gdbinit file \"%s\" has not been loaded.\n"),
982                      auto_load_local_gdbinit_pathname);
983 }
984
985 /* Return non-zero if SCRIPT_NOT_FOUND_WARNING_PRINTED of PSPACE_INFO was unset
986    before calling this function.  Always set SCRIPT_NOT_FOUND_WARNING_PRINTED
987    of PSPACE_INFO.  */
988
989 int
990 script_not_found_warning_print (struct auto_load_pspace_info *pspace_info)
991 {
992   int retval = !pspace_info->script_not_found_warning_printed;
993
994   pspace_info->script_not_found_warning_printed = 1;
995
996   return retval;
997 }
998
999 /* The only valid "set auto-load" argument is off|0|no|disable.  */
1000
1001 static void
1002 set_auto_load_cmd (char *args, int from_tty)
1003 {
1004   struct cmd_list_element *list;
1005   size_t length;
1006
1007   /* See parse_binary_operation in use by the sub-commands.  */
1008
1009   length = args ? strlen (args) : 0;
1010
1011   while (length > 0 && (args[length - 1] == ' ' || args[length - 1] == '\t'))
1012     length--;
1013
1014   if (length == 0 || (strncmp (args, "off", length) != 0
1015                       && strncmp (args, "0", length) != 0
1016                       && strncmp (args, "no", length) != 0
1017                       && strncmp (args, "disable", length) != 0))
1018     error (_("Valid is only global 'set auto-load no'; "
1019              "otherwise check the auto-load sub-commands."));
1020
1021   for (list = *auto_load_set_cmdlist_get (); list != NULL; list = list->next)
1022     if (list->var_type == var_boolean)
1023       {
1024         gdb_assert (list->type == set_cmd);
1025         do_set_command (args, from_tty, list);
1026       }
1027 }
1028
1029 /* Initialize "set auto-load " commands prefix and return it.  */
1030
1031 struct cmd_list_element **
1032 auto_load_set_cmdlist_get (void)
1033 {
1034   static struct cmd_list_element *retval;
1035
1036   if (retval == NULL)
1037     add_prefix_cmd ("auto-load", class_maintenance, set_auto_load_cmd, _("\
1038 Auto-loading specific settings.\n\
1039 Configure various auto-load-specific variables such as\n\
1040 automatic loading of Python scripts."),
1041                     &retval, "set auto-load ",
1042                     1/*allow-unknown*/, &setlist);
1043
1044   return &retval;
1045 }
1046
1047 /* Command "show auto-load" displays summary of all the current
1048    "show auto-load " settings.  */
1049
1050 static void
1051 show_auto_load_cmd (char *args, int from_tty)
1052 {
1053   cmd_show_list (*auto_load_show_cmdlist_get (), from_tty, "");
1054 }
1055
1056 /* Initialize "show auto-load " commands prefix and return it.  */
1057
1058 struct cmd_list_element **
1059 auto_load_show_cmdlist_get (void)
1060 {
1061   static struct cmd_list_element *retval;
1062
1063   if (retval == NULL)
1064     add_prefix_cmd ("auto-load", class_maintenance, show_auto_load_cmd, _("\
1065 Show auto-loading specific settings.\n\
1066 Show configuration of various auto-load-specific variables such as\n\
1067 automatic loading of Python scripts."),
1068                     &retval, "show auto-load ",
1069                     0/*allow-unknown*/, &showlist);
1070
1071   return &retval;
1072 }
1073
1074 /* Command "info auto-load" displays whether the various auto-load files have
1075    been loaded.  This is reimplementation of cmd_show_list which inserts
1076    newlines at proper places.  */
1077
1078 static void
1079 info_auto_load_cmd (char *args, int from_tty)
1080 {
1081   struct cmd_list_element *list;
1082   struct cleanup *infolist_chain;
1083   struct ui_out *uiout = current_uiout;
1084
1085   infolist_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "infolist");
1086
1087   for (list = *auto_load_info_cmdlist_get (); list != NULL; list = list->next)
1088     {
1089       struct cleanup *option_chain
1090         = make_cleanup_ui_out_tuple_begin_end (uiout, "option");
1091
1092       gdb_assert (!list->prefixlist);
1093       gdb_assert (list->type == not_set_cmd);
1094
1095       ui_out_field_string (uiout, "name", list->name);
1096       ui_out_text (uiout, ":  ");
1097       cmd_func (list, auto_load_info_scripts_pattern_nl, from_tty);
1098
1099       /* Close the tuple.  */
1100       do_cleanups (option_chain);
1101     }
1102
1103   /* Close the tuple.  */
1104   do_cleanups (infolist_chain);
1105 }
1106
1107 /* Initialize "info auto-load " commands prefix and return it.  */
1108
1109 struct cmd_list_element **
1110 auto_load_info_cmdlist_get (void)
1111 {
1112   static struct cmd_list_element *retval;
1113
1114   if (retval == NULL)
1115     add_prefix_cmd ("auto-load", class_info, info_auto_load_cmd, _("\
1116 Print current status of auto-loaded files.\n\
1117 Print whether various files like Python scripts or .gdbinit files have been\n\
1118 found and/or loaded."),
1119                     &retval, "info auto-load ",
1120                     0/*allow-unknown*/, &infolist);
1121
1122   return &retval;
1123 }
1124
1125 void _initialize_auto_load (void);
1126
1127 void
1128 _initialize_auto_load (void)
1129 {
1130   struct cmd_list_element *cmd;
1131
1132   auto_load_pspace_data
1133     = register_program_space_data_with_cleanup (auto_load_pspace_data_cleanup);
1134
1135   observer_attach_new_objfile (auto_load_new_objfile);
1136
1137   add_setshow_boolean_cmd ("gdb-scripts", class_support,
1138                            &auto_load_gdb_scripts, _("\
1139 Enable or disable auto-loading of canned sequences of commands scripts."), _("\
1140 Show whether auto-loading of canned sequences of commands scripts is enabled."),
1141                            _("\
1142 If enabled, canned sequences of commands are loaded when the debugger reads\n\
1143 an executable or shared library.\n\
1144 This options has security implications for untrusted inferiors."),
1145                            NULL, show_auto_load_gdb_scripts,
1146                            auto_load_set_cmdlist_get (),
1147                            auto_load_show_cmdlist_get ());
1148
1149   add_cmd ("gdb-scripts", class_info, info_auto_load_gdb_scripts,
1150            _("Print the list of automatically loaded sequences of commands.\n\
1151 Usage: info auto-load gdb-scripts [REGEXP]"),
1152            auto_load_info_cmdlist_get ());
1153
1154   add_setshow_boolean_cmd ("local-gdbinit", class_support,
1155                            &auto_load_local_gdbinit, _("\
1156 Enable or disable auto-loading of .gdbinit script in current directory."), _("\
1157 Show whether auto-loading .gdbinit script in current directory is enabled."),
1158                            _("\
1159 If enabled, canned sequences of commands are loaded when debugger starts\n\
1160 from .gdbinit file in current directory.  Such files are deprecated,\n\
1161 use a script associated with inferior executable file instead.\n\
1162 This options has security implications for untrusted inferiors."),
1163                            NULL, show_auto_load_local_gdbinit,
1164                            auto_load_set_cmdlist_get (),
1165                            auto_load_show_cmdlist_get ());
1166
1167   add_cmd ("local-gdbinit", class_info, info_auto_load_local_gdbinit,
1168            _("Print whether current directory .gdbinit file has been loaded.\n\
1169 Usage: info auto-load local-gdbinit"),
1170            auto_load_info_cmdlist_get ());
1171
1172   auto_load_dir = xstrdup (AUTO_LOAD_DIR);
1173   add_setshow_optional_filename_cmd ("scripts-directory", class_support,
1174                                      &auto_load_dir, _("\
1175 Set the list of directories from which to load auto-loaded scripts."), _("\
1176 Show the list of directories from which to load auto-loaded scripts."), _("\
1177 Automatically loaded Python scripts and GDB scripts are located in one of the\n\
1178 directories listed by this option.  This option is ignored for the kinds of\n\
1179 scripts having 'set auto-load ... off'.  Directories listed here need to be\n\
1180 present also in the 'set auto-load safe-path' option."),
1181                                      set_auto_load_dir, show_auto_load_dir,
1182                                      auto_load_set_cmdlist_get (),
1183                                      auto_load_show_cmdlist_get ());
1184
1185   auto_load_safe_path = xstrdup (AUTO_LOAD_SAFE_PATH);
1186   auto_load_safe_path_vec_update ();
1187   add_setshow_optional_filename_cmd ("safe-path", class_support,
1188                                      &auto_load_safe_path, _("\
1189 Set the list of directories from which it is safe to auto-load files."), _("\
1190 Show the list of directories from which it is safe to auto-load files."), _("\
1191 Various files loaded automatically for the 'set auto-load ...' options must\n\
1192 be located in one of the directories listed by this option.  Warning will be\n\
1193 printed and file will not be used otherwise.\n\
1194 Setting this parameter to an empty list resets it to its default value.\n\
1195 Setting this parameter to '/' (without the quotes) allows any file\n\
1196 for the 'set auto-load ...' options.  Each directory can be also shell\n\
1197 wildcard pattern; '*' does not match directory separator.\n\
1198 This option is ignored for the kinds of files having 'set auto-load ... off'.\n\
1199 This options has security implications for untrusted inferiors."),
1200                                      set_auto_load_safe_path,
1201                                      show_auto_load_safe_path,
1202                                      auto_load_set_cmdlist_get (),
1203                                      auto_load_show_cmdlist_get ());
1204   observer_attach_gdb_datadir_changed (auto_load_gdb_datadir_changed);
1205
1206   cmd = add_cmd ("add-auto-load-safe-path", class_support,
1207                  add_auto_load_safe_path,
1208                  _("Add entries to the list of directories from which it is safe "
1209                    "to auto-load files.\n\
1210 See the commands 'set auto-load safe-path' and 'show auto-load safe-path' to\n\
1211 access the current full list setting."),
1212                  &cmdlist);
1213   set_cmd_completer (cmd, filename_completer);
1214
1215   add_setshow_boolean_cmd ("auto-load", class_maintenance,
1216                            &debug_auto_load, _("\
1217 Set auto-load verifications debugging."), _("\
1218 Show auto-load verifications debugging."), _("\
1219 When non-zero, debugging output for files of 'set auto-load ...'\n\
1220 is displayed."),
1221                             NULL, show_debug_auto_load,
1222                             &setdebuglist, &showdebuglist);
1223 }