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