/usr/src/usr.bin/mg/dired.c

Bug Summary

File:	src/usr.bin/mg/dired.c
Warning:	line 1059, column 10 Access to field 'fn' results in a dereference of a null pointer (loaded from variable 'd1')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name dired.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/mg/obj -resource-dir /usr/local/llvm16/lib/clang/16 -D REGEX -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/mg/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/usr.bin/mg/dired.c
1/*	$OpenBSD: dired.c,v 1.102 2023/03/08 04:43:11 guenther Exp $	*/

3/* This file is in the public domain. */

5/* dired module for mg 2a
* by Robert A. Larson
*/

9#include <sys/queue.h>
10#include <sys/resource.h>
11#include <sys/stat.h>
12#include <sys/time.h>
13#include <sys/types.h>
14#include <sys/wait.h>
15#include <ctype.h>
16#include <err.h>
17#include <errno(*__errno()).h>
18#include <fcntl.h>
19#include <limits.h>
20#include <signal.h>
21#include <stdarg.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <unistd.h>

27#include "def.h"
28#include "funmap.h"
29#include "kbd.h"

31void		 dired_init(void);
32static int	 dired(int, int);
33static int	 d_otherwindow(int, int);
34static int	 d_undel(int, int);
35static int	 d_undelbak(int, int);
36static int	 d_findfile(int, int);
37static int	 d_ffotherwindow(int, int);
38static int	 d_expunge(int, int);
39static int	 d_copy(int, int);
40static int	 d_del(int, int);
41static int	 d_rename(int, int);
42static int	 d_exec(int, struct buffer *, const char *, const char *, ...);
43static int	 d_shell_command(int, int);
44static int	 d_create_directory(int, int);
45static int	 d_makename(struct line *, char *, size_t);
46static int	 d_warpdot(struct line *, int *);
47static int	 d_forwpage(int, int);
48static int	 d_backpage(int, int);
49static int	 d_forwline(int, int);
50static int	 d_backline(int, int);
51static int	 d_killbuffer_cmd(int, int);
52static int	 d_refreshbuffer(int, int);
53static int	 d_filevisitalt(int, int);
54static int	 d_gotofile(int, int);
55static void	 reaper(int);
56static int	 gotofile(char*);
57static struct buffer	*refreshbuffer(struct buffer *);
58static int	 createlist(struct buffer *);
59static void	 redelete(struct buffer *);
60static char 	 *findfname(struct line *, char *);

62extern struct keymap_s helpmap, cXmap, metamap;

64const char DDELCHAR = 'D';

66/*
* Structure which holds a linked list of file names marked for
* deletion. Used to maintain dired buffer 'state' between refreshes.
*/
70struct delentry {
SLIST_ENTRY(delentry)struct { struct delentry *sle_next; } entry;
char   *fn;
73};
74SLIST_HEAD(slisthead, delentry)struct slisthead { struct delentry *slh_first; } delhead = SLIST_HEAD_INITIALIZER(delhead){ ((void *)0) };

76static PF dirednul[] = {
setmark,		/* ^@ */
gotobol,		/* ^A */
backchar,		/* ^B */
rescan,			/* ^C */
d_del,			/* ^D */
gotoeol,		/* ^E */
forwchar,		/* ^F */
ctrlg,			/* ^G */
NULL((void *)0),			/* ^H */
86};

88static PF diredcl[] = {
reposition,		/* ^L */
d_findfile,		/* ^M */
d_forwline,		/* ^N */
rescan,			/* ^O */
d_backline,		/* ^P */
rescan,			/* ^Q */
backisearch,		/* ^R */
forwisearch,		/* ^S */
rescan,			/* ^T */
universal_argument,	/* ^U */
d_forwpage,		/* ^V */
rescan,			/* ^W */
NULL((void *)0)			/* ^X */
102};

104static PF diredcz[] = {
spawncli,		/* ^Z */
NULL((void *)0),			/* esc */
rescan,			/* ^\ */
rescan,			/* ^] */
rescan,			/* ^^ */
rescan,			/* ^_ */
d_forwline,		/* SP */
d_shell_command,	/* ! */
rescan,			/* " */
rescan,			/* # */
rescan,			/* $ */
rescan,			/* % */
rescan,			/* & */
rescan,			/* ' */
rescan,			/* ( */
rescan,			/* ) */
rescan,			/* * */
d_create_directory	/* + */
123};

125static PF direda[] = {
d_filevisitalt,		/* a */
rescan,			/* b */
d_copy,			/* c */
d_del,			/* d */
d_findfile,		/* e */
d_findfile,		/* f */
d_refreshbuffer,	/* g */
rescan,			/* h */
rescan,			/* i */
d_gotofile		/* j */
136};

138static PF diredn[] = {
d_forwline,		/* n */
d_ffotherwindow,	/* o */
d_backline,		/* p */
d_killbuffer_cmd,	/* q */
d_rename,		/* r */
rescan,			/* s */
rescan,			/* t */
d_undel,		/* u */
rescan,			/* v */
rescan,			/* w */
d_expunge		/* x */
150};

152static PF direddl[] = {
d_undelbak		/* del */
154};

156static PF diredbp[] = {
d_backpage		/* v */
158};

160static PF dirednull[] = {
NULL((void *)0)
162};

164static struct KEYMAPE (1){ short map_num; short map_max; PF map_default; struct map_element
 map_element[1]; } d_backpagemap = {
1,
1,
rescan,
{
{
'v', 'v', diredbp, NULL((void *)0)
}
}
173};

175static struct KEYMAPE (7){ short map_num; short map_max; PF map_default; struct map_element
 map_element[7]; } diredmap = {
7,
7,
rescan,
{
{
	CCHR('@')(('@') ^ 0x40), CCHR('H')(('H') ^ 0x40), dirednul, (KEYMAP *) & helpmap
},
{
	CCHR('L')(('L') ^ 0x40), CCHR('X')(('X') ^ 0x40), diredcl, (KEYMAP *) & cXmap
},
{
	CCHR('[')(('[') ^ 0x40), CCHR('[')(('[') ^ 0x40), dirednull, (KEYMAP *) &
	d_backpagemap
},
{
	CCHR('Z')(('Z') ^ 0x40), '+', diredcz, (KEYMAP *) & metamap
},
{
	'a', 'j', direda, NULL((void *)0)
},
{
	'n', 'x', diredn, NULL((void *)0)
},
{
	CCHR('?')(('?') ^ 0x40), CCHR('?')(('?') ^ 0x40), direddl, NULL((void *)0)
},
}
203};

205void
206dired_init(void)
207{
funmap_add(dired, "dired", 1);
funmap_add(d_create_directory, "dired-create-directory", 1);
funmap_add(d_copy, "dired-do-copy", 1);
funmap_add(d_expunge, "dired-do-flagged-delete", 0);
funmap_add(d_rename, "dired-do-rename", 1);
funmap_add(d_findfile, "dired-find-file", 1);
funmap_add(d_ffotherwindow, "dired-find-file-other-window", 1);
funmap_add(d_del, "dired-flag-file-deletion", 0);
funmap_add(d_gotofile, "dired-goto-file", 1);
funmap_add(d_forwline, "dired-next-line", 0);
funmap_add(d_otherwindow, "dired-other-window", 0);
funmap_add(d_backline, "dired-previous-line", 0);
funmap_add(d_refreshbuffer, "dired-revert", 0);
funmap_add(d_backpage, "dired-scroll-down", 0);
funmap_add(d_forwpage, "dired-scroll-up", 0);
funmap_add(d_shell_command, "dired-shell-command", 1);
funmap_add(d_undel, "dired-unmark", 0);
funmap_add(d_undelbak, "dired-unmark-backward", 0);
funmap_add(d_killbuffer_cmd, "quit-window", 0);
maps_add((KEYMAP *)&diredmap, "dired");
dobindkey(fundamental_map(fundamental_mode.p_map), "dired", "^Xd");
229}

231int
232dired(int f, int n)
233{
char		 dname[NFILEN1024], *bufp, *slash;
struct buffer	*bp;

if (curbp->b_fname[0] != '\0') {
(void)strlcpy(dname, curbp->b_fname, sizeof(dname));
if ((slash = strrchr(dname, '/')) != NULL((void *)0)) {
	*(slash + 1) = '\0';
}
} else {
if (getcwd(dname, sizeof(dname)) == NULL((void *)0))
	dname[0] = '\0';
}

if ((bufp = eread("Dired (directory): ", dname, NFILEN1024,
   EFDEF0x0020 | EFNEW0x0008 | EFCR0x0010)) == NULL((void *)0))
return (ABORT2);
if (bufp[0] == '\0')
return (FALSE0);
if ((bp = dired_(bufp)) == NULL((void *)0))
return (FALSE0);

curbp = bp;
return (showbuffer(bp, curwp, WFFULL0x08 | WFMODE0x10));
257}

259int
260d_otherwindow(int f, int n)
261{
char		 dname[NFILEN1024], *bufp, *slash;
struct buffer	*bp;
struct mgwin	*wp;

if (curbp->b_fname[0] != '\0') {
(void)strlcpy(dname, curbp->b_fname, sizeof(dname));
if ((slash = strrchr(dname, '/')) != NULL((void *)0)) {
	*(slash + 1) = '\0';
}
} else {
if (getcwd(dname, sizeof(dname)) == NULL((void *)0))
	dname[0] = '\0';
}

if ((bufp = eread("Dired other window: ", dname, NFILEN1024,
   EFDEF0x0020 | EFNEW0x0008 | EFCR0x0010)) == NULL((void *)0))
return (ABORT2);
else if (bufp[0] == '\0')
return (FALSE0);
if ((bp = dired_(bufp)) == NULL((void *)0))
return (FALSE0);
if ((wp = popbuf(bp, WNONE0x00)) == NULL((void *)0))
return (FALSE0);
curbp = bp;
curwp = wp;
return (TRUE1);
288}

290int
291d_del(int f, int n)
292{
if (n < 0)
return (FALSE0);
while (n--) {
if (d_warpdot(curwp->w_dotp, &curwp->w_doto) == TRUE1) {
	lputc(curwp->w_dotp, 0, DDELCHAR)((curwp->w_dotp)->l_text[(0)]=(DDELCHAR));
	curbp->b_flag |= BFDIREDDEL0x80;
}
if (lforw(curwp->w_dotp)((curwp->w_dotp)->l_fp) != curbp->b_headp) {
	curwp->w_dotp = lforw(curwp->w_dotp)((curwp->w_dotp)->l_fp);
	curwp->w_dotline++;
}
}
curwp->w_rflag |= WFEDIT0x04 | WFMOVE0x02;
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
307}

309int
310d_undel(int f, int n)
311{
if (n < 0)
return (d_undelbak(f, -n));
while (n--) {
if (llength(curwp->w_dotp)((curwp->w_dotp)->l_used) > 0)
	lputc(curwp->w_dotp, 0, ' ')((curwp->w_dotp)->l_text[(0)]=(' '));
if (lforw(curwp->w_dotp)((curwp->w_dotp)->l_fp) != curbp->b_headp) {
	curwp->w_dotp = lforw(curwp->w_dotp)((curwp->w_dotp)->l_fp);
	curwp->w_dotline++;
}
}
curwp->w_rflag |= WFEDIT0x04 | WFMOVE0x02;
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
324}

326int
327d_undelbak(int f, int n)
328{
if (n < 0)
return (d_undel(f, -n));
while (n--) {
if (lback(curwp->w_dotp)((curwp->w_dotp)->l_bp) != curbp->b_headp) {
	curwp->w_dotp = lback(curwp->w_dotp)((curwp->w_dotp)->l_bp);
	curwp->w_dotline--;
}
if (llength(curwp->w_dotp)((curwp->w_dotp)->l_used) > 0)
	lputc(curwp->w_dotp, 0, ' ')((curwp->w_dotp)->l_text[(0)]=(' '));
}
curwp->w_rflag |= WFEDIT0x04 | WFMOVE0x02;
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
341}

343int
344d_findfile(int f, int n)
345{
struct buffer	*bp;
int		 s;
char		 fname[NFILEN1024];

if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT2)
return (FALSE0);
if (s == TRUE1)
bp = dired_(fname);
else
bp = findbuffer(fname);
if (bp == NULL((void *)0))
return (FALSE0);
curbp = bp;
if (showbuffer(bp, curwp, WFFULL0x08) != TRUE1)
return (FALSE0);
if (bp->b_fname[0] != 0)
return (TRUE1);
return (readin(fname));
364}

366int
367d_ffotherwindow(int f, int n)
368{
char		 fname[NFILEN1024];
int		 s;
struct buffer	*bp;
struct mgwin	*wp;

if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT2)
return (FALSE0);
if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL((void *)0))
return (FALSE0);
if ((wp = popbuf(bp, WNONE0x00)) == NULL((void *)0))
return (FALSE0);
curbp = bp;
curwp = wp;
if (bp->b_fname[0] != 0)
return (TRUE1);	/* never true for dired buffers */
return (readin(fname));
385}

387int
388d_expunge(int f, int n)
389{
struct line	*lp, *nlp;
char		 fname[NFILEN1024], sname[NFILEN1024];
int		 tmp;

tmp = curwp->w_dotline;
curwp->w_dotline = 0;

for (lp = bfirstlp(curbp)((((curbp)->b_headp)->l_fp)); lp != curbp->b_headp; lp = nlp) {
curwp->w_dotline++;
nlp = lforw(lp)((lp)->l_fp);
if (llength(lp)((lp)->l_used) && lgetc(lp, 0)(((unsigned char) ((lp)->l_text[(0)]))) == 'D') {
	switch (d_makename(lp, fname, sizeof(fname))) {
	case ABORT2:
		dobeep();
		ewprintf("Bad line in dired buffer");
		curwp->w_dotline = tmp;
		return (FALSE0);
	case FALSE0:
		if (unlink(fname) == -1) {
			(void)xbasename(sname, fname, NFILEN1024);
			dobeep();
			ewprintf("Could not delete '%s'", sname);
			curwp->w_dotline = tmp;
			return (FALSE0);
		}
		break;
	case TRUE1:
		if (rmdir(fname) == -1) {
			(void)xbasename(sname, fname, NFILEN1024);
			dobeep();
			ewprintf("Could not delete directory "
			    "'%s'", sname);
			curwp->w_dotline = tmp;
			return (FALSE0);
		}
		break;
	}
	lfree(lp);
	curwp->w_bufp->b_lines--;
	if (tmp > curwp->w_dotline)
		tmp--;
	curwp->w_rflag |= WFFULL0x08;
}
}
curwp->w_dotline = tmp;
d_warpdot(curwp->w_dotp, &curwp->w_doto);

/* we have deleted all items successfully, remove del flag */
curbp->b_flag &= ~BFDIREDDEL0x80;

return (TRUE1);
441}

443int
444d_copy(int f, int n)
445{
struct stat      statbuf;
char		 frname[NFILEN1024], toname[NFILEN1024], sname[NFILEN1024];
char		*topath, *bufp;
int		 ret;
size_t		 off;
struct buffer	*bp;

if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE0) {
dobeep();
ewprintf("Not a file");
return (FALSE0);
}
off = strlcpy(toname, curbp->b_fname, sizeof(toname));
if (off >= sizeof(toname) - 1) {	/* can't happen, really */
dobeep();
ewprintf("Directory name too long");
return (FALSE0);
}
(void)xbasename(sname, frname, NFILEN1024);
bufp = eread("Copy %s to: ", toname, sizeof(toname),
   EFDEF0x0020 | EFNEW0x0008 | EFCR0x0010, sname);
if (bufp == NULL((void *)0))
return (ABORT2);
else if (bufp[0] == '\0')
return (FALSE0);

topath = adjustname(toname, TRUE1);
if (stat(topath, &statbuf) == 0) {
if (S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000)) {
	ret = snprintf(toname, sizeof(toname), "%s/%s",
	    topath, sname);
	if (ret < 0 || ret >= sizeof(toname) - 1) {
		dobeep();
		ewprintf("Directory name too long");
		return (FALSE0);
	}
	topath = adjustname(toname, TRUE1);
}
}
if (topath == NULL((void *)0))
return (FALSE0);
if (strcmp(frname, topath) == 0) {
ewprintf("Cannot copy to same file: %s", frname);
return (TRUE1);
}
ret = (copy(frname, topath) >= 0) ? TRUE1 : FALSE0;
if (ret != TRUE1)
return (ret);
if ((bp = refreshbuffer(curbp)) == NULL((void *)0))
return (FALSE0);

ewprintf("Copy: 1 file");
return (showbuffer(bp, curwp, WFFULL0x08 | WFMODE0x10));
499}

501int
502d_rename(int f, int n)
503{
struct stat      statbuf;
char		 frname[NFILEN1024], toname[NFILEN1024];
char		*topath, *bufp;
int		 ret;
size_t		 off;
struct buffer	*bp;
char		 sname[NFILEN1024];

if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE0) {
dobeep();
ewprintf("Not a file");
return (FALSE0);
}
off = strlcpy(toname, curbp->b_fname, sizeof(toname));
if (off >= sizeof(toname) - 1) {	/* can't happen, really */
dobeep();
ewprintf("Name too long");
return (FALSE0);
}
(void)xbasename(sname, frname, NFILEN1024);
bufp = eread("Rename %s to: ", toname,
   sizeof(toname), EFDEF0x0020 | EFNEW0x0008 | EFCR0x0010, sname);
if (bufp == NULL((void *)0))
return (ABORT2);
else if (bufp[0] == '\0')
return (FALSE0);

topath = adjustname(toname, TRUE1);
if (stat(topath, &statbuf) == 0) {
if (S_ISDIR(statbuf.st_mode)((statbuf.st_mode & 0170000) == 0040000)) {
	ret = snprintf(toname, sizeof(toname), "%s/%s",
	    topath, sname);
	if (ret < 0 || ret >= sizeof(toname) - 1) {
		dobeep();
		ewprintf("Directory name too long");
		return (FALSE0);
	}
	topath = adjustname(toname, TRUE1);
}
}
if (topath == NULL((void *)0))
return (FALSE0);
if (strcmp(frname, topath) == 0) {
ewprintf("Cannot move to same file: %s", frname);
return (TRUE1);
}
ret = (rename(frname, topath) >= 0) ? TRUE1 : FALSE0;
if (ret != TRUE1)
return (ret);
if ((bp = refreshbuffer(curbp)) == NULL((void *)0))
return (FALSE0);

ewprintf("Move: 1 file");
return (showbuffer(bp, curwp, WFFULL0x08 | WFMODE0x10));
558}

560void
561reaper(int signo __attribute__((unused)))
562{
int	save_errno = errno(*__errno()), status;

while (waitpid(-1, &status, WNOHANG0x01) >= 0)
;
errno(*__errno()) = save_errno;
568}

570/*
* Pipe the currently selected file through a shell command.
*/
573int
574d_shell_command(int f, int n)
575{
char		 command[512], fname[PATH_MAX1024], *bufp;
struct buffer	*bp;
struct mgwin	*wp;
char		 sname[NFILEN1024];

bp = bfind("*Shell Command Output*", TRUE1);
if (bclear(bp) != TRUE1)
return (ABORT2);

if (d_makename(curwp->w_dotp, fname, sizeof(fname)) != FALSE0) {
dobeep();
ewprintf("bad line");
return (ABORT2);
}

command[0] = '\0';
(void)xbasename(sname, fname, NFILEN1024);
bufp = eread("! on %s: ", command, sizeof(command), EFNEW0x0008, sname);
if (bufp == NULL((void *)0))
return (ABORT2);

if (d_exec(0, bp, fname, "sh", "-c", command, NULL((void *)0)) != TRUE1)
return (ABORT2);

if ((wp = popbuf(bp, WNONE0x00)) == NULL((void *)0))
return (ABORT2);	/* XXX - free the buffer?? */
curwp = wp;
curbp = wp->w_bufp;
return (TRUE1);
605}

607/*
* Pipe input file to cmd and insert the command's output in the
* given buffer.  Each line will be prefixed with the given
* number of spaces.
*/
612static int
613d_exec(int space, struct buffer *bp, const char *input, const char *cmd, ...)
614{
char	 buf[BUFSIZ1024];
va_list	 ap;
struct	 sigaction olda, newa;
char	**argv = NULL((void *)0), *cp;
FILE	*fin;
int	 fds[2] = { -1, -1 };
int	 infd = -1;
int	 ret = (ABORT2), n;
pid_t	 pid;

if (sigaction(SIGCHLD20, NULL((void *)0), &olda) == -1)
return (ABORT2);

/* Find the number of arguments. */
va_start(ap, cmd)__builtin_va_start((ap), cmd);
for (n = 2; va_arg(ap, char *)__builtin_va_arg((ap), char *) != NULL((void *)0); n++)
;
va_end(ap)__builtin_va_end((ap));

/* Allocate and build the argv. */
if ((argv = calloc(n, sizeof(*argv))) == NULL((void *)0)) {
dobeep();
ewprintf("Can't allocate argv : %s", strerror(errno(*__errno())));
goto out;
}

n = 1;
argv[0] = (char *)cmd;
va_start(ap, cmd)__builtin_va_start((ap), cmd);
while ((argv[n] = va_arg(ap, char *)__builtin_va_arg((ap), char *)) != NULL((void *)0))
n++;
va_end(ap)__builtin_va_end((ap));

if (input == NULL((void *)0))
input = "/dev/null";

if ((infd = open(input, O_RDONLY0x0000)) == -1) {
dobeep();
ewprintf("Can't open input file : %s", strerror(errno(*__errno())));
goto out;
}

if (pipe(fds) == -1) {
dobeep();
ewprintf("Can't create pipe : %s", strerror(errno(*__errno())));
goto out;
}

newa.sa_handler__sigaction_u.__sa_handler = reaper;
newa.sa_flags = 0;
if (sigaction(SIGCHLD20, &newa, NULL((void *)0)) == -1)
goto out;

if ((pid = fork()) == -1) {
dobeep();
ewprintf("Can't fork");
goto out;
}

switch (pid) {
case 0: /* Child */
close(fds[0]);
dup2(infd, STDIN_FILENO0);
dup2(fds[1], STDOUT_FILENO1);
dup2(fds[1], STDERR_FILENO2);
if (execvp(argv[0], argv) == -1)
	ewprintf("Can't exec %s: %s", argv[0], strerror(errno(*__errno())));
exit(1);
break;
default: /* Parent */
close(infd);
close(fds[1]);
infd = fds[1] = -1;
if ((fin = fdopen(fds[0], "r")) == NULL((void *)0))
	goto out;
while (fgets(buf, sizeof(buf), fin) != NULL((void *)0)) {
	cp = strrchr(buf, *bp->b_nlchr);
	if (cp == NULL((void *)0) && !feof(fin)(!__isthreaded ? (((fin)->_flags & 0x0020) != 0) : (feof
)(fin))) {	/* too long a line */
		int c;
		addlinef(bp, "%*s%s...", space, "", buf);
		while ((c = getc(fin)(!__isthreaded ? (--(fin)->_r < 0 ? __srget(fin) : (int
)(*(fin)->_p++)) : (getc)(fin))) != EOF(-1) &&
		    c != *bp->b_nlchr)
			;
		continue;
	} else if (cp)
		*cp = '\0';
	addlinef(bp, "%*s%s", space, "", buf);
}
fclose(fin);
break;
}
ret = (TRUE1);

708out:
if (sigaction(SIGCHLD20, &olda, NULL((void *)0)) == -1)
ewprintf("Warning, couldn't reset previous signal handler");
if (fds[0] != -1)
close(fds[0]);
if (fds[1] != -1)
close(fds[1]);
if (infd != -1)
close(infd);
free(argv);
return ret;
719}

721int
722d_create_directory(int f, int n)
723{
int ret;
struct buffer	*bp;

ret = ask_makedir();
if (ret != TRUE1)
return(ret);

if ((bp = refreshbuffer(curbp)) == NULL((void *)0))
return (FALSE0);

return (showbuffer(bp, curwp, WFFULL0x08 | WFMODE0x10));
735}

737int
738d_killbuffer_cmd(int f, int n)
739{
return(killbuffer_cmd(FFRAND8, 0));
741}

743int
744d_refreshbuffer(int f, int n)
745{
struct buffer *bp;

if ((bp = refreshbuffer(curbp)) == NULL((void *)0))
1
Calling 'refreshbuffer'→
return (FALSE0);

return (showbuffer(bp, curwp, WFFULL0x08 | WFMODE0x10));
752}

754/*
* Kill then re-open the requested dired buffer.
* If required, take a note of any files marked for deletion. Then once
* the buffer has been re-opened, remark the same files as deleted.
*/
759struct buffer *
760refreshbuffer(struct buffer *bp)
761{
char		*tmp_b_fname;
int	 	 i, tmp_w_dotline, ddel = 0;

/* remember directory path to open later */
tmp_b_fname = strdup(bp->b_fname);
if (tmp_b_fname == NULL((void *)0)) {
2
←
Assuming 'tmp_b_fname' is not equal to NULL→
3
←
Taking false branch→
dobeep();
ewprintf("Out of memory");
return (NULL((void *)0));
}
tmp_w_dotline = curwp->w_dotline;

/* create a list of files for deletion */
if (bp->b_flag & BFDIREDDEL0x80)
4
←
Assuming the condition is true→
5
←
Taking true branch→
ddel = createlist(bp);
6
←
Calling 'createlist'→

killbuffer(bp);

/* dired_() uses findbuffer() to create new buffer */
if ((bp = dired_(tmp_b_fname)) == NULL((void *)0)) {
free(tmp_b_fname);
return (NULL((void *)0));
}
free(tmp_b_fname);

/* remark any previously deleted files with a 'D' */
if (ddel)
redelete(bp);		

/* find dot line */
bp->b_dotp = bfirstlp(bp)((((bp)->b_headp)->l_fp));
if (tmp_w_dotline > bp->b_lines)
tmp_w_dotline = bp->b_lines - 1;
for (i = 1; i < tmp_w_dotline; i++)
bp->b_dotp = lforw(bp->b_dotp)((bp->b_dotp)->l_fp);

bp->b_dotline = i;
bp->b_doto = 0;
d_warpdot(bp->b_dotp, &bp->b_doto);

curbp = bp;

return (bp);
805}

807static int
808d_makename(struct line *lp, char *fn, size_t len)
809{
int	 start, nlen, ret;
char	*namep;

if (d_warpdot(lp, &start) == FALSE0)
return (ABORT2);
namep = &lp->l_text[start];
nlen = llength(lp)((lp)->l_used) - start;

ret = snprintf(fn, len, "%s%.*s", curbp->b_fname, nlen, namep);
if (ret < 0 || ret >= (int)len)
return (ABORT2); /* Name is too long. */

/* Return TRUE if the entry is a directory. */
return ((lgetc(lp, 2)(((unsigned char) ((lp)->l_text[(2)]))) == 'd') ? TRUE1 : FALSE0);
824}

826#define NAME_FIELD9	9

828static int
829d_warpdot(struct line *dotp, int *doto)
830{
char *tp = dotp->l_text;
int off = 0, field = 0, len;

/*
* Find the byte offset to the (space-delimited) filename
* field in formatted ls output.
*/
len = llength(dotp)((dotp)->l_used);
while (off < len) {
if (tp[off++] == ' ') {
	if (++field == NAME_FIELD9) {
		*doto = off;
		return (TRUE1);
	}
	/* Skip the space. */
	while (off < len && tp[off] == ' ')
		off++;
}
}
/* We didn't find the field. */
*doto = 0;
return (FALSE0);
853}

855static int
856d_forwpage(int f, int n)
857{
forwpage(f | FFRAND8, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
860}

862static int
863d_backpage (int f, int n)
864{
backpage(f | FFRAND8, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
867}

869static int
870d_forwline (int f, int n)
871{
forwline(f | FFRAND8, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
874}

876static int
877d_backline (int f, int n)
878{
backline(f | FFRAND8, n);
return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
881}

883int
884d_filevisitalt (int f, int n)
885{
char	 fname[NFILEN1024];

if (d_makename(curwp->w_dotp, fname, sizeof(fname)) == ABORT2)
return (FALSE0);

return(do_filevisitalt(fname));
892}

894/*
* XXX dname needs to have enough place to store an additional '/'.
*/
897struct buffer *
898dired_(char *dname)
899{
struct buffer	*bp;
int		 i;
size_t		 len;

if ((dname = adjustname(dname, TRUE1)) == NULL((void *)0)) {
dobeep();
ewprintf("Bad directory name");
return (NULL((void *)0));
}
/* this should not be done, instead adjustname() should get a flag */
len = strlen(dname);
if (dname[len - 1] != '/') {
dname[len++] = '/';
dname[len] = '\0';
}
if ((access(dname, R_OK0x04 | X_OK0x01)) == -1) {
if (errno(*__errno()) == EACCES13) {
	dobeep();
	ewprintf("Permission denied: %s", dname);
} else {
	dobeep();
	ewprintf("Error opening: %s", dname);
}
return (NULL((void *)0));
}
for (bp = bheadp; bp != NULL((void *)0); bp = bp->b_bufpb_list.l_p.x_bp) {
if (strcmp(bp->b_fname, dname) == 0) {
	if (fchecktime(bp) != TRUE1)
		ewprintf("Directory has changed on disk;"
		    " type g to update Dired");
	return (bp);
}

}
bp = bfind(dname, TRUE1);
bp->b_flag |= BFREADONLY0x10 | BFIGNDIRTY0x40;

if ((d_exec(2, bp, NULL((void *)0), "ls", "-al", dname, NULL((void *)0))) != TRUE1)
return (NULL((void *)0));

/* Find the line with ".." on it. */
bp->b_dotp = bfirstlp(bp)((((bp)->b_headp)->l_fp));
bp->b_dotline = 1;
for (i = 0; i < bp->b_lines; i++) {
bp->b_dotp = lforw(bp->b_dotp)((bp->b_dotp)->l_fp);
bp->b_dotline++;
if (d_warpdot(bp->b_dotp, &bp->b_doto) == FALSE0)
	continue;
if (strcmp(ltext(bp->b_dotp)((bp->b_dotp)->l_text) + bp->b_doto, "..") == 0)
	break;
}

/* We want dot on the entry right after "..", if possible. */
if (++i < bp->b_lines - 2) {
bp->b_dotp = lforw(bp->b_dotp)((bp->b_dotp)->l_fp);
bp->b_dotline++;
}
d_warpdot(bp->b_dotp, &bp->b_doto);

(void)strlcpy(bp->b_fname, dname, sizeof(bp->b_fname));
(void)strlcpy(bp->b_cwd, dname, sizeof(bp->b_cwd));
if ((bp->b_modes[1] = name_mode("dired")) == NULL((void *)0)) {
bp->b_modes[0] = name_mode("fundamental");
dobeep();
ewprintf("Could not find mode dired");
return (NULL((void *)0));
}
(void)fupdstat(bp);
bp->b_nmodes = 1;
return (bp);
970}

972/*
* Iterate through the lines of the dired buffer looking for files
* collected in the linked list made in createlist(). If a line is found
* replace 'D' as first char in a line. As lines are found, remove the
* corresponding item from the linked list. Iterate for as long as there
* are items in the linked list or until end of buffer is found.
*/
979void
980redelete(struct buffer *bp)
981{
struct delentry	*dt, *d1 = NULL((void *)0);
struct line	*lp, *nlp;
char		 fname[NFILEN1024];
char		*p = fname;
size_t		 plen, fnlen;
int		 finished = 0;

/* reset the deleted file buffer flag until a deleted file is found */
bp->b_flag &= ~BFDIREDDEL0x80;

for (lp = bfirstlp(bp)((((bp)->b_headp)->l_fp)); lp != bp->b_headp; lp = nlp) {	
bp->b_dotp = lp;
if ((p = findfname(lp, p)) == NULL((void *)0)) {
	nlp = lforw(lp)((lp)->l_fp);
	continue;
}
plen = strlen(p);
SLIST_FOREACH_SAFE(d1, &delhead, entry, dt)for ((d1) = ((&delhead)->slh_first); (d1) && (
(dt) = ((d1)->entry.sle_next), 1); (d1) = (dt)) {
	fnlen = strlen(d1->fn);
	if ((plen == fnlen) && 
	    (strncmp(p, d1->fn, plen) == 0)) {
		lputc(bp->b_dotp, 0, DDELCHAR)((bp->b_dotp)->l_text[(0)]=(DDELCHAR));
		bp->b_flag |= BFDIREDDEL0x80;
		SLIST_REMOVE(&delhead, d1, delentry, entry)do { if ((&delhead)->slh_first == (d1)) { do { ((&
delhead))->slh_first = ((&delhead))->slh_first->
entry.sle_next; } while (0); } else { struct delentry *curelm
 = (&delhead)->slh_first; while (curelm->entry.sle_next
 != (d1)) curelm = curelm->entry.sle_next; curelm->entry
.sle_next = curelm->entry.sle_next->entry.sle_next; } ;
 } while (0);
		if (SLIST_EMPTY(&delhead)(((&delhead)->slh_first) == ((void *)0))) {
			finished = 1;
			break;
		}	
	}
}
if (finished)
	break;
nlp = lforw(lp)((lp)->l_fp);
}
while (!SLIST_EMPTY(&delhead)(((&delhead)->slh_first) == ((void *)0))) {
d1 = SLIST_FIRST(&delhead)((&delhead)->slh_first);
SLIST_REMOVE_HEAD(&delhead, entry)do { (&delhead)->slh_first = (&delhead)->slh_first
->entry.sle_next; } while (0);
free(d1->fn);
free(d1);
}
return;
1023}

1025/*
* Create a list of files marked for deletion.
*/
1028int
1029createlist(struct buffer *bp)
1030{
struct delentry	*d1 = NULL((void *)0), *d2;
7
←
'd1' initialized to a null pointer value→
struct line	*lp, *nlp;
char		 fname[NFILEN1024];
char		*p = fname;
int		 ret = FALSE0;

for (lp = bfirstlp(bp)((((bp)->b_headp)->l_fp)); lp != bp->b_headp; lp = nlp) {
8
←
Assuming 'lp' is not equal to field 'b_headp'→
/* 
 * Check if the line has 'D' on the first char and if a valid
 * filename can be extracted from it.
 */
if (((lp->l_text[0] != DDELCHAR)) ||
9
←
Assuming the condition is false→
11
←
Taking false branch→
    ((p = findfname(lp, p)) == NULL((void *)0))) {
10
←
Assuming the condition is false→
	nlp = lforw(lp)((lp)->l_fp);
	continue;
}
if (SLIST_EMPTY(&delhead)(((&delhead)->slh_first) == ((void *)0))) {
12
←
Assuming field 'slh_first' is not equal to null→
13
←
Taking false branch→
	if ((d1 = malloc(sizeof(struct delentry)))
	     == NULL((void *)0))
		return (ABORT2);
	if ((d1->fn = strdup(p)) == NULL((void *)0)) {
		free(d1);
		return (ABORT2);
	}
	SLIST_INSERT_HEAD(&delhead, d1, entry)do { (d1)->entry.sle_next = (&delhead)->slh_first; (
&delhead)->slh_first = (d1); } while (0);
} else {
	if ((d2 = malloc(sizeof(struct delentry)))
14
←
Assuming the condition is true→
15
←
Taking true branch→
	     == NULL((void *)0)) {
		free(d1->fn);
16
←
Access to field 'fn' results in a dereference of a null pointer (loaded from variable 'd1')
		free(d1);
		return (ABORT2);
	}
	if ((d2->fn = strdup(p)) == NULL((void *)0)) {
		free(d1->fn);
		free(d1);
		free(d2);
		return (ABORT2);
	}
	if (!d1)
		SLIST_INSERT_HEAD(&delhead, d2, entry)do { (d2)->entry.sle_next = (&delhead)->slh_first; (
&delhead)->slh_first = (d2); } while (0);
	else
		SLIST_INSERT_AFTER(d1, d2, entry)do { (d2)->entry.sle_next = (d1)->entry.sle_next; (d1)->
entry.sle_next = (d2); } while (0);
	d1 = d2;				
}
ret = TRUE1;
nlp = lforw(lp)((lp)->l_fp);
}
return (ret);
1079}

1081int
1082dired_jump(int f, int n)
1083{
struct buffer   *bp;
const char	*modename;
char             dname[NFILEN1024], *fname;
int              ret, i;

/*
* We use fundamental mode in dired, so just check we aren't in
* dired mode for this specific function. Seems like a corner
* case at the moment.
*/
for (i = 0; i <= curbp->b_nmodes; i++) {
modename = curbp->b_modes[i]->p_name;
if (strncmp(modename, "dired", 5) == 0)
	return (dobeep_msg("In dired mode already"));
}

if (getbufcwd(dname, sizeof(dname)) != TRUE1)
return (FALSE0);

fname = curbp->b_fname;

if ((bp = dired_(dname)) == NULL((void *)0))
return (FALSE0);
curbp = bp;

ret = showbuffer(bp, curwp, WFFULL0x08 | WFMODE0x10);
if (ret != TRUE1)
return ret;

fname = adjustname(fname, TRUE1);
if (fname != NULL((void *)0))
gotofile(fname);

return (TRUE1);
1118}

1120int
1121d_gotofile(int f, int n)
1122{
size_t		 lenfpath;
char		 fpath[NFILEN1024];
char		*fpth, *fnp = NULL((void *)0);

if (getbufcwd(fpath, sizeof(fpath)) != TRUE1)
fpath[0] = '\0';
lenfpath = strlen(fpath);
fnp = eread("Goto file: ", fpath, NFILEN1024,
   EFNEW0x0008 | EFCR0x0010 | EFFILE0x0004 | EFDEF0x0020);
if (fnp == NULL((void *)0))
return (ABORT2);
else if (fnp[0] == '\0')
return (FALSE0);

fpth = adjustname(fpath, TRUE1);		/* Removes last '/' if dir...  */
if (fpth == NULL((void *)0) || strlen(fpth) == lenfpath - 1) { /* ...hence -1.    */
ewprintf("No file to find");	/* Current directory given so  */
return (TRUE1);			/* return at present location. */
}
return gotofile(fpth);
1143}

1145int
1146gotofile(char *fpth)
1147{
struct line	*lp, *nlp;
char		 fname[NFILEN1024];
char		*p;
int		 tmp;

(void)xbasename(fname, fpth, NFILEN1024);
tmp = 0;
for (lp = bfirstlp(curbp)((((curbp)->b_headp)->l_fp)); lp != curbp->b_headp; lp = nlp) {
tmp++;
if ((p = findfname(lp, p)) == NULL((void *)0)) {
	nlp = lforw(lp)((lp)->l_fp);
	continue;
}
if (strcmp(fname, p) == 0) {
	curwp->w_dotp = lp;
	curwp->w_dotline = tmp;
	(void)d_warpdot(curwp->w_dotp, &curwp->w_doto);
	tmp--;
	break;
}
nlp = lforw(lp)((lp)->l_fp);
}
if (tmp == curbp->b_lines - 1) {
ewprintf("File not found %s", fname);
return (FALSE0);
} else {
eerase();
return (TRUE1);
}
1177}

1179/*
* Look for and extract a file name on a dired buffer line.
*/
1182char *
1183findfname(struct line *lp, char *fn)
1184{
int start;

(void)d_warpdot(lp, &start);
if (start < 1)
return NULL((void *)0);
fn = &lp->l_text[start];
return fn;
1192}