git.saurik.com Git - apple/shell_cmds.git/blob

1 /*-

2 * SPDX-License-Identifier: BSD-3-Clause

3 *

6 *

7 * This code is derived from software contributed to Berkeley by

8 * Kenneth Almquist.

9 *

10 * Redistribution and use in source and binary forms, with or without

11 * modification, are permitted provided that the following conditions

12 * are met:

13 * 1. Redistributions of source code must retain the above copyright

14 * notice, this list of conditions and the following disclaimer.

15 * 2. Redistributions in binary form must reproduce the above copyright

16 * notice, this list of conditions and the following disclaimer in the

17 * documentation and/or other materials provided with the distribution.

18 * 3. Neither the name of the University nor the names of its contributors

19 * may be used to endorse or promote products derived from this software

20 * without specific prior written permission.

21 *

22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

32 * SUCH DAMAGE.

33 */

35 #ifndef lint

36 #if 0

37 static char sccsid[] = "@(#)redir.c 8.2 (Berkeley) 5/4/95";

38 #endif

39 #endif /* not lint */

40 #include <sys/cdefs.h>

41 __FBSDID("$FreeBSD: head/bin/sh/redir.c 326025 2017-11-20 19:49:47Z pfg $");

43 #include <sys/types.h>

44 #include <sys/stat.h>

45 #include <signal.h>

46 #include <string.h>

47 #include <fcntl.h>

48 #include <errno.h>

49 #include <unistd.h>

50 #include <stdlib.h>

52 /*

53 * Code for dealing with input/output redirection.

54 */

56 #include "shell.h"

57 #include "nodes.h"

58 #include "jobs.h"

59 #include "expand.h"

60 #include "redir.h"

61 #include "output.h"

62 #include "memalloc.h"

63 #include "error.h"

64 #include "options.h"

67 #define EMPTY -2 /* marks an unused slot in redirtab */

68 #define CLOSED -1 /* fd was not open before redir */

71 struct redirtab {

72 struct redirtab *next;

73 int renamed[10];

74 int fd0_redirected;

75 unsigned int empty_redirs;

76 };

79 static struct redirtab *redirlist;

81 /*

82 * We keep track of whether or not fd0 has been redirected. This is for

83 * background commands, where we want to redirect fd0 to /dev/null only

84 * if it hasn't already been redirected.

85 */

86 static int fd0_redirected = 0;

88 /* Number of redirtabs that have not been allocated. */

89 static unsigned int empty_redirs = 0;

 static void openredirect(union node *, char[10 ]);

 static int openhere(union node *);

95 /*

96 * Process a list of redirection commands. If the REDIR_PUSH flag is set,

97 * old file descriptors are stashed away so that the redirection can be

98 * undone by calling popredir. If the REDIR_BACKQ flag is set, then the

99 * standard output, and the standard error if it becomes a duplicate of

100 * stdout, is saved in memory.

101 *

102 * We suppress interrupts so that we won't leave open file

103 * descriptors around. Because the signal handler remains

104 * installed and we do not use system call restart, interrupts

105 * will still abort blocking opens such as fifos (they will fail

106 * with EINTR). There is, however, a race condition if an interrupt

107 * arrives after INTOFF and before open blocks.

108 */

109

110 void

 redirect(union node *redir, int flags)

112 {

113 union node *n;

114 struct redirtab *sv = NULL;

115 int i;

116 int fd;

         char memory[10];        /* file descriptors to write to memory */

118

119 INTOFF;

         for (i = 10 ; --i >= 0 ; )

121 memory[i] = 0;

         memory[1] = flags & REDIR_BACKQ;

123 if (flags & REDIR_PUSH) {

124 empty_redirs++;

125 if (redir != NULL) {

                         sv = ckmalloc(sizeof (struct redirtab));

                         for (i = 0 ; i < 10 ; i++)

128 sv->renamed[i] = EMPTY;

129 sv->fd0_redirected = fd0_redirected;

                         sv->empty_redirs = empty_redirs - 1;

131 sv->next = redirlist;

132 redirlist = sv;

133 empty_redirs = 0;

134 }

135 }

         for (n = redir ; n ; n = n->nfile.next) {

137 fd = n->nfile.fd;

                 if (fd == 0)

139 fd0_redirected = 1;

                 if ((n->nfile.type == NTOFD || n->nfile.type == NFROMFD) &&

141 n->ndup.dupfd == fd)

142 continue; /* redirect from/to same file descriptor */

143

                 if ((flags & REDIR_PUSH) && sv->renamed[fd] == EMPTY) {

145 INTOFF;

                         if ((i = fcntl(fd, F_DUPFD_CLOEXEC, 10)) == -1) {

147 switch (errno) {

148 case EBADF:

149 i = CLOSED;

150 break;

151 default:

152 INTON;

                                         error("%d: %s", fd, strerror(errno));

154 break;

155 }

156 }

157 sv->renamed[fd] = i;

158 INTON;

159 }

160 openredirect(n, memory);

161 INTON;

162 INTOFF;

163 }

         if (memory[1])

165 out1 = &memout;

         if (memory[2])

167 out2 = &memout;

168 INTON;

169 }

170

171

172 static void

 openredirect(union node *redir, char memory[10])

174 {

175 struct stat sb;

         int fd = redir->nfile.fd;

177 const char *fname;

178 int f;

179 int e;

180

181 memory[fd] = 0;

         switch (redir->nfile.type) {

183 case NFROM:

184 fname = redir->nfile.expfname;

                 if ((f = open(fname, O_RDONLY)) < 0)

                         error("cannot open %s: %s", fname, strerror(errno));

187 break;

188 case NFROMTO:

189 fname = redir->nfile.expfname;

                 if ((f = open(fname, O_RDWR|O_CREAT, 0666)) < 0)

                         error("cannot create %s: %s", fname, strerror(errno));

192 break;

193 case NTO:

194 if (Cflag) {

195 fname = redir->nfile.expfname;

                         if (stat(fname, &sb) == -1) {

                                 if ((f = open(fname, O_WRONLY|O_CREAT|O_EXCL, 0666)) < 0)

                                         error("cannot create %s: %s", fname, strerror(errno));

                         } else if (!S_ISREG(sb.st_mode)) {

                                 if ((f = open(fname, O_WRONLY, 0666)) < 0)

                                         error("cannot create %s: %s", fname, strerror(errno));

                                 if (fstat(f, &sb) != -1 && S_ISREG(sb.st_mode)) {

203 close(f);

                                         error("cannot create %s: %s", fname,

205 strerror(EEXIST));

206 }

207 } else

                                 error("cannot create %s: %s", fname,

209 strerror(EEXIST));

210 break;

211 }

212 /* FALLTHROUGH */

213 case NCLOBBER:

214 fname = redir->nfile.expfname;

                 if ((f = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)

                         error("cannot create %s: %s", fname, strerror(errno));

217 break;

218 case NAPPEND:

219 fname = redir->nfile.expfname;

                 if ((f = open(fname, O_WRONLY|O_CREAT|O_APPEND, 0666)) < 0)

                         error("cannot create %s: %s", fname, strerror(errno));

222 break;

223 case NTOFD:

224 case NFROMFD:

                 if (redir->ndup.dupfd >= 0) {   /* if not ">&-" */

                         if (memory[redir->ndup.dupfd])

227 memory[fd] = 1;

228 else {

                                 if (dup2(redir->ndup.dupfd, fd) < 0)

                                         error("%d: %s", redir->ndup.dupfd,

231 strerror(errno));

232 }

233 } else {

234 close(fd);

235 }

236 return;

237 case NHERE:

238 case NXHERE:

239 f = openhere(redir);

240 break;

241 default:

242 abort();

243 }

244 if (f != fd) {

                 if (dup2(f, fd) == -1) {

246 e = errno;

247 close(f);

                         error("%d: %s", fd, strerror(e));

249 }

250 close(f);

251 }

252 }

253

254

255 /*

256 * Handle here documents. Normally we fork off a process to write the

257 * data to a pipe. If the document is short, we can stuff the data in

258 * the pipe without forking.

259 */

260

261 static int

 openhere(union node *redir)

263 {

264 const char *p;

265 int pip[2];

266 size_t len = 0;

267 int flags;

268 ssize_t written = 0;

269

         if (pipe(pip) < 0)

                 error("Pipe call failed: %s", strerror(errno));

272

         if (redir->type == NXHERE)

274 p = redir->nhere.expdoc;

275 else

                 p = redir->nhere.doc->narg.text;

277 len = strlen(p);

         if (len == 0)

279 goto out;

         flags = fcntl(pip[1], F_GETFL, 0);

         if (flags != -1 && fcntl(pip[1], F_SETFL, flags | O_NONBLOCK) != -1) {

                 written = write(pip[1], p, len);

                 if (written < 0)

284 written = 0;

                 if ((size_t)written == len)

286 goto out;

                 fcntl(pip[1], F_SETFL, flags);

288 }

289

         if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {

                 close(pip[0]);

292 signal(SIGINT, SIG_IGN);

293 signal(SIGQUIT, SIG_IGN);

294 signal(SIGHUP, SIG_IGN);

295 signal(SIGTSTP, SIG_IGN);

296 signal(SIGPIPE, SIG_DFL);

                 xwrite(pip[1], p + written, len - written);

298 _exit(0);

299 }

300 out:

         close(pip[1]);

302 return pip[0];

303 }

304

305

306

307 /*

308 * Undo the effects of the last redirection.

309 */

310

311 void

312 popredir(void)

313 {

314 struct redirtab *rp = redirlist;

315 int i;

316

317 INTOFF;

         if (empty_redirs > 0) {

319 empty_redirs--;

320 INTON;

321 return;

322 }

         for (i = 0 ; i < 10 ; i++) {

                 if (rp->renamed[i] != EMPTY) {

                         if (rp->renamed[i] >= 0) {

                                 dup2(rp->renamed[i], i);

                                 close(rp->renamed[i]);

328 } else {

329 close(i);

330 }

331 }

332 }

333 fd0_redirected = rp->fd0_redirected;

334 empty_redirs = rp->empty_redirs;

335 redirlist = rp->next;

336 ckfree(rp);

337 INTON;

338 }

339

340 /* Return true if fd 0 has already been redirected at least once. */

341 int

342 fd0_redirected_p(void)

343 {

344 return fd0_redirected != 0;

345 }

346

347 /*

348 * Discard all saved file descriptors.

349 */

350

351 void

352 clearredir(void)

353 {

354 struct redirtab *rp;

355 int i;

356

         for (rp = redirlist ; rp ; rp = rp->next) {

                 for (i = 0 ; i < 10 ; i++) {

                         if (rp->renamed[i] >= 0) {

                                 close(rp->renamed[i]);

361 }

362 rp->renamed[i] = EMPTY;

363 }

364 }

365 }