xref: /freebsd/contrib/nvi/ex/ex_write.c (revision 7aa383846770374466b1dcb2cefd71bde9acf463)
1 /*-
2  * Copyright (c) 1992, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
5  *	Keith Bostic.  All rights reserved.
6  *
7  * See the LICENSE file for redistribution information.
8  */
9 
10 #include "config.h"
11 
12 #ifndef lint
13 static const char sccsid[] = "@(#)ex_write.c	10.30 (Berkeley) 7/12/96";
14 #endif /* not lint */
15 
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/stat.h>
19 
20 #include <bitstring.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 
30 #include "../common/common.h"
31 
32 enum which {WN, WQ, WRITE, XIT};
33 static int exwr __P((SCR *, EXCMD *, enum which));
34 
35 /*
36  * ex_wn --	:wn[!] [>>] [file]
37  *	Write to a file and switch to the next one.
38  *
39  * PUBLIC: int ex_wn __P((SCR *, EXCMD *));
40  */
41 int
42 ex_wn(sp, cmdp)
43 	SCR *sp;
44 	EXCMD *cmdp;
45 {
46 	if (exwr(sp, cmdp, WN))
47 		return (1);
48 	if (file_m3(sp, 0))
49 		return (1);
50 
51 	/* The file name isn't a new file to edit. */
52 	cmdp->argc = 0;
53 
54 	return (ex_next(sp, cmdp));
55 }
56 
57 /*
58  * ex_wq --	:wq[!] [>>] [file]
59  *	Write to a file and quit.
60  *
61  * PUBLIC: int ex_wq __P((SCR *, EXCMD *));
62  */
63 int
64 ex_wq(sp, cmdp)
65 	SCR *sp;
66 	EXCMD *cmdp;
67 {
68 	int force;
69 
70 	if (exwr(sp, cmdp, WQ))
71 		return (1);
72 	if (file_m3(sp, 0))
73 		return (1);
74 
75 	force = FL_ISSET(cmdp->iflags, E_C_FORCE);
76 
77 	if (ex_ncheck(sp, force))
78 		return (1);
79 
80 	F_SET(sp, force ? SC_EXIT_FORCE : SC_EXIT);
81 	return (0);
82 }
83 
84 /*
85  * ex_write --	:write[!] [>>] [file]
86  *		:write [!] [cmd]
87  *	Write to a file.
88  *
89  * PUBLIC: int ex_write __P((SCR *, EXCMD *));
90  */
91 int
92 ex_write(sp, cmdp)
93 	SCR *sp;
94 	EXCMD *cmdp;
95 {
96 	return (exwr(sp, cmdp, WRITE));
97 }
98 
99 
100 /*
101  * ex_xit -- :x[it]! [file]
102  *	Write out any modifications and quit.
103  *
104  * PUBLIC: int ex_xit __P((SCR *, EXCMD *));
105  */
106 int
107 ex_xit(sp, cmdp)
108 	SCR *sp;
109 	EXCMD *cmdp;
110 {
111 	int force;
112 
113 	NEEDFILE(sp, cmdp);
114 
115 	if (F_ISSET(sp->ep, F_MODIFIED) && exwr(sp, cmdp, XIT))
116 		return (1);
117 	if (file_m3(sp, 0))
118 		return (1);
119 
120 	force = FL_ISSET(cmdp->iflags, E_C_FORCE);
121 
122 	if (ex_ncheck(sp, force))
123 		return (1);
124 
125 	F_SET(sp, force ? SC_EXIT_FORCE : SC_EXIT);
126 	return (0);
127 }
128 
129 /*
130  * exwr --
131  *	The guts of the ex write commands.
132  */
133 static int
134 exwr(sp, cmdp, cmd)
135 	SCR *sp;
136 	EXCMD *cmdp;
137 	enum which cmd;
138 {
139 	MARK rm;
140 	int flags;
141 	char *name, *p;
142 
143 	NEEDFILE(sp, cmdp);
144 
145 	/* All write commands can have an associated '!'. */
146 	LF_INIT(FS_POSSIBLE);
147 	if (FL_ISSET(cmdp->iflags, E_C_FORCE))
148 		LF_SET(FS_FORCE);
149 
150 	/* Skip any leading whitespace. */
151 	if (cmdp->argc != 0)
152 		for (p = cmdp->argv[0]->bp; *p != '\0' && isblank(*p); ++p);
153 
154 	/* If "write !" it's a pipe to a utility. */
155 	if (cmdp->argc != 0 && cmd == WRITE && *p == '!') {
156 		/* Secure means no shell access. */
157 		if (O_ISSET(sp, O_SECURE)) {
158 			ex_emsg(sp, cmdp->cmd->name, EXM_SECURE_F);
159 			return (1);
160 		}
161 
162 		/* Expand the argument. */
163 		for (++p; *p && isblank(*p); ++p);
164 		if (*p == '\0') {
165 			ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
166 			return (1);
167 		}
168 		if (argv_exp1(sp, cmdp, p, strlen(p), 1))
169 			return (1);
170 
171 		/*
172 		 * Historically, vi waited after a write filter even if there
173 		 * wasn't any output from the command.  People complained when
174 		 * nvi waited only if there was output, wanting the visual cue
175 		 * that the program hadn't written anything.
176 		 */
177 		F_SET(sp, SC_EX_WAIT_YES);
178 
179 		/*
180 		 * !!!
181 		 * Ignore the return cursor position, the cursor doesn't
182 		 * move.
183 		 */
184 		if (ex_filter(sp, cmdp, &cmdp->addr1,
185 		    &cmdp->addr2, &rm, cmdp->argv[1]->bp, FILTER_WRITE))
186 			return (1);
187 
188 		/* Ex terminates with a bang, even if the command fails. */
189 		if (!F_ISSET(sp, SC_VI) && !F_ISSET(sp, SC_EX_SILENT))
190 			(void)ex_puts(sp, "!\n");
191 
192 		return (0);
193 	}
194 
195 	/* Set the FS_ALL flag if we're writing the entire file. */
196 	if (cmdp->addr1.lno <= 1 && !db_exist(sp, cmdp->addr2.lno + 1))
197 		LF_SET(FS_ALL);
198 
199 	/* If "write >>" it's an append to a file. */
200 	if (cmdp->argc != 0 && cmd != XIT && p[0] == '>' && p[1] == '>') {
201 		LF_SET(FS_APPEND);
202 
203 		/* Skip ">>" and whitespace. */
204 		for (p += 2; *p && isblank(*p); ++p);
205 	}
206 
207 	/* If no other arguments, just write the file back. */
208 	if (cmdp->argc == 0 || *p == '\0')
209 		return (file_write(sp,
210 		    &cmdp->addr1, &cmdp->addr2, NULL, flags));
211 
212 	/* Build an argv so we get an argument count and file expansion. */
213 	if (argv_exp2(sp, cmdp, p, strlen(p)))
214 		return (1);
215 
216 	/*
217 	 *  0 args: impossible.
218 	 *  1 args: impossible (I hope).
219 	 *  2 args: read it.
220 	 * >2 args: object, too many args.
221 	 *
222 	 * The 1 args case depends on the argv_sexp() function refusing
223 	 * to return success without at least one non-blank character.
224 	 */
225 	switch (cmdp->argc) {
226 	case 0:
227 	case 1:
228 		abort();
229 		/* NOTREACHED */
230 	case 2:
231 		name = cmdp->argv[1]->bp;
232 
233 		/*
234 		 * !!!
235 		 * Historically, the read and write commands renamed
236 		 * "unnamed" files, or, if the file had a name, set
237 		 * the alternate file name.
238 		 */
239 		if (F_ISSET(sp->frp, FR_TMPFILE) &&
240 		    !F_ISSET(sp->frp, FR_EXNAMED)) {
241 			if ((p = v_strdup(sp,
242 			    cmdp->argv[1]->bp, cmdp->argv[1]->len)) != NULL) {
243 				free(sp->frp->name);
244 				sp->frp->name = p;
245 			}
246 			/*
247 			 * The file has a real name, it's no longer a
248 			 * temporary, clear the temporary file flags.
249 			 *
250 			 * !!!
251 			 * If we're writing the whole file, FR_NAMECHANGE
252 			 * will be cleared by the write routine -- this is
253 			 * historic practice.
254 			 */
255 			F_CLR(sp->frp, FR_TMPEXIT | FR_TMPFILE);
256 			F_SET(sp->frp, FR_NAMECHANGE | FR_EXNAMED);
257 
258 			/* Notify the screen. */
259 			(void)sp->gp->scr_rename(sp, sp->frp->name, 1);
260 		} else
261 			set_alt_name(sp, name);
262 		break;
263 	default:
264 		ex_emsg(sp, p, EXM_FILECOUNT);
265 		return (1);
266 	}
267 
268 	return (file_write(sp, &cmdp->addr1, &cmdp->addr2, name, flags));
269 }
270 
271 /*
272  * ex_writefp --
273  *	Write a range of lines to a FILE *.
274  *
275  * PUBLIC: int ex_writefp __P((SCR *,
276  * PUBLIC:    char *, FILE *, MARK *, MARK *, u_long *, u_long *, int));
277  */
278 int
279 ex_writefp(sp, name, fp, fm, tm, nlno, nch, silent)
280 	SCR *sp;
281 	char *name;
282 	FILE *fp;
283 	MARK *fm, *tm;
284 	u_long *nlno, *nch;
285 	int silent;
286 {
287 	struct stat sb;
288 	GS *gp;
289 	u_long ccnt;			/* XXX: can't print off_t portably. */
290 	recno_t fline, tline, lcnt;
291 	size_t len;
292 	int rval;
293 	char *msg, *p;
294 
295 	gp = sp->gp;
296 	fline = fm->lno;
297 	tline = tm->lno;
298 
299 	if (nlno != NULL) {
300 		*nch = 0;
301 		*nlno = 0;
302 	}
303 
304 	/*
305 	 * The vi filter code has multiple processes running simultaneously,
306 	 * and one of them calls ex_writefp().  The "unsafe" function calls
307 	 * in this code are to db_get() and msgq().  Db_get() is safe, see
308 	 * the comment in ex_filter.c:ex_filter() for details.  We don't call
309 	 * msgq if the multiple process bit in the EXF is set.
310 	 *
311 	 * !!!
312 	 * Historic vi permitted files of 0 length to be written.  However,
313 	 * since the way vi got around dealing with "empty" files was to
314 	 * always have a line in the file no matter what, it wrote them as
315 	 * files of a single, empty line.  We write empty files.
316 	 *
317 	 * "Alex, I'll take vi trivia for $1000."
318 	 */
319 	ccnt = 0;
320 	lcnt = 0;
321 	msg = "253|Writing...";
322 	if (tline != 0)
323 		for (; fline <= tline; ++fline, ++lcnt) {
324 			/* Caller has to provide any interrupt message. */
325 			if ((lcnt + 1) % INTERRUPT_CHECK == 0) {
326 				if (INTERRUPTED(sp))
327 					break;
328 				if (!silent) {
329 					gp->scr_busy(sp, msg, msg == NULL ?
330 					    BUSY_UPDATE : BUSY_ON);
331 					msg = NULL;
332 				}
333 			}
334 			if (db_get(sp, fline, DBG_FATAL, &p, &len))
335 				goto err;
336 			if (fwrite(p, 1, len, fp) != len)
337 				goto err;
338 			ccnt += len;
339 			if (putc('\n', fp) != '\n')
340 				break;
341 			++ccnt;
342 		}
343 
344 	if (fflush(fp))
345 		goto err;
346 	/*
347 	 * XXX
348 	 * I don't trust NFS -- check to make sure that we're talking to
349 	 * a regular file and sync so that NFS is forced to flush.
350 	 */
351 	if (!fstat(fileno(fp), &sb) &&
352 	    S_ISREG(sb.st_mode) && fsync(fileno(fp)))
353 		goto err;
354 
355 	if (fclose(fp))
356 		goto err;
357 
358 	rval = 0;
359 	if (0) {
360 err:		if (!F_ISSET(sp->ep, F_MULTILOCK))
361 			msgq_str(sp, M_SYSERR, name, "%s");
362 		(void)fclose(fp);
363 		rval = 1;
364 	}
365 
366 	if (!silent)
367 		gp->scr_busy(sp, NULL, BUSY_OFF);
368 
369 	/* Report the possibly partial transfer. */
370 	if (nlno != NULL) {
371 		*nch = ccnt;
372 		*nlno = lcnt;
373 	}
374 	return (rval);
375 }
376