1 /* bashhist.c -- bash interface to the GNU history library. */
3 /* Copyright (C) 1993-2010 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash 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.
12 Bash 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.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
25 #if defined (HAVE_UNISTD_H)
27 # include <sys/types.h>
32 #include "bashtypes.h"
36 #include "posixstat.h"
41 #if defined (SYSLOG_HISTORY)
48 #include "parser.h" /* for the struct dstack stuff. */
49 #include "pathexp.h" /* for the struct ignorevar stuff */
50 #include "bashhist.h" /* matching prototypes and declarations */
51 #include "builtins/common.h"
53 #include <readline/history.h>
54 #include <glob/glob.h>
55 #include <glob/strmatch.h>
57 #if defined (READLINE)
58 # include "bashline.h"
59 extern int rl_done, rl_dispatching; /* should really include readline.h */
66 static int histignore_item_func __P((struct ign *));
67 static int check_history_control __P((char *));
68 static void hc_erasedups __P((char *));
69 static void really_add_history __P((char *));
71 static struct ignorevar histignore =
77 (sh_iv_item_func_t *)histignore_item_func,
80 #define HIGN_EXPAND 0x01
82 /* Declarations of bash history variables. */
83 /* Non-zero means to remember lines typed to the shell on the history
84 list. This is different than the user-controlled behaviour; this
85 becomes zero when we read lines from a file, for example. */
86 int remember_on_history = 1;
87 int enable_history_list = 1; /* value for `set -o history' */
89 /* The number of lines that Bash has added to this history session. The
90 difference between the number of the top element in the history list
91 (offset from history_base) and the number of lines in the history file.
92 Appending this session's history to the history file resets this to 0. */
93 int history_lines_this_session;
95 /* The number of lines that Bash has read from the history file. */
96 int history_lines_in_file;
98 #if defined (BANG_HISTORY)
99 /* Non-zero means do no history expansion on this line, regardless
100 of what history_expansion says. */
101 int history_expansion_inhibited;
104 /* With the old default, every line was saved in the history individually.
105 I.e., if the user enters:
110 Each line will be individually saved in the history.
117 If the variable command_oriented_history is set, multiple lines
118 which form one command will be saved as one history entry.
129 The user can then recall the whole command all at once instead
130 of just being able to recall one line at a time.
132 This is now enabled by default.
134 int command_oriented_history = 1;
136 /* Set to 1 if the first line of a possibly-multi-line command was saved
137 in the history list. Managed by maybe_add_history(), but global so
138 the history-manipluating builtins can see it. */
139 int current_command_first_line_saved = 0;
141 /* Non-zero means to store newlines in the history list when using
142 command_oriented_history rather than trying to use semicolons. */
145 /* Non-zero means to append the history to the history file at shell
146 exit, even if the history has been stifled. */
147 int force_append_history;
149 /* A nit for picking at history saving. Flags have the following values:
151 Value == 0 means save all lines parsed by the shell on the history.
152 Value & HC_IGNSPACE means save all lines that do not start with a space.
153 Value & HC_IGNDUPS means save all lines that do not match the last
155 Value & HC_ERASEDUPS means to remove all other matching lines from the
156 history list before saving the latest line. */
159 /* Set to 1 if the last command was added to the history list successfully
160 as a separate history entry; set to 0 if the line was ignored or added
161 to a previous entry as part of command-oriented-history processing. */
162 int hist_last_line_added;
164 /* Set to 1 if builtins/history.def:push_history added the last history
166 int hist_last_line_pushed;
168 #if defined (READLINE)
169 /* If non-zero, and readline is being used, the user is offered the
170 chance to re-edit a failed history expansion. */
171 int history_reediting;
173 /* If non-zero, and readline is being used, don't directly execute a
174 line with history substitution. Reload it into the editing buffer
175 instead and let the user further edit and confirm with a newline. */
178 #endif /* READLINE */
180 /* Non-zero means to not save function definitions in the history list. */
181 int dont_save_function_defs;
183 /* Variables declared in other files used here. */
184 extern int current_command_line_count;
186 extern struct dstack dstack;
187 extern int parser_state;
189 static int bash_history_inhibit_expansion __P((char *, int));
190 #if defined (READLINE)
191 static void re_edit __P((char *));
193 static int history_expansion_p __P((char *));
194 static int shell_comment __P((char *));
195 static int should_expand __P((char *));
196 static HIST_ENTRY *last_history_entry __P((void));
197 static char *expand_histignore_pattern __P((char *));
198 static int history_should_ignore __P((char *));
200 /* Is the history expansion starting at string[i] one that should not
203 bash_history_inhibit_expansion (string, i)
207 /* The shell uses ! as a pattern negation character in globbing [...]
208 expressions, so let those pass without expansion. */
209 if (i > 0 && (string[i - 1] == '[') && member (']', string + i + 1))
211 /* The shell uses ! as the indirect expansion character, so let those
212 expansions pass as well. */
213 else if (i > 1 && string[i - 1] == '{' && string[i - 2] == '$' &&
214 member ('}', string + i + 1))
216 /* The shell uses $! as a defined parameter expansion. */
217 else if (i > 1 && string[i - 1] == '$' && string[i] == '!')
219 #if defined (EXTENDED_GLOB)
220 else if (extended_glob && i > 1 && string[i+1] == '(' && member (')', string + i + 2))
228 bash_initialize_history ()
230 history_quotes_inhibit_expansion = 1;
231 history_search_delimiter_chars = ";&()|<>";
232 history_inhibit_expansion_function = bash_history_inhibit_expansion;
233 #if defined (BANG_HISTORY)
234 sv_histchars ("histchars");
239 bash_history_reinit (interact)
242 #if defined (BANG_HISTORY)
243 history_expansion = interact != 0;
244 history_expansion_inhibited = 1;
246 remember_on_history = enable_history_list = interact != 0;
247 history_inhibit_expansion_function = bash_history_inhibit_expansion;
251 bash_history_disable ()
253 remember_on_history = 0;
254 #if defined (BANG_HISTORY)
255 history_expansion_inhibited = 1;
260 bash_history_enable ()
262 remember_on_history = 1;
263 #if defined (BANG_HISTORY)
264 history_expansion_inhibited = 0;
266 history_inhibit_expansion_function = bash_history_inhibit_expansion;
267 sv_history_control ("HISTCONTROL");
268 sv_histignore ("HISTIGNORE");
271 /* Load the history list from the history file. */
277 /* Truncate history file for interactive shells which desire it.
278 Note that the history file is automatically truncated to the
279 size of HISTSIZE if the user does not explicitly set the size
281 set_if_not ("HISTSIZE", "500");
282 sv_histsize ("HISTSIZE");
284 set_if_not ("HISTFILESIZE", get_string_value ("HISTSIZE"));
285 sv_histsize ("HISTFILESIZE");
287 /* Read the history in HISTFILE into the history list. */
288 hf = get_string_value ("HISTFILE");
290 if (hf && *hf && file_exists (hf))
294 history_lines_in_file = where_history ();
299 bash_clear_history ()
302 history_lines_this_session = 0;
305 /* Delete and free the history list entry at offset I. */
307 bash_delete_histent (i)
312 discard = remove_history (i);
314 free_history_entry (discard);
315 history_lines_this_session--;
321 bash_delete_last_history ()
324 HIST_ENTRY **hlist, *histent;
327 hlist = history_list ();
331 for (i = 0; hlist[i]; i++)
335 /* History_get () takes a parameter that must be offset by history_base. */
336 histent = history_get (history_base + i); /* Don't free this */
340 r = bash_delete_histent (i);
342 if (where_history () > history_length)
343 history_set_pos (history_length);
348 #ifdef INCLUDE_UNUSED
349 /* Write the existing history out to the history file. */
355 hf = get_string_value ("HISTFILE");
356 if (hf && *hf && file_exists (hf))
358 /* Append only the lines that occurred this session to
362 if (history_lines_this_session <= where_history () || force_append_history)
363 append_history (history_lines_this_session, hf);
366 sv_histsize ("HISTFILESIZE");
372 maybe_append_history (filename)
378 result = EXECUTION_SUCCESS;
379 /* XXX - why isn't this <= where_history() ? */
380 if (history_lines_this_session && (history_lines_this_session <= where_history ()))
382 /* If the filename was supplied, then create it if necessary. */
383 if (stat (filename, &buf) == -1 && errno == ENOENT)
385 fd = open (filename, O_WRONLY|O_CREAT, 0600);
388 builtin_error (_("%s: cannot create: %s"), filename, strerror (errno));
389 return (EXECUTION_FAILURE);
393 result = append_history (history_lines_this_session, filename);
394 history_lines_in_file += history_lines_this_session;
395 history_lines_this_session = 0;
400 /* If this is an interactive shell, then append the lines executed
401 this session to the history file. */
403 maybe_save_shell_history ()
409 if (history_lines_this_session)
411 hf = get_string_value ("HISTFILE");
415 /* If the file doesn't exist, then create it. */
416 if (file_exists (hf) == 0)
419 file = open (hf, O_CREAT | O_TRUNC | O_WRONLY, 0600);
424 /* Now actually append the lines if the history hasn't been
425 stifled. If the history has been stifled, rewrite the
428 if (history_lines_this_session <= where_history () || force_append_history)
430 result = append_history (history_lines_this_session, hf);
431 history_lines_in_file += history_lines_this_session;
435 result = write_history (hf);
436 history_lines_in_file = history_lines_this_session;
438 history_lines_this_session = 0;
440 sv_histsize ("HISTFILESIZE");
446 #if defined (READLINE)
447 /* Tell readline () that we have some text for it to edit. */
452 if (bash_input.type == st_stdin)
455 #endif /* READLINE */
457 /* Return 1 if this line needs history expansion. */
459 history_expansion_p (line)
464 for (s = line; *s; s++)
465 if (*s == history_expansion_char || *s == history_subst_char)
470 /* Do pre-processing on LINE. If PRINT_CHANGES is non-zero, then
471 print the results of expanding the line if there were any changes.
472 If there is an error, return NULL, otherwise the expanded line is
473 returned. If ADDIT is non-zero the line is added to the history
474 list after history expansion. ADDIT is just a suggestion;
475 REMEMBER_ON_HISTORY can veto, and does.
476 Right now this does history expansion. */
478 pre_process_line (line, print_changes, addit)
480 int print_changes, addit;
489 # if defined (BANG_HISTORY)
490 /* History expand the line. If this results in no errors, then
491 add that line to the history if ADDIT is non-zero. */
492 if (!history_expansion_inhibited && history_expansion && history_expansion_p (line))
494 expanded = history_expand (line, &history_value);
501 internal_error ("%s", history_value);
502 #if defined (READLINE)
503 else if (hist_verify == 0 || expanded == 2)
507 fprintf (stderr, "%s\n", history_value);
510 /* If there was an error, return NULL. */
511 if (expanded < 0 || expanded == 2) /* 2 == print only */
513 # if defined (READLINE)
514 if (expanded == 2 && rl_dispatching == 0 && *history_value)
516 if (expanded == 2 && *history_value)
517 # endif /* !READLINE */
518 maybe_add_history (history_value);
520 free (history_value);
522 # if defined (READLINE)
523 /* New hack. We can allow the user to edit the
524 failed history expansion. */
525 if (history_reediting && expanded < 0 && rl_done)
527 # endif /* READLINE */
528 return ((char *)NULL);
531 # if defined (READLINE)
532 if (hist_verify && expanded == 1)
534 re_edit (history_value);
535 return ((char *)NULL);
540 /* Let other expansions know that return_value can be free'ed,
541 and that a line has been added to the history list. Note
542 that we only add lines that have something in them. */
544 return_value = history_value;
546 # endif /* BANG_HISTORY */
548 if (addit && remember_on_history && *return_value)
549 maybe_add_history (return_value);
553 return_value = savestring (line);
556 return (return_value);
559 /* Return 1 if the first non-whitespace character in LINE is a `#', indicating
560 * that the line is a shell comment. */
567 for (p = line; p && *p && whitespace (*p); p++)
569 return (p && *p == '#');
572 #ifdef INCLUDE_UNUSED
573 /* Remove shell comments from LINE. A `#' and anything after it is a comment.
574 This isn't really useful yet, since it doesn't handle quoting. */
576 filter_comments (line)
581 for (p = line; p && *p && *p != '#'; p++)
589 /* Check LINE against what HISTCONTROL says to do. Returns 1 if the line
590 should be saved; 0 if it should be discarded. */
592 check_history_control (line)
598 if (history_control == 0)
601 /* ignorespace or ignoreboth */
602 if ((history_control & HC_IGNSPACE) && *line == ' ')
605 /* ignoredups or ignoreboth */
606 if (history_control & HC_IGNDUPS)
609 temp = previous_history ();
611 r = (temp == 0 || STREQ (temp->line, line) == 0);
622 /* Remove all entries matching LINE from the history list. Triggered when
623 HISTCONTROL includes `erasedups'. */
632 while (temp = previous_history ())
634 if (STREQ (temp->line, line))
636 r = where_history ();
643 /* Add LINE to the history list, handling possibly multi-line compound
644 commands. We note whether or not we save the first line of each command
645 (which is usually the entire command and history entry), and don't add
646 the second and subsequent lines of a multi-line compound command if we
647 didn't save the first line. We don't usually save shell comment lines in
648 compound commands in the history, because they could have the effect of
649 commenting out the rest of the command when the entire command is saved as
650 a single history entry (when COMMAND_ORIENTED_HISTORY is enabled). If
651 LITERAL_HISTORY is set, we're saving lines in the history with embedded
652 newlines, so it's OK to save comment lines. We also make sure to save
653 multiple-line quoted strings or other constructs. */
655 maybe_add_history (line)
658 hist_last_line_added = 0;
660 /* Don't use the value of history_control to affect the second
661 and subsequent lines of a multi-line command (old code did
662 this only when command_oriented_history is enabled). */
663 if (current_command_line_count > 1)
665 if (current_command_first_line_saved &&
666 (literal_history || dstack.delimiter_depth != 0 || shell_comment (line) == 0))
667 bash_add_history (line);
671 /* This is the first line of a (possible multi-line) command. Note whether
672 or not we should save the first line and remember it. */
673 current_command_first_line_saved = check_add_history (line, 0);
676 /* Just check LINE against HISTCONTROL and HISTIGNORE and add it to the
677 history if it's OK. Used by `history -s' as well as maybe_add_history().
678 Returns 1 if the line was saved in the history, 0 otherwise. */
680 check_add_history (line, force)
684 if (check_history_control (line) && history_should_ignore (line) == 0)
686 /* We're committed to saving the line. If the user has requested it,
687 remove other matching lines from the history. */
688 if (history_control & HC_ERASEDUPS)
693 really_add_history (line);
697 bash_add_history (line);
703 #if defined (SYSLOG_HISTORY)
704 #define SYSLOG_MAXLEN 600
707 bash_syslog_history (line)
710 char trunc[SYSLOG_MAXLEN];
712 if (strlen(line) < SYSLOG_MAXLEN)
713 syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "HISTORY: PID=%d UID=%d %s", getpid(), current_user.uid, line);
716 strncpy (trunc, line, SYSLOG_MAXLEN);
717 trunc[SYSLOG_MAXLEN - 1] = '\0';
718 syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "HISTORY (TRUNCATED): PID=%d UID=%d %s", getpid(), current_user.uid, trunc);
723 /* Add a line to the history list.
724 The variable COMMAND_ORIENTED_HISTORY controls the style of history
725 remembering; when non-zero, and LINE is not the first line of a
726 complete parser construct, append LINE to the last history line instead
727 of adding it as a new line. */
729 bash_add_history (line)
732 int add_it, offset, curlen;
733 HIST_ENTRY *current, *old;
734 char *chars_to_add, *new_line;
737 if (command_oriented_history && current_command_line_count > 1)
739 chars_to_add = literal_history ? "\n" : history_delimiting_chars (line);
742 current = previous_history ();
746 /* If the previous line ended with an escaped newline (escaped
747 with backslash, but otherwise unquoted), then remove the quoted
748 newline, since that is what happens when the line is parsed. */
749 curlen = strlen (current->line);
751 if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\\' &&
752 current->line[curlen - 2] != '\\')
754 current->line[curlen - 1] = '\0';
759 /* If we're not in some kind of quoted construct, the current history
760 entry ends with a newline, and we're going to add a semicolon,
761 don't. In some cases, it results in a syntax error (e.g., before
762 a close brace), and it should not be needed. */
763 if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\n' && *chars_to_add == ';')
766 new_line = (char *)xmalloc (1
769 + strlen (chars_to_add));
770 sprintf (new_line, "%s%s%s", current->line, chars_to_add, line);
771 offset = where_history ();
772 old = replace_history_entry (offset, new_line, current->data);
776 free_history_entry (old);
783 really_add_history (line);
785 #if defined (SYSLOG_HISTORY)
786 bash_syslog_history (line);
793 really_add_history (line)
796 hist_last_line_added = 1;
797 hist_last_line_pushed = 0;
799 history_lines_this_session++;
806 return (remember_on_history ? history_base + where_history () : 1);
815 for (p = s; p && *p; p++)
826 histignore_item_func (ign)
829 if (should_expand (ign->val))
830 ign->flags |= HIGN_EXPAND;
835 setup_history_ignore (varname)
838 setup_ignore_patterns (&histignore);
842 last_history_entry ()
847 he = previous_history ();
857 he = last_history_entry ();
859 return ((char *)NULL);
864 expand_histignore_pattern (pat)
870 phe = last_history_entry ();
872 if (phe == (HIST_ENTRY *)0)
873 return (savestring (pat));
875 ret = strcreplace (pat, '&', phe->line, 1);
880 /* Return 1 if we should not put LINE into the history according to the
881 patterns in HISTIGNORE. */
883 history_should_ignore (line)
886 register int i, match;
889 if (histignore.num_ignores == 0)
892 for (i = match = 0; i < histignore.num_ignores; i++)
894 if (histignore.ignores[i].flags & HIGN_EXPAND)
895 npat = expand_histignore_pattern (histignore.ignores[i].val);
897 npat = histignore.ignores[i].val;
899 match = strmatch (npat, line, FNMATCH_EXTFLAG) != FNM_NOMATCH;
901 if (histignore.ignores[i].flags & HIGN_EXPAND)