bashhist.c

   1 /* bashhist.c -- bash interface to the GNU history library. */
   2
   3 /* Copyright (C) 1993-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   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.
  11
  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.
  16
  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/>.
  19 */
  20
  21 #include "config.h"
  22
  23 #if defined (HISTORY)
  24
  25 #if defined (HAVE_UNISTD_H)
  26 #  ifdef _MINIX
  27  #    include <sys/types.h>
  28 #  endif
  29 #  include <unistd.h>
  30 #endif
  31
  32 #include "bashtypes.h"
  33 #include <stdio.h>
  34 #include <errno.h>
  35 #include "bashansi.h"
  36 #include "posixstat.h"
  37 #include "filecntl.h"
  38
  39 #include "bashintl.h"
  40
  41 #if defined (SYSLOG_HISTORY)
  42 #  include <syslog.h>
  43 #endif
  44
  45 #include "shell.h"
  46 #include "flags.h"
  47 #include "input.h"
  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"
  52
  53 #include <readline/history.h>
  54 #include <glob/glob.h>
  55 #include <glob/strmatch.h>
  56
  57 #if defined (READLINE)
  58 #  include "bashline.h"
  59 extern int rl_done, rl_dispatching;     /* should really include readline.h */
  60 #endif
  61
  62 #if !defined (errno)
  63 extern int errno;
  64 #endif
  65
  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 *));
  70
  71 static struct ignorevar histignore =
  72 {
  73   "HISTIGNORE",
  74   (struct ign *)0,
  75   0,
  76   (char *)0,
  77   (sh_iv_item_func_t *)histignore_item_func,
  78 };
  79
  80 #define HIGN_EXPAND 0x01
  81
  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 = 0;
  87 int enable_history_list = 0;    /* value for `set -o history' */
  88
  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;
  94
  95 /* The number of lines that Bash has read from the history file. */
  96 int history_lines_in_file;
  97
  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;
 102 /* If non-zero, double quotes can quote the history expansion character. */
 103 int double_quotes_inhibit_history_expansion = 0;
 104 #endif
 105
 106 /* With the old default, every line was saved in the history individually.
 107    I.e., if the user enters:
 108         bash$ for i in a b c
 109         > do
 110         > echo $i
 111         > done
 112    Each line will be individually saved in the history.
 113         bash$ history
 114         10  for i in a b c
 115         11  do
 116         12  echo $i
 117         13  done
 118         14  history
 119    If the variable command_oriented_history is set, multiple lines
 120    which form one command will be saved as one history entry.
 121         bash$ for i in a b c
 122         > do
 123         > echo $i
 124         > done
 125         bash$ history
 126         10  for i in a b c
 127     do
 128     echo $i
 129     done
 130         11  history
 131    The user can then recall the whole command all at once instead
 132    of just being able to recall one line at a time.
 133
 134    This is now enabled by default.
 135    */
 136 int command_oriented_history = 1;
 137
 138 /* Set to 1 if the first line of a possibly-multi-line command was saved
 139    in the history list.  Managed by maybe_add_history(), but global so
 140    the history-manipluating builtins can see it. */
 141 int current_command_first_line_saved = 0;
 142
 143 /* Non-zero means to store newlines in the history list when using
 144    command_oriented_history rather than trying to use semicolons. */
 145 int literal_history;
 146
 147 /* Non-zero means to append the history to the history file at shell
 148    exit, even if the history has been stifled. */
 149 int force_append_history;
 150
 151 /* A nit for picking at history saving.  Flags have the following values:
 152
 153    Value == 0 means save all lines parsed by the shell on the history.
 154    Value & HC_IGNSPACE means save all lines that do not start with a space.
 155    Value & HC_IGNDUPS means save all lines that do not match the last
 156    line saved.
 157    Value & HC_ERASEDUPS means to remove all other matching lines from the
 158    history list before saving the latest line. */
 159 int history_control;
 160
 161 /* Set to 1 if the last command was added to the history list successfully
 162    as a separate history entry; set to 0 if the line was ignored or added
 163    to a previous entry as part of command-oriented-history processing. */
 164 int hist_last_line_added;
 165
 166 /* Set to 1 if builtins/history.def:push_history added the last history
 167    entry. */
 168 int hist_last_line_pushed;
 169
 170 #if defined (READLINE)
 171 /* If non-zero, and readline is being used, the user is offered the
 172    chance to re-edit a failed history expansion. */
 173 int history_reediting;
 174
 175 /* If non-zero, and readline is being used, don't directly execute a
 176    line with history substitution.  Reload it into the editing buffer
 177    instead and let the user further edit and confirm with a newline. */
 178 int hist_verify;
 179
 180 #endif /* READLINE */
 181
 182 /* Non-zero means to not save function definitions in the history list. */
 183 int dont_save_function_defs;
 184
 185 /* Variables declared in other files used here. */
 186 extern int current_command_line_count;
 187
 188 extern struct dstack dstack;
 189 extern int parser_state;
 190
 191 #if defined (BANG_HISTORY)
 192 static int bash_history_inhibit_expansion __P((char *, int));
 193 #endif
 194 #if defined (READLINE)
 195 static void re_edit __P((char *));
 196 #endif
 197 static int history_expansion_p __P((char *));
 198 static int shell_comment __P((char *));
 199 static int should_expand __P((char *));
 200 static HIST_ENTRY *last_history_entry __P((void));
 201 static char *expand_histignore_pattern __P((char *));
 202 static int history_should_ignore __P((char *));
 203
 204 #if defined (BANG_HISTORY)
 205 /* Is the history expansion starting at string[i] one that should not
 206    be expanded? */
 207 static int
 208 bash_history_inhibit_expansion (string, i)
 209      char *string;
 210      int i;
 211 {
 212   int t;
 213   char hx[2];
 214
 215   hx[0] = history_expansion_char;
 216   hx[1] = '\0';
 217
 218   /* The shell uses ! as a pattern negation character in globbing [...]
 219      expressions, so let those pass without expansion. */
 220   if (i > 0 && (string[i - 1] == '[') && member (']', string + i + 1))
 221     return (1);
 222   /* The shell uses ! as the indirect expansion character, so let those
 223      expansions pass as well. */
 224   else if (i > 1 && string[i - 1] == '{' && string[i - 2] == '$' &&
 225              member ('}', string + i + 1))
 226     return (1);
 227   /* The shell uses $! as a defined parameter expansion. */
 228   else if (i > 1 && string[i - 1] == '$' && string[i] == '!')
 229     return (1);
 230 #if defined (EXTENDED_GLOB)
 231   else if (extended_glob && i > 1 && string[i+1] == '(' && member (')', string + i + 2))
 232     return (1);
 233 #endif
 234
 235   /* Make sure the history expansion should not be skipped by quoting or
 236      command/process substitution. */
 237   else if ((t = skip_to_histexp (string, 0, hx, SD_NOJMP|SD_HISTEXP)) > 0)
 238     {
 239       /* Skip instances of history expansion appearing on the line before
 240          this one. */
 241       while (t < i)
 242         {
 243           t = skip_to_histexp (string, t+1, hx, SD_NOJMP|SD_HISTEXP);
 244           if (t <= 0)
 245             return 0;
 246         }
 247       return (t > i);
 248     }
 249   else
 250     return (0);
 251 }
 252 #endif
 253
 254 void
 255 bash_initialize_history ()
 256 {
 257   history_quotes_inhibit_expansion = 1;
 258   history_search_delimiter_chars = ";&()|<>";
 259 #if defined (BANG_HISTORY)
 260   history_inhibit_expansion_function = bash_history_inhibit_expansion;
 261   sv_histchars ("histchars");
 262 #endif
 263 }
 264
 265 void
 266 bash_history_reinit (interact)
 267      int interact;
 268 {
 269 #if defined (BANG_HISTORY)
 270   history_expansion = interact != 0;
 271   history_expansion_inhibited = 1;      /* XXX */
 272   history_inhibit_expansion_function = bash_history_inhibit_expansion;
 273 #endif
 274   remember_on_history = enable_history_list;
 275 }
 276
 277 void
 278 bash_history_disable ()
 279 {
 280   remember_on_history = 0;
 281 #if defined (BANG_HISTORY)
 282   history_expansion_inhibited = 1;
 283 #endif
 284 }
 285
 286 void
 287 bash_history_enable ()
 288 {
 289   remember_on_history = enable_history_list = 1;
 290 #if defined (BANG_HISTORY)
 291   history_expansion_inhibited = 0;
 292   history_inhibit_expansion_function = bash_history_inhibit_expansion;
 293 #endif
 294   sv_history_control ("HISTCONTROL");
 295   sv_histignore ("HISTIGNORE");
 296 }
 297
 298 /* Load the history list from the history file. */
 299 void
 300 load_history ()
 301 {
 302   char *hf;
 303
 304   /* Truncate history file for interactive shells which desire it.
 305      Note that the history file is automatically truncated to the
 306      size of HISTSIZE if the user does not explicitly set the size
 307      differently. */
 308   set_if_not ("HISTSIZE", "500");
 309   sv_histsize ("HISTSIZE");
 310
 311   set_if_not ("HISTFILESIZE", get_string_value ("HISTSIZE"));
 312   sv_histsize ("HISTFILESIZE");
 313
 314   /* Read the history in HISTFILE into the history list. */
 315   hf = get_string_value ("HISTFILE");
 316
 317   if (hf && *hf && file_exists (hf))
 318     {
 319       read_history (hf);
 320       /* We have read all of the lines from the history file, even if we
 321          read more lines than $HISTSIZE.  Remember the total number of lines
 322          we read so we don't count the last N lines as new over and over
 323          again. */
 324       history_lines_in_file = history_lines_read_from_file;
 325       using_history ();
 326       /* history_lines_in_file = where_history () + history_base - 1; */
 327     }
 328 }
 329
 330 void
 331 bash_clear_history ()
 332 {
 333   clear_history ();
 334   history_lines_this_session = 0;
 335   /* XXX - reset history_lines_read_from_file? */
 336 }
 337
 338 /* Delete and free the history list entry at offset I. */
 339 int
 340 bash_delete_histent (i)
 341      int i;
 342 {
 343   HIST_ENTRY *discard;
 344
 345   discard = remove_history (i);
 346   if (discard)
 347     free_history_entry (discard);
 348   history_lines_this_session--;
 349
 350   return 1;
 351 }
 352
 353 int
 354 bash_delete_last_history ()
 355 {
 356   register int i;
 357   HIST_ENTRY **hlist, *histent;
 358   int r;
 359
 360   hlist = history_list ();
 361   if (hlist == NULL)
 362     return 0;
 363
 364   for (i = 0; hlist[i]; i++)
 365     ;
 366   i--;
 367
 368   /* History_get () takes a parameter that must be offset by history_base. */
 369   histent = history_get (history_base + i);     /* Don't free this */
 370   if (histent == NULL)
 371     return 0;
 372
 373   r = bash_delete_histent (i);
 374
 375   if (where_history () > history_length)
 376     history_set_pos (history_length);
 377
 378   return r;
 379 }
 380
 381 #ifdef INCLUDE_UNUSED
 382 /* Write the existing history out to the history file. */
 383 void
 384 save_history ()
 385 {
 386   char *hf;
 387   int r;
 388
 389   hf = get_string_value ("HISTFILE");
 390   if (hf && *hf && file_exists (hf))
 391     {
 392       /* Append only the lines that occurred this session to
 393          the history file. */
 394       using_history ();
 395
 396       if (history_lines_this_session <= where_history () || force_append_history)
 397         r = append_history (history_lines_this_session, hf);
 398       else
 399         r = write_history (hf);
 400       sv_histsize ("HISTFILESIZE");
 401     }
 402 }
 403 #endif
 404
 405 int
 406 maybe_append_history (filename)
 407      char *filename;
 408 {
 409   int fd, result;
 410   struct stat buf;
 411
 412   result = EXECUTION_SUCCESS;
 413   if (history_lines_this_session > 0 && (history_lines_this_session <= where_history ()))
 414     {
 415       /* If the filename was supplied, then create it if necessary. */
 416       if (stat (filename, &buf) == -1 && errno == ENOENT)
 417         {
 418           fd = open (filename, O_WRONLY|O_CREAT, 0600);
 419           if (fd < 0)
 420             {
 421               builtin_error (_("%s: cannot create: %s"), filename, strerror (errno));
 422               return (EXECUTION_FAILURE);
 423             }
 424           close (fd);
 425         }
 426       result = append_history (history_lines_this_session, filename);
 427       /* Pretend we already read these lines from the file because we just
 428          added them */
 429       history_lines_in_file += history_lines_this_session;
 430       history_lines_this_session = 0;
 431     }
 432   else
 433     history_lines_this_session = 0;     /* reset if > where_history() */
 434
 435   return (result);
 436 }
 437
 438 /* If this is an interactive shell, then append the lines executed
 439    this session to the history file. */
 440 int
 441 maybe_save_shell_history ()
 442 {
 443   int result;
 444   char *hf;
 445
 446   result = 0;
 447   if (history_lines_this_session > 0)
 448     {
 449       hf = get_string_value ("HISTFILE");
 450
 451       if (hf && *hf)
 452         {
 453           /* If the file doesn't exist, then create it. */
 454           if (file_exists (hf) == 0)
 455             {
 456               int file;
 457               file = open (hf, O_CREAT | O_TRUNC | O_WRONLY, 0600);
 458               if (file != -1)
 459                 close (file);
 460             }
 461
 462           /* Now actually append the lines if the history hasn't been
 463              stifled.  If the history has been stifled, rewrite the
 464              history file. */
 465           using_history ();
 466           if (history_lines_this_session <= where_history () || force_append_history)
 467             {
 468               result = append_history (history_lines_this_session, hf);
 469               history_lines_in_file += history_lines_this_session;
 470             }
 471           else
 472             {
 473               result = write_history (hf);
 474               history_lines_in_file = history_lines_written_to_file;
 475               /* history_lines_in_file = where_history () + history_base - 1; */
 476             }
 477           history_lines_this_session = 0;
 478
 479           sv_histsize ("HISTFILESIZE");
 480         }
 481     }
 482   return (result);
 483 }
 484
 485 #if defined (READLINE)
 486 /* Tell readline () that we have some text for it to edit. */
 487 static void
 488 re_edit (text)
 489      char *text;
 490 {
 491   if (bash_input.type == st_stdin)
 492     bash_re_edit (text);
 493 }
 494 #endif /* READLINE */
 495
 496 /* Return 1 if this line needs history expansion. */
 497 static int
 498 history_expansion_p (line)
 499      char *line;
 500 {
 501   register char *s;
 502
 503   for (s = line; *s; s++)
 504     if (*s == history_expansion_char || *s == history_subst_char)
 505       return 1;
 506   return 0;
 507 }
 508
 509 /* Do pre-processing on LINE.  If PRINT_CHANGES is non-zero, then
 510    print the results of expanding the line if there were any changes.
 511    If there is an error, return NULL, otherwise the expanded line is
 512    returned.  If ADDIT is non-zero the line is added to the history
 513    list after history expansion.  ADDIT is just a suggestion;
 514    REMEMBER_ON_HISTORY can veto, and does.
 515    Right now this does history expansion. */
 516 char *
 517 pre_process_line (line, print_changes, addit)
 518      char *line;
 519      int print_changes, addit;
 520 {
 521   char *history_value;
 522   char *return_value;
 523   int expanded;
 524
 525   return_value = line;
 526   expanded = 0;
 527
 528 #  if defined (BANG_HISTORY)
 529   /* History expand the line.  If this results in no errors, then
 530      add that line to the history if ADDIT is non-zero. */
 531   if (!history_expansion_inhibited && history_expansion && history_expansion_p (line))
 532     {
 533       expanded = history_expand (line, &history_value);
 534
 535       if (expanded)
 536         {
 537           if (print_changes)
 538             {
 539               if (expanded < 0)
 540                 internal_error ("%s", history_value);
 541 #if defined (READLINE)
 542               else if (hist_verify == 0 || expanded == 2)
 543 #else
 544               else
 545 #endif
 546                 fprintf (stderr, "%s\n", history_value);
 547             }
 548
 549           /* If there was an error, return NULL. */
 550           if (expanded < 0 || expanded == 2)    /* 2 == print only */
 551             {
 552 #    if defined (READLINE)
 553               if (expanded == 2 && rl_dispatching == 0 && *history_value)
 554 #    else
 555               if (expanded == 2 && *history_value)
 556 #    endif /* !READLINE */
 557                 maybe_add_history (history_value);
 558
 559               free (history_value);
 560
 561 #    if defined (READLINE)
 562               /* New hack.  We can allow the user to edit the
 563                  failed history expansion. */
 564               if (history_reediting && expanded < 0 && rl_done)
 565                 re_edit (line);
 566 #    endif /* READLINE */
 567               return ((char *)NULL);
 568             }
 569
 570 #    if defined (READLINE)
 571           if (hist_verify && expanded == 1)
 572             {
 573               re_edit (history_value);
 574               free (history_value);
 575               return ((char *)NULL);
 576             }
 577 #    endif
 578         }
 579
 580       /* Let other expansions know that return_value can be free'ed,
 581          and that a line has been added to the history list.  Note
 582          that we only add lines that have something in them. */
 583       expanded = 1;
 584       return_value = history_value;
 585     }
 586 #  endif /* BANG_HISTORY */
 587
 588   if (addit && remember_on_history && *return_value)
 589     maybe_add_history (return_value);
 590
 591 #if 0
 592   if (expanded == 0)
 593     return_value = savestring (line);
 594 #endif
 595
 596   return (return_value);
 597 }
 598
 599 /* Return 1 if the first non-whitespace character in LINE is a `#', indicating
 600  * that the line is a shell comment. */
 601 static int
 602 shell_comment (line)
 603      char *line;
 604 {
 605   char *p;
 606
 607   for (p = line; p && *p && whitespace (*p); p++)
 608     ;
 609   return (p && *p == '#');
 610 }
 611
 612 #ifdef INCLUDE_UNUSED
 613 /* Remove shell comments from LINE.  A `#' and anything after it is a comment.
 614    This isn't really useful yet, since it doesn't handle quoting. */
 615 static char *
 616 filter_comments (line)
 617      char *line;
 618 {
 619   char *p;
 620
 621   for (p = line; p && *p && *p != '#'; p++)
 622     ;
 623   if (p && *p == '#')
 624     *p = '\0';
 625   return (line);
 626 }
 627 #endif
 628
 629 /* Check LINE against what HISTCONTROL says to do.  Returns 1 if the line
 630    should be saved; 0 if it should be discarded. */
 631 static int
 632 check_history_control (line)
 633      char *line;
 634 {
 635   HIST_ENTRY *temp;
 636   int r;
 637
 638   if (history_control == 0)
 639     return 1;
 640
 641   /* ignorespace or ignoreboth */
 642   if ((history_control & HC_IGNSPACE) && *line == ' ')
 643     return 0;
 644
 645   /* ignoredups or ignoreboth */
 646   if (history_control & HC_IGNDUPS)
 647     {
 648       using_history ();
 649       temp = previous_history ();
 650
 651       r = (temp == 0 || STREQ (temp->line, line) == 0);
 652
 653       using_history ();
 654
 655       if (r == 0)
 656         return r;
 657     }
 658
 659   return 1;
 660 }
 661
 662 /* Remove all entries matching LINE from the history list.  Triggered when
 663    HISTCONTROL includes `erasedups'. */
 664 static void
 665 hc_erasedups (line)
 666      char *line;
 667 {
 668   HIST_ENTRY *temp;
 669   int r;
 670
 671   using_history ();
 672   while (temp = previous_history ())
 673     {
 674       if (STREQ (temp->line, line))
 675         {
 676           r = where_history ();
 677           temp = remove_history (r);
 678           if (temp)
 679             free_history_entry (temp);
 680         }
 681     }
 682   using_history ();
 683 }
 684
 685 /* Add LINE to the history list, handling possibly multi-line compound
 686    commands.  We note whether or not we save the first line of each command
 687    (which is usually the entire command and history entry), and don't add
 688    the second and subsequent lines of a multi-line compound command if we
 689    didn't save the first line.  We don't usually save shell comment lines in
 690    compound commands in the history, because they could have the effect of
 691    commenting out the rest of the command when the entire command is saved as
 692    a single history entry (when COMMAND_ORIENTED_HISTORY is enabled).  If
 693    LITERAL_HISTORY is set, we're saving lines in the history with embedded
 694    newlines, so it's OK to save comment lines.  If we're collecting the body
 695    of a here-document, we should act as if literal_history is enabled, because
 696    we want to save the entire contents of the here-document as it was
 697    entered.  We also make sure to save multiple-line quoted strings or other
 698    constructs. */
 699 void
 700 maybe_add_history (line)
 701      char *line;
 702 {
 703   hist_last_line_added = 0;
 704
 705   /* Don't use the value of history_control to affect the second
 706      and subsequent lines of a multi-line command (old code did
 707      this only when command_oriented_history is enabled). */
 708   if (current_command_line_count > 1)
 709     {
 710       if (current_command_first_line_saved &&
 711           ((parser_state & PST_HEREDOC) || literal_history || dstack.delimiter_depth != 0 || shell_comment (line) == 0))
 712         bash_add_history (line);
 713       return;
 714     }
 715
 716   /* This is the first line of a (possible multi-line) command.  Note whether
 717      or not we should save the first line and remember it. */
 718   current_command_first_line_saved = check_add_history (line, 0);
 719 }
 720
 721 /* Just check LINE against HISTCONTROL and HISTIGNORE and add it to the
 722    history if it's OK.  Used by `history -s' as well as maybe_add_history().
 723    Returns 1 if the line was saved in the history, 0 otherwise. */
 724 int
 725 check_add_history (line, force)
 726      char *line;
 727      int force;
 728 {
 729   if (check_history_control (line) && history_should_ignore (line) == 0)
 730     {
 731       /* We're committed to saving the line.  If the user has requested it,
 732          remove other matching lines from the history. */
 733       if (history_control & HC_ERASEDUPS)
 734         hc_erasedups (line);
 735
 736       if (force)
 737         {
 738           really_add_history (line);
 739           using_history ();
 740         }
 741       else
 742         bash_add_history (line);
 743       return 1;
 744     }
 745   return 0;
 746 }
 747
 748 #if defined (SYSLOG_HISTORY)
 749 #define SYSLOG_MAXLEN 600
 750
 751 extern char *shell_name;
 752
 753 #ifndef OPENLOG_OPTS
 754 #define OPENLOG_OPTS 0
 755 #endif
 756
 757 void
 758 bash_syslog_history (line)
 759      const char *line;
 760 {
 761   char trunc[SYSLOG_MAXLEN];
 762   static int first = 1;
 763
 764   if (first)
 765     {
 766       openlog (shell_name, OPENLOG_OPTS, SYSLOG_FACILITY);
 767       first = 0;
 768     }
 769
 770   if (strlen(line) < SYSLOG_MAXLEN)
 771     syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "HISTORY: PID=%d UID=%d %s", getpid(), current_user.uid, line);
 772   else
 773     {
 774       strncpy (trunc, line, SYSLOG_MAXLEN);
 775       trunc[SYSLOG_MAXLEN - 1] = '\0';
 776       syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "HISTORY (TRUNCATED): PID=%d UID=%d %s", getpid(), current_user.uid, trunc);
 777     }
 778 }
 779 #endif
 780
 781 /* Add a line to the history list.
 782    The variable COMMAND_ORIENTED_HISTORY controls the style of history
 783    remembering;  when non-zero, and LINE is not the first line of a
 784    complete parser construct, append LINE to the last history line instead
 785    of adding it as a new line. */
 786 void
 787 bash_add_history (line)
 788      char *line;
 789 {
 790   int add_it, offset, curlen;
 791   HIST_ENTRY *current, *old;
 792   char *chars_to_add, *new_line;
 793
 794   add_it = 1;
 795   if (command_oriented_history && current_command_line_count > 1)
 796     {
 797       /* The second and subsequent lines of a here document have the trailing
 798          newline preserved.  We don't want to add extra newlines here, but we
 799          do want to add one after the first line (which is the command that
 800          contains the here-doc specifier).  parse.y:history_delimiting_chars()
 801          does the right thing to take care of this for us.  We don't want to
 802          add extra newlines if the user chooses to enable literal_history,
 803          so we have to duplicate some of what that function does here. */
 804       if ((parser_state & PST_HEREDOC) && literal_history && current_command_line_count > 2 && line[strlen (line) - 1] == '\n')
 805         chars_to_add = "";
 806       else
 807         chars_to_add = literal_history ? "\n" : history_delimiting_chars (line);
 808
 809       using_history ();
 810       current = previous_history ();
 811
 812       if (current)
 813         {
 814           /* If the previous line ended with an escaped newline (escaped
 815              with backslash, but otherwise unquoted), then remove the quoted
 816              newline, since that is what happens when the line is parsed. */
 817           curlen = strlen (current->line);
 818
 819           if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\\' &&
 820               current->line[curlen - 2] != '\\')
 821             {
 822               current->line[curlen - 1] = '\0';
 823               curlen--;
 824               chars_to_add = "";
 825             }
 826
 827           /* If we're not in some kind of quoted construct, the current history
 828              entry ends with a newline, and we're going to add a semicolon,
 829              don't.  In some cases, it results in a syntax error (e.g., before
 830              a close brace), and it should not be needed. */
 831           if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\n' && *chars_to_add == ';')
 832             chars_to_add++;
 833
 834           new_line = (char *)xmalloc (1
 835                                       + curlen
 836                                       + strlen (line)
 837                                       + strlen (chars_to_add));
 838           sprintf (new_line, "%s%s%s", current->line, chars_to_add, line);
 839           offset = where_history ();
 840           old = replace_history_entry (offset, new_line, current->data);
 841           free (new_line);
 842
 843           if (old)
 844             free_history_entry (old);
 845
 846           add_it = 0;
 847         }
 848     }
 849
 850   if (add_it)
 851     really_add_history (line);
 852
 853 #if defined (SYSLOG_HISTORY)
 854   bash_syslog_history (line);
 855 #endif
 856
 857   using_history ();
 858 }
 859
 860 static void
 861 really_add_history (line)
 862      char *line;
 863 {
 864   hist_last_line_added = 1;
 865   hist_last_line_pushed = 0;
 866   add_history (line);
 867   history_lines_this_session++;
 868 }
 869
 870 int
 871 history_number ()
 872 {
 873   using_history ();
 874   return (remember_on_history ? history_base + where_history () : 1);
 875 }
 876
 877 static int
 878 should_expand (s)
 879      char *s;
 880 {
 881   char *p;
 882
 883   for (p = s; p && *p; p++)
 884     {
 885       if (*p == '\\')
 886         p++;
 887       else if (*p == '&')
 888         return 1;
 889     }
 890   return 0;
 891 }
 892
 893 static int
 894 histignore_item_func (ign)
 895      struct ign *ign;
 896 {
 897   if (should_expand (ign->val))
 898     ign->flags |= HIGN_EXPAND;
 899   return (0);
 900 }
 901
 902 void
 903 setup_history_ignore (varname)
 904      char *varname;
 905 {
 906   setup_ignore_patterns (&histignore);
 907 }
 908
 909 static HIST_ENTRY *
 910 last_history_entry ()
 911 {
 912   HIST_ENTRY *he;
 913
 914   using_history ();
 915   he = previous_history ();
 916   using_history ();
 917   return he;
 918 }
 919
 920 char *
 921 last_history_line ()
 922 {
 923   HIST_ENTRY *he;
 924
 925   he = last_history_entry ();
 926   if (he == 0)
 927     return ((char *)NULL);
 928   return he->line;
 929 }
 930
 931 static char *
 932 expand_histignore_pattern (pat)
 933      char *pat;
 934 {
 935   HIST_ENTRY *phe;
 936   char *ret;
 937
 938   phe = last_history_entry ();
 939
 940   if (phe == (HIST_ENTRY *)0)
 941     return (savestring (pat));
 942
 943   ret = strcreplace (pat, '&', phe->line, 1);
 944
 945   return ret;
 946 }
 947
 948 /* Return 1 if we should not put LINE into the history according to the
 949    patterns in HISTIGNORE. */
 950 static int
 951 history_should_ignore (line)
 952      char *line;
 953 {
 954   register int i, match;
 955   char *npat;
 956
 957   if (histignore.num_ignores == 0)
 958     return 0;
 959
 960   for (i = match = 0; i < histignore.num_ignores; i++)
 961     {
 962       if (histignore.ignores[i].flags & HIGN_EXPAND)
 963         npat = expand_histignore_pattern (histignore.ignores[i].val);
 964       else
 965         npat = histignore.ignores[i].val;
 966
 967       match = strmatch (npat, line, FNMATCH_EXTFLAG) != FNM_NOMATCH;
 968
 969       if (histignore.ignores[i].flags & HIGN_EXPAND)
 970         free (npat);
 971
 972       if (match)
 973         break;
 974     }
 975
 976   return match;
 977 }
 978 #endif /* HISTORY */