src/histrap.c

   1 /*      $OpenBSD: history.c,v 1.41 2015/09/01 13:12:31 tedu Exp $       */
   2 /*      $OpenBSD: trap.c,v 1.23 2010/05/19 17:36:08 jasper Exp $        */
   3
   4 /*-
   5  * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
   6  *               2011, 2012, 2014, 2015, 2016, 2017
   7  *      mirabilos <m@mirbsd.org>
   8  *
   9  * Provided that these terms and disclaimer and all copyright notices
  10  * are retained or reproduced in an accompanying document, permission
  11  * is granted to deal in this work without restriction, including un-
  12  * limited rights to use, publicly perform, distribute, sell, modify,
  13  * merge, give away, or sublicence.
  14  *
  15  * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to
  16  * the utmost extent permitted by applicable law, neither express nor
  17  * implied; without malicious intent or gross negligence. In no event
  18  * may a licensor, author or contributor be held liable for indirect,
  19  * direct, other damage, loss, or other issues arising in any way out
  20  * of dealing in the work, even if advised of the possibility of such
  21  * damage or existence of a defect, except proven that it results out
  22  * of said person's immediate fault when using the work as intended.
  23  */
  24
  25 #include "sh.h"
  26 #if HAVE_SYS_FILE_H
  27 #include <sys/file.h>
  28 #endif
  29
  30 __RCSID("$MirOS: src/bin/mksh/histrap.c,v 1.166 2017/08/07 23:25:09 tg Exp $");
  31
  32 Trap sigtraps[ksh_NSIG + 1];
  33 static struct sigaction Sigact_ign;
  34
  35 #if HAVE_PERSISTENT_HISTORY
  36 static int histload(Source *, unsigned char *, size_t);
  37 static int writehistline(int, int, const char *);
  38 static void writehistfile(int, const char *);
  39 #endif
  40
  41 static int hist_execute(char *, Area *);
  42 static char **hist_get(const char *, bool, bool);
  43 static char **hist_get_oldest(void);
  44
  45 static bool hstarted;           /* set after hist_init() called */
  46 static Source *hist_source;
  47
  48 #if HAVE_PERSISTENT_HISTORY
  49 /*XXX imake style */
  50 #if defined(__linux)
  51 #define caddr_cast(x)   ((void *)(x))
  52 #else
  53 #define caddr_cast(x)   ((caddr_t)(x))
  54 #endif
  55
  56 /* several OEs do not have these constants */
  57 #ifndef MAP_FAILED
  58 #define MAP_FAILED      caddr_cast(-1)
  59 #endif
  60
  61 /* some OEs need the default mapping type specified */
  62 #ifndef MAP_FILE
  63 #define MAP_FILE        0
  64 #endif
  65
  66 /* current history file: name, fd, size */
  67 static char *hname;
  68 static int histfd = -1;
  69 static off_t histfsize;
  70 #endif
  71
  72 /* HISTSIZE default: size of saved history, persistent or standard */
  73 #ifdef MKSH_SMALL
  74 #define MKSH_DEFHISTSIZE        255
  75 #else
  76 #define MKSH_DEFHISTSIZE        2047
  77 #endif
  78 /* maximum considered size of persistent history file */
  79 #define MKSH_MAXHISTFSIZE       ((off_t)1048576 * 96)
  80
  81 /* hidden option */
  82 #define HIST_DISCARD            5
  83
  84 int
  85 c_fc(const char **wp)
  86 {
  87         struct shf *shf;
  88         struct temp *tf;
  89         bool gflag = false, lflag = false, nflag = false, rflag = false,
  90             sflag = false;
  91         int optc;
  92         const char *p, *first = NULL, *last = NULL;
  93         char **hfirst, **hlast, **hp, *editor = NULL;
  94
  95         if (!Flag(FTALKING_I)) {
  96                 bi_errorf("history %ss not available", Tfunction);
  97                 return (1);
  98         }
  99
 100         while ((optc = ksh_getopt(wp, &builtin_opt,
 101             "e:glnrs0,1,2,3,4,5,6,7,8,9,")) != -1)
 102                 switch (optc) {
 103
 104                 case 'e':
 105                         p = builtin_opt.optarg;
 106                         if (ksh_isdash(p))
 107                                 sflag = true;
 108                         else {
 109                                 size_t len = strlen(p);
 110
 111                                 /* almost certainly not overflowing */
 112                                 editor = alloc(len + 4, ATEMP);
 113                                 memcpy(editor, p, len);
 114                                 memcpy(editor + len, Tspdollaru, 4);
 115                         }
 116                         break;
 117
 118                 /* non-AT&T ksh */
 119                 case 'g':
 120                         gflag = true;
 121                         break;
 122
 123                 case 'l':
 124                         lflag = true;
 125                         break;
 126
 127                 case 'n':
 128                         nflag = true;
 129                         break;
 130
 131                 case 'r':
 132                         rflag = true;
 133                         break;
 134
 135                 /* POSIX version of -e - */
 136                 case 's':
 137                         sflag = true;
 138                         break;
 139
 140                 /* kludge city - accept -num as -- -num (kind of) */
 141                 case '0': case '1': case '2': case '3': case '4':
 142                 case '5': case '6': case '7': case '8': case '9':
 143                         p = shf_smprintf("-%c%s",
 144                                         optc, builtin_opt.optarg);
 145                         if (!first)
 146                                 first = p;
 147                         else if (!last)
 148                                 last = p;
 149                         else {
 150                                 bi_errorf(Ttoo_many_args);
 151                                 return (1);
 152                         }
 153                         break;
 154
 155                 case '?':
 156                         return (1);
 157                 }
 158         wp += builtin_opt.optind;
 159
 160         /* Substitute and execute command */
 161         if (sflag) {
 162                 char *pat = NULL, *rep = NULL, *line;
 163
 164                 if (editor || lflag || nflag || rflag) {
 165                         bi_errorf("can't use -e, -l, -n, -r with -s (-e -)");
 166                         return (1);
 167                 }
 168
 169                 /* Check for pattern replacement argument */
 170                 if (*wp && **wp && (p = cstrchr(*wp + 1, '='))) {
 171                         strdupx(pat, *wp, ATEMP);
 172                         rep = pat + (p - *wp);
 173                         *rep++ = '\0';
 174                         wp++;
 175                 }
 176                 /* Check for search prefix */
 177                 if (!first && (first = *wp))
 178                         wp++;
 179                 if (last || *wp) {
 180                         bi_errorf(Ttoo_many_args);
 181                         return (1);
 182                 }
 183
 184                 hp = first ? hist_get(first, false, false) :
 185                     hist_get_newest(false);
 186                 if (!hp)
 187                         return (1);
 188                 /* hist_replace */
 189                 if (!pat)
 190                         strdupx(line, *hp, ATEMP);
 191                 else {
 192                         char *s, *s1;
 193                         size_t len, pat_len, rep_len;
 194                         XString xs;
 195                         char *xp;
 196                         bool any_subst = false;
 197
 198                         pat_len = strlen(pat);
 199                         rep_len = strlen(rep);
 200                         Xinit(xs, xp, 128, ATEMP);
 201                         for (s = *hp; (s1 = strstr(s, pat)) &&
 202                             (!any_subst || gflag); s = s1 + pat_len) {
 203                                 any_subst = true;
 204                                 len = s1 - s;
 205                                 XcheckN(xs, xp, len + rep_len);
 206                                 /*; first part */
 207                                 memcpy(xp, s, len);
 208                                 xp += len;
 209                                 /* replacement */
 210                                 memcpy(xp, rep, rep_len);
 211                                 xp += rep_len;
 212                         }
 213                         if (!any_subst) {
 214                                 bi_errorf(Tbadsubst);
 215                                 return (1);
 216                         }
 217                         len = strlen(s) + 1;
 218                         XcheckN(xs, xp, len);
 219                         memcpy(xp, s, len);
 220                         xp += len;
 221                         line = Xclose(xs, xp);
 222                 }
 223                 return (hist_execute(line, ATEMP));
 224         }
 225
 226         if (editor && (lflag || nflag)) {
 227                 bi_errorf("can't use -l, -n with -e");
 228                 return (1);
 229         }
 230
 231         if (!first && (first = *wp))
 232                 wp++;
 233         if (!last && (last = *wp))
 234                 wp++;
 235         if (*wp) {
 236                 bi_errorf(Ttoo_many_args);
 237                 return (1);
 238         }
 239         if (!first) {
 240                 hfirst = lflag ? hist_get("-16", true, true) :
 241                     hist_get_newest(false);
 242                 if (!hfirst)
 243                         return (1);
 244                 /* can't fail if hfirst didn't fail */
 245                 hlast = hist_get_newest(false);
 246         } else {
 247                 /*
 248                  * POSIX says not an error if first/last out of bounds
 249                  * when range is specified; AT&T ksh and pdksh allow out
 250                  * of bounds for -l as well.
 251                  */
 252                 hfirst = hist_get(first, tobool(lflag || last), lflag);
 253                 if (!hfirst)
 254                         return (1);
 255                 hlast = last ? hist_get(last, true, lflag) :
 256                     (lflag ? hist_get_newest(false) : hfirst);
 257                 if (!hlast)
 258                         return (1);
 259         }
 260         if (hfirst > hlast) {
 261                 char **temp;
 262
 263                 temp = hfirst; hfirst = hlast; hlast = temp;
 264                 /* POSIX */
 265                 rflag = !rflag;
 266         }
 267
 268         /* List history */
 269         if (lflag) {
 270                 char *s, *t;
 271
 272                 for (hp = rflag ? hlast : hfirst;
 273                     hp >= hfirst && hp <= hlast; hp += rflag ? -1 : 1) {
 274                         if (!nflag)
 275                                 shf_fprintf(shl_stdout, Tf_lu,
 276                                     (unsigned long)hist_source->line -
 277                                     (unsigned long)(histptr - hp));
 278                         shf_putc('\t', shl_stdout);
 279                         /* print multi-line commands correctly */
 280                         s = *hp;
 281                         while ((t = strchr(s, '\n'))) {
 282                                 *t = '\0';
 283                                 shf_fprintf(shl_stdout, "%s\n\t", s);
 284                                 *t++ = '\n';
 285                                 s = t;
 286                         }
 287                         shf_fprintf(shl_stdout, Tf_sN, s);
 288                 }
 289                 shf_flush(shl_stdout);
 290                 return (0);
 291         }
 292
 293         /* Run editor on selected lines, then run resulting commands */
 294
 295         tf = maketemp(ATEMP, TT_HIST_EDIT, &e->temps);
 296         if (!(shf = tf->shf)) {
 297                 bi_errorf(Tf_temp, Tcreate, tf->tffn, cstrerror(errno));
 298                 return (1);
 299         }
 300         for (hp = rflag ? hlast : hfirst;
 301             hp >= hfirst && hp <= hlast; hp += rflag ? -1 : 1)
 302                 shf_fprintf(shf, Tf_sN, *hp);
 303         if (shf_close(shf) == -1) {
 304                 bi_errorf(Tf_temp, Twrite, tf->tffn, cstrerror(errno));
 305                 return (1);
 306         }
 307
 308         /* Ignore setstr errors here (arbitrary) */
 309         setstr(local("_", false), tf->tffn, KSH_RETURN_ERROR);
 310
 311         if ((optc = command(editor ? editor : TFCEDIT_dollaru, 0)))
 312                 return (optc);
 313
 314         {
 315                 struct stat statb;
 316                 XString xs;
 317                 char *xp;
 318                 ssize_t n;
 319
 320                 if (!(shf = shf_open(tf->tffn, O_RDONLY, 0, 0))) {
 321                         bi_errorf(Tf_temp, Topen, tf->tffn, cstrerror(errno));
 322                         return (1);
 323                 }
 324
 325                 if (stat(tf->tffn, &statb) < 0)
 326                         n = 128;
 327                 else if ((off_t)statb.st_size > MKSH_MAXHISTFSIZE) {
 328                         bi_errorf(Tf_toolarge, Thistory,
 329                             Tfile, (unsigned long)statb.st_size);
 330                         goto errout;
 331                 } else
 332                         n = (size_t)statb.st_size + 1;
 333                 Xinit(xs, xp, n, hist_source->areap);
 334                 while ((n = shf_read(xp, Xnleft(xs, xp), shf)) > 0) {
 335                         xp += n;
 336                         if (Xnleft(xs, xp) <= 0)
 337                                 XcheckN(xs, xp, Xlength(xs, xp));
 338                 }
 339                 if (n < 0) {
 340                         bi_errorf(Tf_temp, Tread, tf->tffn,
 341                             cstrerror(shf_errno(shf)));
 342  errout:
 343                         shf_close(shf);
 344                         return (1);
 345                 }
 346                 shf_close(shf);
 347                 *xp = '\0';
 348                 strip_nuls(Xstring(xs, xp), Xlength(xs, xp));
 349                 return (hist_execute(Xstring(xs, xp), hist_source->areap));
 350         }
 351 }
 352
 353 /* save cmd in history, execute cmd (cmd gets afree’d) */
 354 static int
 355 hist_execute(char *cmd, Area *areap)
 356 {
 357         static int last_line = -1;
 358
 359         /* Back up over last histsave */
 360         if (histptr >= history && last_line != hist_source->line) {
 361                 hist_source->line--;
 362                 afree(*histptr, APERM);
 363                 histptr--;
 364                 last_line = hist_source->line;
 365         }
 366
 367         histsave(&hist_source->line, cmd, HIST_STORE, true);
 368         /* now *histptr == cmd without all trailing newlines */
 369         afree(cmd, areap);
 370         cmd = *histptr;
 371         /* pdksh says POSIX doesn’t say this is done, testsuite needs it */
 372         shellf(Tf_sN, cmd);
 373
 374         /*-
 375          * Commands are executed here instead of pushing them onto the
 376          * input 'cause POSIX says the redirection and variable assignments
 377          * in
 378          *      X=y fc -e - 42 2> /dev/null
 379          * are to effect the repeated commands environment.
 380          */
 381         return (command(cmd, 0));
 382 }
 383
 384 /*
 385  * get pointer to history given pattern
 386  * pattern is a number or string
 387  */
 388 static char **
 389 hist_get(const char *str, bool approx, bool allow_cur)
 390 {
 391         char **hp = NULL;
 392         int n;
 393
 394         if (getn(str, &n)) {
 395                 hp = histptr + (n < 0 ? n : (n - hist_source->line));
 396                 if ((size_t)hp < (size_t)history) {
 397                         if (approx)
 398                                 hp = hist_get_oldest();
 399                         else {
 400                                 bi_errorf(Tf_sD_s, str, Tnot_in_history);
 401                                 hp = NULL;
 402                         }
 403                 } else if ((size_t)hp > (size_t)histptr) {
 404                         if (approx)
 405                                 hp = hist_get_newest(allow_cur);
 406                         else {
 407                                 bi_errorf(Tf_sD_s, str, Tnot_in_history);
 408                                 hp = NULL;
 409                         }
 410                 } else if (!allow_cur && hp == histptr) {
 411                         bi_errorf(Tf_sD_s, str, "invalid range");
 412                         hp = NULL;
 413                 }
 414         } else {
 415                 bool anchored = *str == '?' ? (++str, false) : true;
 416
 417                 /* the -1 is to avoid the current fc command */
 418                 if ((n = findhist(histptr - history - 1, 0, str, anchored)) < 0)
 419                         bi_errorf(Tf_sD_s, str, Tnot_in_history);
 420                 else
 421                         hp = &history[n];
 422         }
 423         return (hp);
 424 }
 425
 426 /* Return a pointer to the newest command in the history */
 427 char **
 428 hist_get_newest(bool allow_cur)
 429 {
 430         if (histptr < history || (!allow_cur && histptr == history)) {
 431                 bi_errorf("no history (yet)");
 432                 return (NULL);
 433         }
 434         return (allow_cur ? histptr : histptr - 1);
 435 }
 436
 437 /* Return a pointer to the oldest command in the history */
 438 static char **
 439 hist_get_oldest(void)
 440 {
 441         if (histptr <= history) {
 442                 bi_errorf("no history (yet)");
 443                 return (NULL);
 444         }
 445         return (history);
 446 }
 447
 448 #if !defined(MKSH_NO_CMDLINE_EDITING) && !MKSH_S_NOVI
 449 /* current position in history[] */
 450 static char **current;
 451
 452 /*
 453  * Return the current position.
 454  */
 455 char **
 456 histpos(void)
 457 {
 458         return (current);
 459 }
 460
 461 int
 462 histnum(int n)
 463 {
 464         int last = histptr - history;
 465
 466         if (n < 0 || n >= last) {
 467                 current = histptr;
 468                 return (last);
 469         } else {
 470                 current = &history[n];
 471                 return (n);
 472         }
 473 }
 474 #endif
 475
 476 /*
 477  * This will become unnecessary if hist_get is modified to allow
 478  * searching from positions other than the end, and in either
 479  * direction.
 480  */
 481 int
 482 findhist(int start, int fwd, const char *str, bool anchored)
 483 {
 484         char **hp;
 485         int maxhist = histptr - history;
 486         int incr = fwd ? 1 : -1;
 487         size_t len = strlen(str);
 488
 489         if (start < 0 || start >= maxhist)
 490                 start = maxhist;
 491
 492         hp = &history[start];
 493         for (; hp >= history && hp <= histptr; hp += incr)
 494                 if ((anchored && strncmp(*hp, str, len) == 0) ||
 495                     (!anchored && strstr(*hp, str)))
 496                         return (hp - history);
 497
 498         return (-1);
 499 }
 500
 501 /*
 502  * set history; this means reallocating the dataspace
 503  */
 504 void
 505 sethistsize(mksh_ari_t n)
 506 {
 507         if (n > 0 && n != histsize) {
 508                 int cursize = histptr - history;
 509
 510                 /* save most recent history */
 511                 if (n < cursize) {
 512                         memmove(history, histptr - n + 1, n * sizeof(char *));
 513                         cursize = n - 1;
 514                 }
 515
 516                 history = aresize2(history, n, sizeof(char *), APERM);
 517
 518                 histsize = n;
 519                 histptr = history + cursize;
 520         }
 521 }
 522
 523 #if HAVE_PERSISTENT_HISTORY
 524 /*
 525  * set history file; this can mean reloading/resetting/starting
 526  * history file maintenance
 527  */
 528 void
 529 sethistfile(const char *name)
 530 {
 531         /* if not started then nothing to do */
 532         if (hstarted == false)
 533                 return;
 534
 535         /* if the name is the same as the name we have */
 536         if (hname && name && !strcmp(hname, name))
 537                 return;
 538
 539         /*
 540          * it's a new name - possibly
 541          */
 542         if (histfd != -1) {
 543                 /* yes the file is open */
 544                 (void)close(histfd);
 545                 histfd = -1;
 546                 histfsize = 0;
 547                 afree(hname, APERM);
 548                 hname = NULL;
 549                 /* let's reset the history */
 550                 histsave(NULL, NULL, HIST_DISCARD, true);
 551                 histptr = history - 1;
 552                 hist_source->line = 0;
 553         }
 554
 555         if (name)
 556                 hist_init(hist_source);
 557 }
 558 #endif
 559
 560 /*
 561  * initialise the history vector
 562  */
 563 void
 564 init_histvec(void)
 565 {
 566         if (history == (char **)NULL) {
 567                 histsize = MKSH_DEFHISTSIZE;
 568                 history = alloc2(histsize, sizeof(char *), APERM);
 569                 histptr = history - 1;
 570         }
 571 }
 572
 573
 574 /*
 575  * It turns out that there is a lot of ghastly hackery here
 576  */
 577
 578 #if !defined(MKSH_SMALL) && HAVE_PERSISTENT_HISTORY
 579 /* do not save command in history but possibly sync */
 580 bool
 581 histsync(void)
 582 {
 583         bool changed = false;
 584
 585         /* called by histsave(), may not HIST_DISCARD, caller should flush */
 586
 587         if (histfd != -1) {
 588                 int lno = hist_source->line;
 589
 590                 hist_source->line++;
 591                 writehistfile(0, NULL);
 592                 hist_source->line--;
 593
 594                 if (lno != hist_source->line)
 595                         changed = true;
 596         }
 597
 598         return (changed);
 599 }
 600 #endif
 601
 602 /*
 603  * save command in history
 604  */
 605 void
 606 histsave(int *lnp, const char *cmd, int svmode, bool ignoredups)
 607 {
 608         static char *enqueued = NULL;
 609         char **hp, *c;
 610         const char *ccp;
 611
 612         if (svmode == HIST_DISCARD) {
 613                 afree(enqueued, APERM);
 614                 enqueued = NULL;
 615                 return;
 616         }
 617
 618         if (svmode == HIST_APPEND) {
 619                 if (!enqueued)
 620                         svmode = HIST_STORE;
 621         } else if (enqueued) {
 622                 c = enqueued;
 623                 enqueued = NULL;
 624                 --*lnp;
 625                 histsave(lnp, c, HIST_STORE, true);
 626                 afree(c, APERM);
 627         }
 628
 629         if (svmode == HIST_FLUSH)
 630                 return;
 631
 632         ccp = strnul(cmd);
 633         while (ccp > cmd && ccp[-1] == '\n')
 634                 --ccp;
 635         strndupx(c, cmd, ccp - cmd, APERM);
 636
 637         if (svmode != HIST_APPEND) {
 638                 if (ignoredups &&
 639                     histptr >= history &&
 640                     !strcmp(c, *histptr)
 641 #if !defined(MKSH_SMALL) && HAVE_PERSISTENT_HISTORY
 642                     && !histsync()
 643 #endif
 644                     ) {
 645                         afree(c, APERM);
 646                         return;
 647                 }
 648                 ++*lnp;
 649         }
 650
 651 #if HAVE_PERSISTENT_HISTORY
 652         if (svmode == HIST_STORE && histfd != -1)
 653                 writehistfile(*lnp, c);
 654 #endif
 655
 656         if (svmode == HIST_QUEUE || svmode == HIST_APPEND) {
 657                 size_t nenq, ncmd;
 658
 659                 if (!enqueued) {
 660                         if (*c)
 661                                 enqueued = c;
 662                         else
 663                                 afree(c, APERM);
 664                         return;
 665                 }
 666
 667                 nenq = strlen(enqueued);
 668                 ncmd = strlen(c);
 669                 enqueued = aresize(enqueued, nenq + 1 + ncmd + 1, APERM);
 670                 enqueued[nenq] = '\n';
 671                 memcpy(enqueued + nenq + 1, c, ncmd + 1);
 672                 afree(c, APERM);
 673                 return;
 674         }
 675
 676         hp = histptr;
 677
 678         if (++hp >= history + histsize) {
 679                 /* remove oldest command */
 680                 afree(*history, APERM);
 681                 for (hp = history; hp < history + histsize - 1; hp++)
 682                         hp[0] = hp[1];
 683         }
 684         *hp = c;
 685         histptr = hp;
 686 }
 687
 688 /*
 689  * Write history data to a file nominated by HISTFILE;
 690  * if HISTFILE is unset then history still happens, but
 691  * the data is not written to a file. All copies of ksh
 692  * looking at the file will maintain the same history.
 693  * This is ksh behaviour.
 694  *
 695  * This stuff uses mmap()
 696  *
 697  * This stuff is so totally broken it must eventually be
 698  * redesigned, without mmap, better checks, support for
 699  * larger files, etc. and handle partially corrupted files
 700  */
 701
 702 /*-
 703  * Open a history file
 704  * Format is:
 705  * Bytes 1, 2:
 706  *      HMAGIC - just to check that we are dealing with the correct object
 707  * Then follows a number of stored commands
 708  * Each command is
 709  *      <command byte><command number(4 octets, big endian)><bytes><NUL>
 710  */
 711 #define HMAGIC1         0xAB
 712 #define HMAGIC2         0xCD
 713 #define COMMAND         0xFF
 714
 715 #if HAVE_PERSISTENT_HISTORY
 716 static const unsigned char sprinkle[2] = { HMAGIC1, HMAGIC2 };
 717
 718 static int
 719 hist_persist_back(int srcfd)
 720 {
 721         off_t tot, mis;
 722         ssize_t n, w;
 723         char *buf, *cp;
 724         int rv = 0;
 725 #define MKSH_HS_BUFSIZ 4096
 726
 727         if ((tot = lseek(srcfd, (off_t)0, SEEK_END)) < 0 ||
 728             lseek(srcfd, (off_t)0, SEEK_SET) < 0 ||
 729             lseek(histfd, (off_t)0, SEEK_SET) < 0)
 730                 return (1);
 731
 732         if ((buf = malloc_osfunc(MKSH_HS_BUFSIZ)) == NULL)
 733                 return (1);
 734
 735         mis = tot;
 736         while (mis > 0) {
 737                 if ((n = blocking_read(srcfd, (cp = buf),
 738                     MKSH_HS_BUFSIZ)) == -1) {
 739                         if (errno == EINTR) {
 740                                 intrcheck();
 741                                 continue;
 742                         }
 743                         goto copy_error;
 744                 }
 745                 mis -= n;
 746                 while (n) {
 747                         if (intrsig)
 748                                 goto has_intrsig;
 749                         if ((w = write(histfd, cp, n)) != -1) {
 750                                 n -= w;
 751                                 cp += w;
 752                                 continue;
 753                         }
 754                         if (errno == EINTR) {
 755  has_intrsig:
 756                                 intrcheck();
 757                                 continue;
 758                         }
 759                         goto copy_error;
 760                 }
 761         }
 762         if (ftruncate(histfd, tot)) {
 763  copy_error:
 764                 rv = 1;
 765         }
 766         free_osfunc(buf);
 767         return (rv);
 768 }
 769
 770 static void
 771 hist_persist_init(void)
 772 {
 773         unsigned char *base;
 774         int lines, fd;
 775         enum { hist_init_first, hist_init_retry, hist_use_it } hs;
 776
 777         if (((hname = str_val(global("HISTFILE"))) == NULL) || !*hname) {
 778                 hname = NULL;
 779                 return;
 780         }
 781         strdupx(hname, hname, APERM);
 782         hs = hist_init_first;
 783
 784  retry:
 785         /* we have a file and are interactive */
 786         if ((fd = binopen3(hname, O_RDWR | O_CREAT | O_APPEND, 0600)) < 0)
 787                 return;
 788         if ((histfd = savefd(fd)) < 0)
 789                 return;
 790         if (histfd != fd)
 791                 close(fd);
 792
 793         mksh_lockfd(histfd);
 794
 795         histfsize = lseek(histfd, (off_t)0, SEEK_END);
 796         if (histfsize > MKSH_MAXHISTFSIZE) {
 797                 /* we ignore too large files but still append to them */
 798                 goto hist_init_tail;
 799         } else if (histfsize > 2) {
 800                 /* we have some data, check its validity */
 801                 base = (void *)mmap(NULL, (size_t)histfsize, PROT_READ,
 802                     MAP_FILE | MAP_PRIVATE, histfd, (off_t)0);
 803                 if (base == (unsigned char *)MAP_FAILED)
 804                         goto hist_init_fail;
 805                 if (base[0] != HMAGIC1 || base[1] != HMAGIC2) {
 806                         munmap(caddr_cast(base), (size_t)histfsize);
 807                         goto hist_init_fail;
 808                 }
 809                 /* load _all_ data */
 810                 lines = histload(hist_source, base + 2, (size_t)histfsize - 2);
 811                 munmap(caddr_cast(base), (size_t)histfsize);
 812                 /* check if the file needs to be truncated */
 813                 if (lines > histsize && histptr >= history) {
 814                         /* you're fucked up with the current code, trust me */
 815                         char *nhname, **hp;
 816                         struct stat sb;
 817
 818                         /* create temporary file */
 819                         nhname = shf_smprintf("%s.%d", hname, (int)procpid);
 820                         if ((fd = binopen3(nhname, O_RDWR | O_CREAT | O_TRUNC |
 821                             O_EXCL, 0600)) < 0) {
 822                                 /* just don't truncate then, meh. */
 823                                 hs = hist_use_it;
 824                                 goto hist_trunc_dont;
 825                         }
 826                         if (fstat(histfd, &sb) >= 0 &&
 827                             chown(nhname, sb.st_uid, sb.st_gid)) {
 828                                 /* abort the truncation then, meh. */
 829                                 goto hist_trunc_abort;
 830                         }
 831                         /* we definitively want some magic in that file */
 832                         if (write(fd, sprinkle, 2) != 2)
 833                                 goto hist_trunc_abort;
 834                         /* and of course the entries */
 835                         hp = history;
 836                         while (hp < histptr) {
 837                                 if (!writehistline(fd,
 838                                     hist_source->line - (histptr - hp), *hp))
 839                                         goto hist_trunc_abort;
 840                                 ++hp;
 841                         }
 842                         /* now transfer back */
 843                         if (!hist_persist_back(fd)) {
 844                                 /* success! */
 845                                 hs = hist_use_it;
 846                         }
 847  hist_trunc_abort:
 848                         /* remove temporary file */
 849                         close(fd);
 850                         fd = -1;
 851                         unlink(nhname);
 852                         /* use whatever is in the file now */
 853  hist_trunc_dont:
 854                         afree(nhname, ATEMP);
 855                         if (hs == hist_use_it)
 856                                 goto hist_trunc_done;
 857                         goto hist_init_fail;
 858                 }
 859         } else if (histfsize != 0) {
 860                 /* negative or too small... */
 861  hist_init_fail:
 862                 /* ... or mmap failed or illegal */
 863                 hist_finish();
 864                 /* nuke the bogus file then retry, at most once */
 865                 if (!unlink(hname) && hs != hist_init_retry) {
 866                         hs = hist_init_retry;
 867                         goto retry;
 868                 }
 869                 if (hs != hist_init_retry)
 870                         bi_errorf(Tf_cant_ss_s,
 871                             "unlink HISTFILE", hname, cstrerror(errno));
 872                 histfsize = 0;
 873                 return;
 874         } else {
 875                 /* size 0, add magic to the history file */
 876                 if (write(histfd, sprinkle, 2) != 2) {
 877                         hist_finish();
 878                         return;
 879                 }
 880         }
 881  hist_trunc_done:
 882         histfsize = lseek(histfd, (off_t)0, SEEK_END);
 883  hist_init_tail:
 884         mksh_unlkfd(histfd);
 885 }
 886 #endif
 887
 888 void
 889 hist_init(Source *s)
 890 {
 891         histsave(NULL, NULL, HIST_DISCARD, true);
 892
 893         if (Flag(FTALKING) == 0)
 894                 return;
 895
 896         hstarted = true;
 897         hist_source = s;
 898
 899 #if HAVE_PERSISTENT_HISTORY
 900         hist_persist_init();
 901 #endif
 902 }
 903
 904 #if HAVE_PERSISTENT_HISTORY
 905 /*
 906  * load the history structure from the stored data
 907  */
 908 static int
 909 histload(Source *s, unsigned char *base, size_t bytes)
 910 {
 911         int lno = 0, lines = 0;
 912         unsigned char *cp;
 913
 914  histload_loop:
 915         /* !bytes check as some systems (older FreeBSDs) have buggy memchr */
 916         if (!bytes || (cp = memchr(base, COMMAND, bytes)) == NULL)
 917                 return (lines);
 918         /* advance base pointer past COMMAND byte */
 919         bytes -= ++cp - base;
 920         base = cp;
 921         /* if there is no full string left, don't bother with the rest */
 922         if (bytes < 5 || (cp = memchr(base + 4, '\0', bytes - 4)) == NULL)
 923                 return (lines);
 924         /* load the stored line number */
 925         lno = ((base[0] & 0xFF) << 24) | ((base[1] & 0xFF) << 16) |
 926             ((base[2] & 0xFF) << 8) | (base[3] & 0xFF);
 927         /* store away the found line (@base[4]) */
 928         ++lines;
 929         if (histptr >= history && lno - 1 != s->line) {
 930                 /* a replacement? */
 931                 char **hp;
 932
 933                 if (lno >= s->line - (histptr - history) && lno <= s->line) {
 934                         hp = &histptr[lno - s->line];
 935                         afree(*hp, APERM);
 936                         strdupx(*hp, (char *)(base + 4), APERM);
 937                 }
 938         } else {
 939                 s->line = lno--;
 940                 histsave(&lno, (char *)(base + 4), HIST_NOTE, false);
 941         }
 942         /* advance base pointer past NUL */
 943         bytes -= ++cp - base;
 944         base = cp;
 945         /* repeat until no more */
 946         goto histload_loop;
 947 }
 948
 949 /*
 950  * write a command to the end of the history file
 951  *
 952  * This *MAY* seem easy but it's also necessary to check
 953  * that the history file has not changed in size.
 954  * If it has - then some other shell has written to it and
 955  * we should (re)read those commands to update our history
 956  */
 957 static void
 958 writehistfile(int lno, const char *cmd)
 959 {
 960         off_t sizenow;
 961         size_t bytes;
 962         unsigned char *base, *news;
 963
 964         mksh_lockfd(histfd);
 965         sizenow = lseek(histfd, (off_t)0, SEEK_END);
 966         if (sizenow < histfsize) {
 967                 /* the file has shrunk; trust it just appending the new data */
 968                 /* well, for now, anyway… since mksh strdups all into memory */
 969                 /* we can use a nicer approach some time later… */
 970                 ;
 971         } else if (
 972                 /* ignore changes when the file is too large */
 973                 sizenow <= MKSH_MAXHISTFSIZE
 974             &&
 975                 /* the size has changed, we need to do read updates */
 976                 sizenow > histfsize
 977             ) {
 978                 /* both sizenow and histfsize are <= MKSH_MAXHISTFSIZE */
 979                 bytes = (size_t)(sizenow - histfsize);
 980                 base = (void *)mmap(NULL, (size_t)sizenow, PROT_READ,
 981                     MAP_FILE | MAP_PRIVATE, histfd, (off_t)0);
 982                 if (base == (unsigned char *)MAP_FAILED)
 983                         goto bad;
 984                 news = base + (size_t)histfsize;
 985                 if (*news == COMMAND) {
 986                         hist_source->line--;
 987                         histload(hist_source, news, bytes);
 988                         hist_source->line++;
 989                         lno = hist_source->line;
 990                 } else
 991                         bytes = 0;
 992                 munmap(caddr_cast(base), (size_t)sizenow);
 993                 if (!bytes)
 994                         goto bad;
 995         }
 996         if (cmd && !writehistline(histfd, lno, cmd)) {
 997  bad:
 998                 hist_finish();
 999                 return;
1000         }
1001         histfsize = lseek(histfd, (off_t)0, SEEK_END);
1002         mksh_unlkfd(histfd);
1003 }
1004
1005 static int
1006 writehistline(int fd, int lno, const char *cmd)
1007 {
1008         ssize_t n;
1009         unsigned char hdr[5];
1010
1011         hdr[0] = COMMAND;
1012         hdr[1] = (lno >> 24) & 0xFF;
1013         hdr[2] = (lno >> 16) & 0xFF;
1014         hdr[3] = (lno >> 8) & 0xFF;
1015         hdr[4] = lno & 0xFF;
1016         n = strlen(cmd) + 1;
1017         return (write(fd, hdr, 5) == 5 && write(fd, cmd, n) == n);
1018 }
1019
1020 void
1021 hist_finish(void)
1022 {
1023         if (histfd >= 0) {
1024                 mksh_unlkfd(histfd);
1025                 (void)close(histfd);
1026         }
1027         histfd = -1;
1028 }
1029 #endif
1030
1031
1032 #if !HAVE_SYS_SIGNAME
1033 static const struct mksh_sigpair {
1034         const char * const name;
1035         int nr;
1036 } mksh_sigpairs[] = {
1037 #include "signames.inc"
1038         { NULL, 0 }
1039 };
1040 #endif
1041
1042 #if HAVE_SYS_SIGLIST
1043 #if !HAVE_SYS_SIGLIST_DECL
1044 extern const char * const sys_siglist[];
1045 #endif
1046 #endif
1047
1048 void
1049 inittraps(void)
1050 {
1051         int i;
1052         const char *cs;
1053 #if !HAVE_SYS_SIGNAME
1054         const struct mksh_sigpair *pair;
1055 #endif
1056
1057         trap_exstat = -1;
1058
1059         /* populate sigtraps based on sys_signame and sys_siglist */
1060         for (i = 1; i < ksh_NSIG; i++) {
1061                 sigtraps[i].signal = i;
1062 #if HAVE_SYS_SIGNAME
1063                 cs = sys_signame[i];
1064 #else
1065                 pair = mksh_sigpairs;
1066                 while ((pair->nr != i) && (pair->name != NULL))
1067                         ++pair;
1068                 cs = pair->name;
1069 #endif
1070                 if ((cs == NULL) ||
1071                     (cs[0] == '\0'))
1072                         sigtraps[i].name = null;
1073                 else {
1074                         char *s;
1075
1076                         /* this is not optimal, what about SIGSIG1? */
1077                         if (ksh_eq(cs[0], 'S', 's') &&
1078                             ksh_eq(cs[1], 'I', 'i') &&
1079                             ksh_eq(cs[2], 'G', 'g') &&
1080                             cs[3] != '\0') {
1081                                 /* skip leading "SIG" */
1082                                 cs += 3;
1083                         }
1084                         strdupx(s, cs, APERM);
1085                         sigtraps[i].name = s;
1086                         while ((*s = ksh_toupper(*s)))
1087                                 ++s;
1088                         /* check for reserved names */
1089                         if (!strcmp(sigtraps[i].name, "EXIT") ||
1090                             !strcmp(sigtraps[i].name, "ERR")) {
1091 #ifndef MKSH_SMALL
1092                                 internal_warningf(Tinvname, sigtraps[i].name,
1093                                     "signal");
1094 #endif
1095                                 sigtraps[i].name = null;
1096                         }
1097                 }
1098                 if (sigtraps[i].name == null)
1099                         sigtraps[i].name = shf_smprintf(Tf_d, i);
1100 #if HAVE_SYS_SIGLIST
1101                 sigtraps[i].mess = sys_siglist[i];
1102 #elif HAVE_STRSIGNAL
1103                 sigtraps[i].mess = strsignal(i);
1104 #else
1105                 sigtraps[i].mess = NULL;
1106 #endif
1107                 if ((sigtraps[i].mess == NULL) ||
1108                     (sigtraps[i].mess[0] == '\0'))
1109                         sigtraps[i].mess = shf_smprintf(Tf_sd,
1110                             "Signal", i);
1111         }
1112         sigtraps[ksh_SIGEXIT].signal = ksh_SIGEXIT;
1113         sigtraps[ksh_SIGEXIT].name = "EXIT";
1114         sigtraps[ksh_SIGEXIT].mess = "Exit trap";
1115         sigtraps[ksh_SIGERR].signal = ksh_SIGERR;
1116         sigtraps[ksh_SIGERR].name = "ERR";
1117         sigtraps[ksh_SIGERR].mess = "Error handler";
1118
1119         (void)sigemptyset(&Sigact_ign.sa_mask);
1120         Sigact_ign.sa_flags = 0; /* interruptible */
1121         Sigact_ign.sa_handler = SIG_IGN;
1122
1123         sigtraps[SIGINT].flags |= TF_DFL_INTR | TF_TTY_INTR;
1124         sigtraps[SIGQUIT].flags |= TF_DFL_INTR | TF_TTY_INTR;
1125         /* SIGTERM is not fatal for interactive */
1126         sigtraps[SIGTERM].flags |= TF_DFL_INTR;
1127         sigtraps[SIGHUP].flags |= TF_FATAL;
1128         sigtraps[SIGCHLD].flags |= TF_SHELL_USES;
1129
1130         /* these are always caught so we can clean up any temporary files. */
1131         setsig(&sigtraps[SIGINT], trapsig, SS_RESTORE_ORIG);
1132         setsig(&sigtraps[SIGQUIT], trapsig, SS_RESTORE_ORIG);
1133         setsig(&sigtraps[SIGTERM], trapsig, SS_RESTORE_ORIG);
1134         setsig(&sigtraps[SIGHUP], trapsig, SS_RESTORE_ORIG);
1135 }
1136
1137 static void alarm_catcher(int sig);
1138
1139 void
1140 alarm_init(void)
1141 {
1142         sigtraps[SIGALRM].flags |= TF_SHELL_USES;
1143         setsig(&sigtraps[SIGALRM], alarm_catcher,
1144                 SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP);
1145 }
1146
1147 /* ARGSUSED */
1148 static void
1149 alarm_catcher(int sig MKSH_A_UNUSED)
1150 {
1151         /* this runs inside interrupt context, with errno saved */
1152
1153         if (ksh_tmout_state == TMOUT_READING) {
1154                 int left = alarm(0);
1155
1156                 if (left == 0) {
1157                         ksh_tmout_state = TMOUT_LEAVING;
1158                         intrsig = 1;
1159                 } else
1160                         alarm(left);
1161         }
1162 }
1163
1164 Trap *
1165 gettrap(const char *cs, bool igncase, bool allsigs)
1166 {
1167         int i;
1168         Trap *p;
1169         char *as;
1170
1171         /* signal number (1..ksh_NSIG) or 0? */
1172
1173         if (ctype(*cs, C_DIGIT))
1174                 return ((getn(cs, &i) && 0 <= i && i < ksh_NSIG) ?
1175                     (&sigtraps[i]) : NULL);
1176
1177         /* do a lookup by name then */
1178
1179         /* this breaks SIGSIG1, but we do that above anyway */
1180         if (ksh_eq(cs[0], 'S', 's') &&
1181             ksh_eq(cs[1], 'I', 'i') &&
1182             ksh_eq(cs[2], 'G', 'g') &&
1183             cs[3] != '\0') {
1184                 /* skip leading "SIG" */
1185                 cs += 3;
1186         }
1187         if (igncase) {
1188                 char *s;
1189
1190                 strdupx(as, cs, ATEMP);
1191                 cs = s = as;
1192                 while ((*s = ksh_toupper(*s)))
1193                         ++s;
1194         } else
1195                 as = NULL;
1196
1197         /* this is idiotic, we really want a hashtable here */
1198
1199         p = sigtraps;
1200         i = ksh_NSIG + 1;
1201         do {
1202                 if (!strcmp(p->name, cs))
1203                         goto found;
1204                 ++p;
1205         } while (--i);
1206         goto notfound;
1207
1208  found:
1209         if (!allsigs) {
1210                 if (p->signal == ksh_SIGEXIT || p->signal == ksh_SIGERR) {
1211  notfound:
1212                         p = NULL;
1213                 }
1214         }
1215         afree(as, ATEMP);
1216         return (p);
1217 }
1218
1219 /*
1220  * trap signal handler
1221  */
1222 void
1223 trapsig(int i)
1224 {
1225         Trap *p = &sigtraps[i];
1226         int eno = errno;
1227
1228         trap = p->set = 1;
1229         if (p->flags & TF_DFL_INTR)
1230                 intrsig = 1;
1231         if ((p->flags & TF_FATAL) && !p->trap) {
1232                 fatal_trap = 1;
1233                 intrsig = 1;
1234         }
1235         if (p->shtrap)
1236                 (*p->shtrap)(i);
1237         errno = eno;
1238 }
1239
1240 /*
1241  * called when we want to allow the user to ^C out of something - won't
1242  * work if user has trapped SIGINT.
1243  */
1244 void
1245 intrcheck(void)
1246 {
1247         if (intrsig)
1248                 runtraps(TF_DFL_INTR|TF_FATAL);
1249 }
1250
1251 /*
1252  * called after EINTR to check if a signal with normally causes process
1253  * termination has been received.
1254  */
1255 int
1256 fatal_trap_check(void)
1257 {
1258         Trap *p = sigtraps;
1259         int i = ksh_NSIG + 1;
1260
1261         /* todo: should check if signal is fatal, not the TF_DFL_INTR flag */
1262         do {
1263                 if (p->set && (p->flags & (TF_DFL_INTR|TF_FATAL)))
1264                         /* return value is used as an exit code */
1265                         return (ksh_sigmask(p->signal));
1266                 ++p;
1267         } while (--i);
1268         return (0);
1269 }
1270
1271 /*
1272  * Returns the signal number of any pending traps: ie, a signal which has
1273  * occurred for which a trap has been set or for which the TF_DFL_INTR flag
1274  * is set.
1275  */
1276 int
1277 trap_pending(void)
1278 {
1279         Trap *p = sigtraps;
1280         int i = ksh_NSIG + 1;
1281
1282         do {
1283                 if (p->set && ((p->trap && p->trap[0]) ||
1284                     ((p->flags & (TF_DFL_INTR|TF_FATAL)) && !p->trap)))
1285                         return (p->signal);
1286                 ++p;
1287         } while (--i);
1288         return (0);
1289 }
1290
1291 /*
1292  * run any pending traps. If intr is set, only run traps that
1293  * can interrupt commands.
1294  */
1295 void
1296 runtraps(int flag)
1297 {
1298         Trap *p = sigtraps;
1299         int i = ksh_NSIG + 1;
1300
1301         if (ksh_tmout_state == TMOUT_LEAVING) {
1302                 ksh_tmout_state = TMOUT_EXECUTING;
1303                 warningf(false, "timed out waiting for input");
1304                 unwind(LEXIT);
1305         } else
1306                 /*
1307                  * XXX: this means the alarm will have no effect if a trap
1308                  * is caught after the alarm() was started...not good.
1309                  */
1310                 ksh_tmout_state = TMOUT_EXECUTING;
1311         if (!flag)
1312                 trap = 0;
1313         if (flag & TF_DFL_INTR)
1314                 intrsig = 0;
1315         if (flag & TF_FATAL)
1316                 fatal_trap = 0;
1317         ++trap_nested;
1318         do {
1319                 if (p->set && (!flag ||
1320                     ((p->flags & flag) && p->trap == NULL)))
1321                         runtrap(p, false);
1322                 ++p;
1323         } while (--i);
1324         if (!--trap_nested)
1325                 runtrap(NULL, true);
1326 }
1327
1328 void
1329 runtrap(Trap *p, bool is_last)
1330 {
1331         int old_changed = 0, i;
1332         char *trapstr;
1333
1334         if (p == NULL)
1335                 /* just clean up, see runtraps() above */
1336                 goto donetrap;
1337         i = p->signal;
1338         trapstr = p->trap;
1339         p->set = 0;
1340         if (trapstr == NULL) {
1341                 /* SIG_DFL */
1342                 if (p->flags & (TF_FATAL | TF_DFL_INTR)) {
1343                         exstat = (int)(128U + (unsigned)i);
1344                         if ((unsigned)exstat > 255U)
1345                                 exstat = 255;
1346                 }
1347                 /* e.g. SIGHUP */
1348                 if (p->flags & TF_FATAL)
1349                         unwind(LLEAVE);
1350                 /* e.g. SIGINT, SIGQUIT, SIGTERM, etc. */
1351                 if (p->flags & TF_DFL_INTR)
1352                         unwind(LINTR);
1353                 goto donetrap;
1354         }
1355         if (trapstr[0] == '\0')
1356                 /* SIG_IGN */
1357                 goto donetrap;
1358         if (i == ksh_SIGEXIT || i == ksh_SIGERR) {
1359                 /* avoid recursion on these */
1360                 old_changed = p->flags & TF_CHANGED;
1361                 p->flags &= ~TF_CHANGED;
1362                 p->trap = NULL;
1363         }
1364         if (trap_exstat == -1)
1365                 trap_exstat = exstat & 0xFF;
1366         /*
1367          * Note: trapstr is fully parsed before anything is executed, thus
1368          * no problem with afree(p->trap) in settrap() while still in use.
1369          */
1370         command(trapstr, current_lineno);
1371         if (i == ksh_SIGEXIT || i == ksh_SIGERR) {
1372                 if (p->flags & TF_CHANGED)
1373                         /* don't clear TF_CHANGED */
1374                         afree(trapstr, APERM);
1375                 else
1376                         p->trap = trapstr;
1377                 p->flags |= old_changed;
1378         }
1379
1380  donetrap:
1381         /* we're the last trap of a sequence executed */
1382         if (is_last && trap_exstat != -1) {
1383                 exstat = trap_exstat;
1384                 trap_exstat = -1;
1385         }
1386 }
1387
1388 /* clear pending traps and reset user's trap handlers; used after fork(2) */
1389 void
1390 cleartraps(void)
1391 {
1392         Trap *p = sigtraps;
1393         int i = ksh_NSIG + 1;
1394
1395         trap = 0;
1396         intrsig = 0;
1397         fatal_trap = 0;
1398
1399         do {
1400                 p->set = 0;
1401                 if ((p->flags & TF_USER_SET) && (p->trap && p->trap[0]))
1402                         settrap(p, NULL);
1403                 ++p;
1404         } while (--i);
1405 }
1406
1407 /* restore signals just before an exec(2) */
1408 void
1409 restoresigs(void)
1410 {
1411         Trap *p = sigtraps;
1412         int i = ksh_NSIG + 1;
1413
1414         do {
1415                 if (p->flags & (TF_EXEC_IGN|TF_EXEC_DFL))
1416                         setsig(p, (p->flags & TF_EXEC_IGN) ? SIG_IGN : SIG_DFL,
1417                             SS_RESTORE_CURR|SS_FORCE);
1418                 ++p;
1419         } while (--i);
1420 }
1421
1422 void
1423 settrap(Trap *p, const char *s)
1424 {
1425         sig_t f;
1426
1427         afree(p->trap, APERM);
1428         /* handles s == NULL */
1429         strdupx(p->trap, s, APERM);
1430         p->flags |= TF_CHANGED;
1431         f = !s ? SIG_DFL : s[0] ? trapsig : SIG_IGN;
1432
1433         p->flags |= TF_USER_SET;
1434         if ((p->flags & (TF_DFL_INTR|TF_FATAL)) && f == SIG_DFL)
1435                 f = trapsig;
1436         else if (p->flags & TF_SHELL_USES) {
1437                 if (!(p->flags & TF_ORIG_IGN) || Flag(FTALKING)) {
1438                         /* do what user wants at exec time */
1439                         p->flags &= ~(TF_EXEC_IGN|TF_EXEC_DFL);
1440                         if (f == SIG_IGN)
1441                                 p->flags |= TF_EXEC_IGN;
1442                         else
1443                                 p->flags |= TF_EXEC_DFL;
1444                 }
1445
1446                 /*
1447                  * assumes handler already set to what shell wants it
1448                  * (normally trapsig, but could be j_sigchld() or SIG_IGN)
1449                  */
1450                 return;
1451         }
1452
1453         /* todo: should we let user know signal is ignored? how? */
1454         setsig(p, f, SS_RESTORE_CURR|SS_USER);
1455 }
1456
1457 /*
1458  * called by c_print() when writing to a co-process to ensure
1459  * SIGPIPE won't kill shell (unless user catches it and exits)
1460  */
1461 bool
1462 block_pipe(void)
1463 {
1464         bool restore_dfl = false;
1465         Trap *p = &sigtraps[SIGPIPE];
1466
1467         if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL))) {
1468                 setsig(p, SIG_IGN, SS_RESTORE_CURR);
1469                 if (p->flags & TF_ORIG_DFL)
1470                         restore_dfl = true;
1471         } else if (p->cursig == SIG_DFL) {
1472                 setsig(p, SIG_IGN, SS_RESTORE_CURR);
1473                 /* restore to SIG_DFL */
1474                 restore_dfl = true;
1475         }
1476         return (restore_dfl);
1477 }
1478
1479 /* called by c_print() to undo whatever block_pipe() did */
1480 void
1481 restore_pipe(void)
1482 {
1483         setsig(&sigtraps[SIGPIPE], SIG_DFL, SS_RESTORE_CURR);
1484 }
1485
1486 /*
1487  * Set action for a signal. Action may not be set if original
1488  * action was SIG_IGN, depending on the value of flags and FTALKING.
1489  */
1490 int
1491 setsig(Trap *p, sig_t f, int flags)
1492 {
1493         struct sigaction sigact;
1494
1495         if (p->signal == ksh_SIGEXIT || p->signal == ksh_SIGERR)
1496                 return (1);
1497
1498         memset(&sigact, 0, sizeof(sigact));
1499
1500         /*
1501          * First time setting this signal? If so, get and note the current
1502          * setting.
1503          */
1504         if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL))) {
1505                 sigaction(p->signal, &Sigact_ign, &sigact);
1506                 p->flags |= sigact.sa_handler == SIG_IGN ?
1507                     TF_ORIG_IGN : TF_ORIG_DFL;
1508                 p->cursig = SIG_IGN;
1509         }
1510
1511         /*-
1512          * Generally, an ignored signal stays ignored, except if
1513          *      - the user of an interactive shell wants to change it
1514          *      - the shell wants for force a change
1515          */
1516         if ((p->flags & TF_ORIG_IGN) && !(flags & SS_FORCE) &&
1517             (!(flags & SS_USER) || !Flag(FTALKING)))
1518                 return (0);
1519
1520         setexecsig(p, flags & SS_RESTORE_MASK);
1521
1522         /*
1523          * This is here 'cause there should be a way of clearing
1524          * shtraps, but don't know if this is a sane way of doing
1525          * it. At the moment, all users of shtrap are lifetime
1526          * users (SIGALRM, SIGCHLD, SIGWINCH).
1527          */
1528         if (!(flags & SS_USER))
1529                 p->shtrap = (sig_t)NULL;
1530         if (flags & SS_SHTRAP) {
1531                 p->shtrap = f;
1532                 f = trapsig;
1533         }
1534
1535         if (p->cursig != f) {
1536                 p->cursig = f;
1537                 (void)sigemptyset(&sigact.sa_mask);
1538                 /* interruptible */
1539                 sigact.sa_flags = 0;
1540                 sigact.sa_handler = f;
1541                 sigaction(p->signal, &sigact, NULL);
1542         }
1543
1544         return (1);
1545 }
1546
1547 /* control what signal is set to before an exec() */
1548 void
1549 setexecsig(Trap *p, int restore)
1550 {
1551         /* XXX debugging */
1552         if (!(p->flags & (TF_ORIG_IGN|TF_ORIG_DFL)))
1553                 internal_errorf("setexecsig: unset signal %d(%s)",
1554                     p->signal, p->name);
1555
1556         /* restore original value for exec'd kids */
1557         p->flags &= ~(TF_EXEC_IGN|TF_EXEC_DFL);
1558         switch (restore & SS_RESTORE_MASK) {
1559         case SS_RESTORE_CURR:
1560                 /* leave things as they currently are */
1561                 break;
1562         case SS_RESTORE_ORIG:
1563                 p->flags |= p->flags & TF_ORIG_IGN ? TF_EXEC_IGN : TF_EXEC_DFL;
1564                 break;
1565         case SS_RESTORE_DFL:
1566                 p->flags |= TF_EXEC_DFL;
1567                 break;
1568         case SS_RESTORE_IGN:
1569                 p->flags |= TF_EXEC_IGN;
1570                 break;
1571         }
1572 }
1573
1574 #if HAVE_PERSISTENT_HISTORY || defined(DF)
1575 /*
1576  * File descriptor locking and unlocking functions.
1577  * Could use some error handling, but hey, this is only
1578  * advisory locking anyway, will often not work over NFS,
1579  * and you are SOL if this fails...
1580  */
1581
1582 void
1583 mksh_lockfd(int fd)
1584 {
1585 #if defined(__OpenBSD__)
1586         /* flock is not interrupted by signals */
1587         (void)flock(fd, LOCK_EX);
1588 #elif HAVE_FLOCK
1589         int rv;
1590
1591         /* e.g. on Linux */
1592         do {
1593                 rv = flock(fd, LOCK_EX);
1594         } while (rv == 1 && errno == EINTR);
1595 #elif HAVE_LOCK_FCNTL
1596         int rv;
1597         struct flock lks;
1598
1599         memset(&lks, 0, sizeof(lks));
1600         lks.l_type = F_WRLCK;
1601         do {
1602                 rv = fcntl(fd, F_SETLKW, &lks);
1603         } while (rv == 1 && errno == EINTR);
1604 #endif
1605 }
1606
1607 /* designed to not define mksh_unlkfd if none triggered */
1608 #if HAVE_FLOCK
1609 void
1610 mksh_unlkfd(int fd)
1611 {
1612         (void)flock(fd, LOCK_UN);
1613 }
1614 #elif HAVE_LOCK_FCNTL
1615 void
1616 mksh_unlkfd(int fd)
1617 {
1618         struct flock lks;
1619
1620         memset(&lks, 0, sizeof(lks));
1621         lks.l_type = F_UNLCK;
1622         (void)fcntl(fd, F_SETLKW, &lks);
1623 }
1624 #endif
1625 #endif