1 /* $NetBSD: ex_init.c,v 1.4 2014/01/26 21:43:45 christos Exp $ */
2 /*-
3 * Copyright (c) 1992, 1993, 1994
4 * The Regents of the University of California. All rights reserved.
5 * Copyright (c) 1992, 1993, 1994, 1995, 1996
6 * Keith Bostic. All rights reserved.
7 *
8 * See the LICENSE file for redistribution information.
9 */
10
11 #include "config.h"
12
13 #include <sys/cdefs.h>
14 #if 0
15 #ifndef lint
16 static const char sccsid[] = "Id: ex_init.c,v 10.31 2001/06/25 15:19:16 skimo Exp (Berkeley) Date: 2001/06/25 15:19:16 ";
17 #endif /* not lint */
18 #else
19 __RCSID("$NetBSD: ex_init.c,v 1.4 2014/01/26 21:43:45 christos Exp $");
20 #endif
21
22 #include <sys/param.h>
23 #include <sys/types.h> /* XXX: param.h may not have included types.h */
24 #include <sys/queue.h>
25 #include <sys/stat.h>
26
27 #include <bitstring.h>
28 #include <fcntl.h>
29 #include <limits.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34
35 #include "../common/common.h"
36 #include "tag.h"
37 #include "pathnames.h"
38
39 enum rc { NOEXIST, NOPERM, RCOK };
40 static enum rc exrc_isok __P((SCR *, struct stat *, const char *, int, int));
41
42 static int ex_run_file __P((SCR *, const char *));
43
44 /*
45 * ex_screen_copy --
46 * Copy ex screen.
47 *
48 * PUBLIC: int ex_screen_copy __P((SCR *, SCR *));
49 */
50 int
ex_screen_copy(SCR * orig,SCR * sp)51 ex_screen_copy(SCR *orig, SCR *sp)
52 {
53 EX_PRIVATE *oexp, *nexp;
54
55 /* Create the private ex structure. */
56 CALLOC_RET(orig, nexp, EX_PRIVATE *, 1, sizeof(EX_PRIVATE));
57 sp->ex_private = nexp;
58
59 /* Initialize queues. */
60 TAILQ_INIT(&nexp->tq);
61 TAILQ_INIT(&nexp->tagfq);
62 LIST_INIT(&nexp->cscq);
63
64 if (orig == NULL) {
65 } else {
66 oexp = EXP(orig);
67
68 if (oexp->lastbcomm != NULL &&
69 (nexp->lastbcomm = v_wstrdup(sp, oexp->lastbcomm,
70 STRLEN(oexp->lastbcomm))) == NULL) {
71 msgq(sp, M_SYSERR, NULL);
72 return(1);
73 }
74 if (ex_tag_copy(orig, sp))
75 return (1);
76 }
77 return (0);
78 }
79
80 /*
81 * ex_screen_end --
82 * End a vi screen.
83 *
84 * PUBLIC: int ex_screen_end __P((SCR *));
85 */
86 int
ex_screen_end(SCR * sp)87 ex_screen_end(SCR *sp)
88 {
89 EX_PRIVATE *exp;
90 int rval;
91
92 if ((exp = EXP(sp)) == NULL)
93 return (0);
94
95 rval = 0;
96
97 /* Close down script connections. */
98 if (F_ISSET(sp, SC_SCRIPT) && sscr_end(sp))
99 rval = 1;
100
101 if (argv_free(sp))
102 rval = 1;
103
104 if (exp->ibp != NULL)
105 free(exp->ibp);
106
107 if (exp->lastbcomm != NULL)
108 free(exp->lastbcomm);
109
110 if (ex_tag_free(sp))
111 rval = 1;
112
113 /* Free private memory. */
114 free(exp);
115 sp->ex_private = NULL;
116
117 return (rval);
118 }
119
120 /*
121 * ex_optchange --
122 * Handle change of options for ex.
123 *
124 * PUBLIC: int ex_optchange __P((SCR *, int, const char *, u_long *));
125 */
126 int
ex_optchange(SCR * sp,int offset,const char * str,u_long * valp)127 ex_optchange(SCR *sp, int offset, const char *str, u_long *valp)
128 {
129 switch (offset) {
130 case O_TAGS:
131 return (ex_tagf_alloc(sp, str));
132 }
133 return (0);
134 }
135
136 /*
137 * ex_exrc --
138 * Read the EXINIT environment variable and the startup exrc files,
139 * and execute their commands.
140 *
141 * PUBLIC: int ex_exrc __P((SCR *));
142 */
143 int
ex_exrc(SCR * sp)144 ex_exrc(SCR *sp)
145 {
146 struct stat hsb, lsb;
147 char *p, path[MAXPATHLEN];
148 const CHAR_T *wp;
149 size_t wlen;
150
151 /*
152 * Source the system, environment, $HOME and local .exrc values.
153 * Vi historically didn't check $HOME/.exrc if the environment
154 * variable EXINIT was set. This is all done before the file is
155 * read in, because things in the .exrc information can set, for
156 * example, the recovery directory.
157 *
158 * !!!
159 * While nvi can handle any of the options settings of historic vi,
160 * the converse is not true. Since users are going to have to have
161 * files and environmental variables that work with both, we use nvi
162 * versions of both the $HOME and local startup files if they exist,
163 * otherwise the historic ones.
164 *
165 * !!!
166 * For a discussion of permissions and when what .exrc files are
167 * read, see the comment above the exrc_isok() function below.
168 *
169 * !!!
170 * If the user started the historic of vi in $HOME, vi read the user's
171 * .exrc file twice, as $HOME/.exrc and as ./.exrc. We avoid this, as
172 * it's going to make some commands behave oddly, and I can't imagine
173 * anyone depending on it.
174 */
175 switch (exrc_isok(sp, &hsb, _PATH_SYSEXRC, 1, 0)) {
176 case NOEXIST:
177 case NOPERM:
178 break;
179 case RCOK:
180 if (ex_run_file(sp, _PATH_SYSEXRC))
181 return (1);
182 break;
183 }
184
185 /* Run the commands. */
186 if (EXCMD_RUNNING(sp->wp))
187 (void)ex_cmd(sp);
188 if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE))
189 return (0);
190
191 if ((p = getenv("NEXINIT")) != NULL) {
192 CHAR2INT(sp, p, strlen(p) + 1, wp, wlen);
193 if (ex_run_str(sp, "NEXINIT", wp, wlen - 1, 1, 0))
194 return (1);
195 } else if ((p = getenv("EXINIT")) != NULL) {
196 CHAR2INT(sp, p, strlen(p) + 1, wp, wlen);
197 if (ex_run_str(sp, "EXINIT", wp, wlen - 1, 1, 0))
198 return (1);
199 } else if ((p = getenv("HOME")) != NULL && *p) {
200 (void)snprintf(path, sizeof(path), "%s/%s", p, _PATH_NEXRC);
201 switch (exrc_isok(sp, &hsb, path, 0, 1)) {
202 case NOEXIST:
203 (void)snprintf(path,
204 sizeof(path), "%s/%s", p, _PATH_EXRC);
205 if (exrc_isok(sp,
206 &hsb, path, 0, 1) == RCOK && ex_run_file(sp, path))
207 return (1);
208 break;
209 case NOPERM:
210 break;
211 case RCOK:
212 if (ex_run_file(sp, path))
213 return (1);
214 break;
215 }
216 }
217
218 /* Run the commands. */
219 if (EXCMD_RUNNING(sp->wp))
220 (void)ex_cmd(sp);
221 if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE))
222 return (0);
223
224 /* Previous commands may have set the exrc option. */
225 if (O_ISSET(sp, O_EXRC)) {
226 switch (exrc_isok(sp, &lsb, _PATH_NEXRC, 0, 0)) {
227 case NOEXIST:
228 if (exrc_isok(sp, &lsb, _PATH_EXRC, 0, 0) == RCOK &&
229 (lsb.st_dev != hsb.st_dev ||
230 lsb.st_ino != hsb.st_ino) &&
231 ex_run_file(sp, _PATH_EXRC))
232 return (1);
233 break;
234 case NOPERM:
235 break;
236 case RCOK:
237 if ((lsb.st_dev != hsb.st_dev ||
238 lsb.st_ino != hsb.st_ino) &&
239 ex_run_file(sp, _PATH_NEXRC))
240 return (1);
241 break;
242 }
243 /* Run the commands. */
244 if (EXCMD_RUNNING(sp->wp))
245 (void)ex_cmd(sp);
246 if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE))
247 return (0);
248 }
249
250 return (0);
251 }
252
253 /*
254 * ex_run_file --
255 * Set up a file of ex commands to run.
256 */
257 static int
ex_run_file(SCR * sp,const char * name)258 ex_run_file(SCR *sp, const char *name)
259 {
260 EXCMD cmd;
261 const CHAR_T *wp;
262 size_t wlen;
263
264 ex_cinit(sp, &cmd, C_SOURCE, 0, OOBLNO, OOBLNO, 0);
265 CHAR2INT(sp, name, strlen(name)+1, wp, wlen);
266 argv_exp0(sp, &cmd, wp, wlen - 1);
267 return (ex_source(sp, &cmd));
268 }
269
270 /*
271 * ex_run_str --
272 * Set up a string of ex commands to run.
273 *
274 * PUBLIC: int ex_run_str __P((SCR *, const char *, const CHAR_T *, size_t, int, int));
275 */
276 int
ex_run_str(SCR * sp,const char * name,const CHAR_T * str,size_t len,int ex_flags,int nocopy)277 ex_run_str(SCR *sp, const char *name, const CHAR_T *str, size_t len, int ex_flags, int nocopy)
278 {
279 WIN *wp;
280 EXCMD *ecp;
281
282 wp = sp->wp;
283 if (EXCMD_RUNNING(wp)) {
284 CALLOC_RET(sp, ecp, EXCMD *, 1, sizeof(EXCMD));
285 LIST_INSERT_HEAD(&wp->ecq, ecp, q);
286 } else
287 ecp = &wp->excmd;
288
289 F_INIT(ecp,
290 ex_flags ? E_BLIGNORE | E_NOAUTO | E_NOPRDEF | E_VLITONLY : 0);
291
292 if (nocopy)
293 ecp->cp = __UNCONST(str);
294 else
295 if ((ecp->cp = v_wstrdup(sp, str, len)) == NULL)
296 return (1);
297 ecp->clen = len;
298
299 if (name == NULL)
300 ecp->if_name = NULL;
301 else {
302 if ((ecp->if_name = v_strdup(sp, name, strlen(name))) == NULL)
303 return (1);
304 ecp->if_lno = 1;
305 F_SET(ecp, E_NAMEDISCARD);
306 }
307
308 return (0);
309 }
310
311 /*
312 * exrc_isok --
313 * Check a .exrc file for source-ability.
314 *
315 * !!!
316 * Historically, vi read the $HOME and local .exrc files if they were owned
317 * by the user's real ID, or the "sourceany" option was set, regardless of
318 * any other considerations. We no longer support the sourceany option as
319 * it's a security problem of mammoth proportions. We require the system
320 * .exrc file to be owned by root, the $HOME .exrc file to be owned by the
321 * user's effective ID (or that the user's effective ID be root) and the
322 * local .exrc files to be owned by the user's effective ID. In all cases,
323 * the file cannot be writeable by anyone other than its owner.
324 *
325 * In O'Reilly ("Learning the VI Editor", Fifth Ed., May 1992, page 106),
326 * it notes that System V release 3.2 and later has an option "[no]exrc".
327 * The behavior is that local .exrc files are read only if the exrc option
328 * is set. The default for the exrc option was off, so, by default, local
329 * .exrc files were not read. The problem this was intended to solve was
330 * that System V permitted users to give away files, so there's no possible
331 * ownership or writeability test to ensure that the file is safe.
332 *
333 * POSIX 1003.2-1992 standardized exrc as an option. It required the exrc
334 * option to be off by default, thus local .exrc files are not to be read
335 * by default. The Rationale noted (incorrectly) that this was a change
336 * to historic practice, but correctly noted that a default of off improves
337 * system security. POSIX also required that vi check the effective user
338 * ID instead of the real user ID, which is why we've switched from historic
339 * practice.
340 *
341 * We initialize the exrc variable to off. If it's turned on by the system
342 * or $HOME .exrc files, and the local .exrc file passes the ownership and
343 * writeability tests, then we read it. This breaks historic 4BSD practice,
344 * but it gives us a measure of security on systems where users can give away
345 * files.
346 */
347 static enum rc
exrc_isok(SCR * sp,struct stat * sbp,const char * path,int rootown,int rootid)348 exrc_isok(SCR *sp, struct stat *sbp, const char *path, int rootown, int rootid)
349 {
350 enum { ROOTOWN, OWN, WRITER } etype;
351 uid_t euid;
352 int nf1, nf2;
353 char *a, *b, buf[MAXPATHLEN];
354
355 /* Check for the file's existence. */
356 if (stat(path, sbp))
357 return (NOEXIST);
358
359 /* Check ownership permissions. */
360 euid = geteuid();
361 if (!(rootown && sbp->st_uid == 0) &&
362 !(rootid && euid == 0) && sbp->st_uid != euid) {
363 etype = rootown ? ROOTOWN : OWN;
364 goto denied;
365 }
366
367 /* Check writeability. */
368 if (sbp->st_mode & (S_IWGRP | S_IWOTH)) {
369 etype = WRITER;
370 goto denied;
371 }
372 return (RCOK);
373
374 denied: a = msg_print(sp, path, &nf1);
375 if (strchr(path, '/') == NULL && getcwd(buf, sizeof(buf)) != NULL) {
376 b = msg_print(sp, buf, &nf2);
377 switch (etype) {
378 case ROOTOWN:
379 msgq(sp, M_ERR,
380 "125|%s/%s: not sourced: not owned by you or root",
381 b, a);
382 break;
383 case OWN:
384 msgq(sp, M_ERR,
385 "126|%s/%s: not sourced: not owned by you", b, a);
386 break;
387 case WRITER:
388 msgq(sp, M_ERR,
389 "127|%s/%s: not sourced: writeable by a user other than the owner", b, a);
390 break;
391 }
392 if (nf2)
393 FREE_SPACE(sp, b, 0);
394 } else
395 switch (etype) {
396 case ROOTOWN:
397 msgq(sp, M_ERR,
398 "128|%s: not sourced: not owned by you or root", a);
399 break;
400 case OWN:
401 msgq(sp, M_ERR,
402 "129|%s: not sourced: not owned by you", a);
403 break;
404 case WRITER:
405 msgq(sp, M_ERR,
406 "130|%s: not sourced: writeable by a user other than the owner", a);
407 break;
408 }
409
410 if (nf1)
411 FREE_SPACE(sp, a, 0);
412 return (NOPERM);
413 }
414