1 | /* $Id: shinstance.c 2303 2009-03-01 07:25:29Z bird $ */
|
---|
2 | /** @file
|
---|
3 | * The shell instance methods.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (c) 2007-2009 knut st. osmundsen <bird-kBuild-spamix@anduin.net>
|
---|
8 | *
|
---|
9 | *
|
---|
10 | * This file is part of kBuild.
|
---|
11 | *
|
---|
12 | * kBuild is free software; you can redistribute it and/or modify
|
---|
13 | * it under the terms of the GNU General Public License as published by
|
---|
14 | * the Free Software Foundation; either version 2 of the License, or
|
---|
15 | * (at your option) any later version.
|
---|
16 | *
|
---|
17 | * kBuild is distributed in the hope that it will be useful,
|
---|
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
20 | * GNU General Public License for more details.
|
---|
21 | *
|
---|
22 | * You should have received a copy of the GNU General Public License
|
---|
23 | * along with kBuild; if not, write to the Free Software
|
---|
24 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
---|
25 | *
|
---|
26 | */
|
---|
27 |
|
---|
28 | /*******************************************************************************
|
---|
29 | * Header Files *
|
---|
30 | *******************************************************************************/
|
---|
31 | #include <string.h>
|
---|
32 | #include <stdlib.h>
|
---|
33 | #include <assert.h>
|
---|
34 | #ifdef _MSC_VER
|
---|
35 | # include <process.h>
|
---|
36 | #else
|
---|
37 | # include <unistd.h>
|
---|
38 | # include <pwd.h>
|
---|
39 | #endif
|
---|
40 | #if K_OS == K_OS_WINDOWS
|
---|
41 | # include <Windows.h>
|
---|
42 | #endif
|
---|
43 | #include "shinstance.h"
|
---|
44 |
|
---|
45 | #if K_OS == K_OS_WINDOWS
|
---|
46 | extern pid_t shfork_do_it(shinstance *psh); /* shforkA-win.asm */
|
---|
47 | #endif
|
---|
48 |
|
---|
49 |
|
---|
50 | /*******************************************************************************
|
---|
51 | * Global Variables *
|
---|
52 | *******************************************************************************/
|
---|
53 | /** The mutex protecting the the globals and some shell instance members (sigs). */
|
---|
54 | static shmtx g_sh_mtx;
|
---|
55 | /** The root shell instance. */
|
---|
56 | static shinstance *g_sh_root;
|
---|
57 | /** The first shell instance. */
|
---|
58 | static shinstance *g_sh_head;
|
---|
59 | /** The last shell instance. */
|
---|
60 | static shinstance *g_sh_tail;
|
---|
61 | /** The number of shells. */
|
---|
62 | static int volatile g_num_shells;
|
---|
63 | /** Per signal state for determining a common denominator.
|
---|
64 | * @remarks defaults and unmasked actions aren't counted. */
|
---|
65 | struct shsigstate
|
---|
66 | {
|
---|
67 | /** The current signal action. */
|
---|
68 | #ifndef _MSC_VER
|
---|
69 | struct sigaction sa;
|
---|
70 | #else
|
---|
71 | struct
|
---|
72 | {
|
---|
73 | void (*sa_handler)(int);
|
---|
74 | int sa_flags;
|
---|
75 | shsigset_t sa_mask;
|
---|
76 | } sa;
|
---|
77 | #endif
|
---|
78 | /** The number of restarts (siginterrupt / SA_RESTART). */
|
---|
79 | int num_restart;
|
---|
80 | /** The number of ignore handlers. */
|
---|
81 | int num_ignore;
|
---|
82 | /** The number of specific handlers. */
|
---|
83 | int num_specific;
|
---|
84 | /** The number of threads masking it. */
|
---|
85 | int num_masked;
|
---|
86 | } g_sig_state[NSIG];
|
---|
87 |
|
---|
88 |
|
---|
89 |
|
---|
90 | int shmtx_init(shmtx *pmtx)
|
---|
91 | {
|
---|
92 | pmtx->b[0] = 0;
|
---|
93 | return 0;
|
---|
94 | }
|
---|
95 |
|
---|
96 | void shmtx_delete(shmtx *pmtx)
|
---|
97 | {
|
---|
98 | pmtx->b[0] = 0;
|
---|
99 | }
|
---|
100 |
|
---|
101 | void shmtx_enter(shmtx *pmtx, shmtxtmp *ptmp)
|
---|
102 | {
|
---|
103 | pmtx->b[0] = 0;
|
---|
104 | ptmp->i = 0;
|
---|
105 | }
|
---|
106 |
|
---|
107 | void shmtx_leave(shmtx *pmtx, shmtxtmp *ptmp)
|
---|
108 | {
|
---|
109 | pmtx->b[0] = 0;
|
---|
110 | ptmp->i = 432;
|
---|
111 | }
|
---|
112 |
|
---|
113 | /**
|
---|
114 | * Links the shell instance.
|
---|
115 | *
|
---|
116 | * @param psh The shell.
|
---|
117 | */
|
---|
118 | static void sh_int_link(shinstance *psh)
|
---|
119 | {
|
---|
120 | shmtxtmp tmp;
|
---|
121 | shmtx_enter(&g_sh_mtx, &tmp);
|
---|
122 |
|
---|
123 | if (psh->rootshell)
|
---|
124 | g_sh_root = psh;
|
---|
125 |
|
---|
126 | psh->next = NULL;
|
---|
127 | psh->prev = g_sh_tail;
|
---|
128 | if (g_sh_tail)
|
---|
129 | g_sh_tail->next = psh;
|
---|
130 | else
|
---|
131 | g_sh_tail = g_sh_head = psh;
|
---|
132 | g_sh_tail = psh;
|
---|
133 |
|
---|
134 | g_num_shells++;
|
---|
135 |
|
---|
136 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
137 | }
|
---|
138 |
|
---|
139 | #if 0
|
---|
140 | /**
|
---|
141 | * Unlink the shell instance.
|
---|
142 | *
|
---|
143 | * @param psh The shell.
|
---|
144 | */
|
---|
145 | static void sh_int_unlink(shinstance *psh)
|
---|
146 | {
|
---|
147 | shmtxtmp tmp;
|
---|
148 | shmtx_enter(&g_sh_mtx, &tmp);
|
---|
149 |
|
---|
150 | g_num_shells--;
|
---|
151 |
|
---|
152 | if (g_sh_tail == psh)
|
---|
153 | g_sh_tail = psh->prev;
|
---|
154 | else
|
---|
155 | psh->next->prev = psh->prev;
|
---|
156 |
|
---|
157 | if (g_sh_head == psh)
|
---|
158 | g_sh_head = psh->next;
|
---|
159 | else
|
---|
160 | psh->prev->next = psh->next;
|
---|
161 |
|
---|
162 | if (g_sh_root == psh)
|
---|
163 | g_sh_root = 0;
|
---|
164 |
|
---|
165 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
166 | }
|
---|
167 | #endif
|
---|
168 |
|
---|
169 | /**
|
---|
170 | * Destroys the shell instance.
|
---|
171 | *
|
---|
172 | * This will work on partially initialized instances (because I'm lazy).
|
---|
173 | *
|
---|
174 | * @param psh The shell instance to be destroyed.
|
---|
175 | */
|
---|
176 | static void sh_destroy(shinstance *psh)
|
---|
177 | {
|
---|
178 | memset(psh, 0, sizeof(*psh));
|
---|
179 | sh_free(NULL, psh);
|
---|
180 | }
|
---|
181 |
|
---|
182 | /**
|
---|
183 | * Clones a string vector like enviorn or argv.
|
---|
184 | *
|
---|
185 | * @returns 0 on success, -1 and errno on failure.
|
---|
186 | * @param psh The shell to associate the allocations with.
|
---|
187 | * @param dstp Where to store the clone.
|
---|
188 | * @param src The vector to be cloned.
|
---|
189 | */
|
---|
190 | static int sh_clone_string_vector(shinstance *psh, char ***dstp, char **src)
|
---|
191 | {
|
---|
192 | char **dst;
|
---|
193 | size_t items;
|
---|
194 |
|
---|
195 | /* count first */
|
---|
196 | items = 0;
|
---|
197 | while (src[items])
|
---|
198 | items++;
|
---|
199 |
|
---|
200 | /* alloc clone array. */
|
---|
201 | *dstp = dst = sh_malloc(psh, sizeof(*dst) * items + 1);
|
---|
202 | if (!dst)
|
---|
203 | return -1;
|
---|
204 |
|
---|
205 | /* copy the items */
|
---|
206 | dst[items] = NULL;
|
---|
207 | while (items-- > 0)
|
---|
208 | {
|
---|
209 | dst[items] = sh_strdup(psh, src[items]);
|
---|
210 | if (!dst[items])
|
---|
211 | {
|
---|
212 | /* allocation error, clean up. */
|
---|
213 | while (dst[++items])
|
---|
214 | sh_free(psh, dst[items]);
|
---|
215 | sh_free(psh, dst);
|
---|
216 | errno = ENOMEM;
|
---|
217 | return -1;
|
---|
218 | }
|
---|
219 | }
|
---|
220 |
|
---|
221 | return 0;
|
---|
222 | }
|
---|
223 |
|
---|
224 | /**
|
---|
225 | * Creates a root shell instance.
|
---|
226 | *
|
---|
227 | * @param inherit The shell to inherit from. If NULL inherit from environment and such.
|
---|
228 | * @param argc The argument count.
|
---|
229 | * @param argv The argument vector.
|
---|
230 | * @param envp The environment vector.
|
---|
231 | *
|
---|
232 | * @returns pointer to root shell on success, NULL on failure.
|
---|
233 | */
|
---|
234 | shinstance *sh_create_root_shell(shinstance *inherit, int argc, char **argv, char **envp)
|
---|
235 | {
|
---|
236 | shinstance *psh;
|
---|
237 | int i;
|
---|
238 |
|
---|
239 | /*
|
---|
240 | * The allocations.
|
---|
241 | */
|
---|
242 | psh = sh_calloc(NULL, sizeof(*psh), 1);
|
---|
243 | if (psh)
|
---|
244 | {
|
---|
245 | /* Init it enought for sh_destroy() to not get upset */
|
---|
246 | /* ... */
|
---|
247 |
|
---|
248 | /* Call the basic initializers. */
|
---|
249 | if ( !sh_clone_string_vector(psh, &psh->shenviron, envp)
|
---|
250 | && !sh_clone_string_vector(psh, &psh->argptr, argv)
|
---|
251 | && !shfile_init(&psh->fdtab, inherit ? &inherit->fdtab : NULL))
|
---|
252 | {
|
---|
253 | /* the special stuff. */
|
---|
254 | #ifdef _MSC_VER
|
---|
255 | psh->pid = _getpid();
|
---|
256 | #else
|
---|
257 | psh->pid = getpid();
|
---|
258 | #endif
|
---|
259 | /*sh_sigemptyset(&psh->sigrestartset);*/
|
---|
260 | for (i = 0; i < NSIG; i++)
|
---|
261 | psh->sigactions[i].sh_handler = SH_SIG_UNK;
|
---|
262 | if (inherit)
|
---|
263 | psh->sigmask = psh->sigmask;
|
---|
264 | else
|
---|
265 | {
|
---|
266 | #if defined(_MSC_VER)
|
---|
267 | sh_sigemptyset(&psh->sigmask);
|
---|
268 | #else
|
---|
269 | sigprocmask(SIG_SETMASK, NULL, &psh->sigmask);
|
---|
270 | #endif
|
---|
271 | }
|
---|
272 |
|
---|
273 | /* memalloc.c */
|
---|
274 | psh->stacknleft = MINSIZE;
|
---|
275 | psh->herefd = -1;
|
---|
276 | psh->stackp = &psh->stackbase;
|
---|
277 | psh->stacknxt = psh->stackbase.space;
|
---|
278 |
|
---|
279 | /* input.c */
|
---|
280 | psh->plinno = 1;
|
---|
281 | psh->init_editline = 0;
|
---|
282 | psh->parsefile = &psh->basepf;
|
---|
283 |
|
---|
284 | /* output.c */
|
---|
285 | psh->output.bufsize = OUTBUFSIZ;
|
---|
286 | psh->output.fd = 1;
|
---|
287 | psh->output.psh = psh;
|
---|
288 | psh->errout.bufsize = 100;
|
---|
289 | psh->errout.fd = 2;
|
---|
290 | psh->errout.psh = psh;
|
---|
291 | psh->memout.fd = MEM_OUT;
|
---|
292 | psh->memout.psh = psh;
|
---|
293 | psh->out1 = &psh->output;
|
---|
294 | psh->out2 = &psh->errout;
|
---|
295 |
|
---|
296 | /* jobs.c */
|
---|
297 | psh->backgndpid = -1;
|
---|
298 | #if JOBS
|
---|
299 | psh->curjob = -1;
|
---|
300 | #else
|
---|
301 | # error asdf
|
---|
302 | #endif
|
---|
303 | psh->ttyfd = -1;
|
---|
304 |
|
---|
305 | /* show.c */
|
---|
306 | psh->tracefd = -1;
|
---|
307 |
|
---|
308 | /* link it. */
|
---|
309 | sh_int_link(psh);
|
---|
310 | return psh;
|
---|
311 | }
|
---|
312 |
|
---|
313 | sh_destroy(psh);
|
---|
314 | }
|
---|
315 | return NULL;
|
---|
316 | }
|
---|
317 |
|
---|
318 | /** getenv() */
|
---|
319 | char *sh_getenv(shinstance *psh, const char *var)
|
---|
320 | {
|
---|
321 | size_t len;
|
---|
322 | int i = 0;
|
---|
323 |
|
---|
324 | if (!var)
|
---|
325 | return NULL;
|
---|
326 |
|
---|
327 | len = strlen(var);
|
---|
328 | i = 0;
|
---|
329 | while (psh->shenviron[i])
|
---|
330 | {
|
---|
331 | const char *item = psh->shenviron[i];
|
---|
332 | if ( !strncmp(item, var, len)
|
---|
333 | && item[len] == '=')
|
---|
334 | return (char *)item + len + 1;
|
---|
335 | }
|
---|
336 |
|
---|
337 | return NULL;
|
---|
338 | }
|
---|
339 |
|
---|
340 | char **sh_environ(shinstance *psh)
|
---|
341 | {
|
---|
342 | return psh->shenviron;
|
---|
343 | }
|
---|
344 |
|
---|
345 | const char *sh_gethomedir(shinstance *psh, const char *user)
|
---|
346 | {
|
---|
347 | const char *ret = NULL;
|
---|
348 |
|
---|
349 | #ifdef _MSC_VER
|
---|
350 | ret = sh_getenv(psh, "HOME");
|
---|
351 | if (!ret)
|
---|
352 | ret = sh_getenv(psh, "USERPROFILE");
|
---|
353 | #else
|
---|
354 | struct passwd *pwd = getpwnam(user); /** @todo use getpwdnam_r */
|
---|
355 | (void)psh;
|
---|
356 | ret = pwd ? pwd->pw_dir : NULL;
|
---|
357 | #endif
|
---|
358 |
|
---|
359 | return ret;
|
---|
360 | }
|
---|
361 |
|
---|
362 | /**
|
---|
363 | * Lazy initialization of a signal state, globally.
|
---|
364 | *
|
---|
365 | * @param psh The shell doing the lazy work.
|
---|
366 | * @param signo The signal (valid).
|
---|
367 | */
|
---|
368 | static void sh_int_lazy_init_sigaction(shinstance *psh, int signo)
|
---|
369 | {
|
---|
370 | if (psh->sigactions[signo].sh_handler == SH_SIG_UNK)
|
---|
371 | {
|
---|
372 | shmtxtmp tmp;
|
---|
373 | shmtx_enter(&g_sh_mtx, &tmp);
|
---|
374 |
|
---|
375 | if (psh->sigactions[signo].sh_handler == SH_SIG_UNK)
|
---|
376 | {
|
---|
377 | shsigaction_t shold;
|
---|
378 | shinstance *cur;
|
---|
379 | #ifndef _MSC_VER
|
---|
380 | struct sigaction old;
|
---|
381 | if (!sigaction(signo, NULL, &old))
|
---|
382 | {
|
---|
383 | /* convert */
|
---|
384 | shold.sh_flags = old.sa_flags;
|
---|
385 | shold.sh_mask = old.sa_mask;
|
---|
386 | if (old.sa_handler == SIG_DFL)
|
---|
387 | shold.sh_handler = SH_SIG_DFL;
|
---|
388 | else
|
---|
389 | {
|
---|
390 | assert(old.sa_handler == SIG_IGN);
|
---|
391 | shold.sh_handler = SH_SIG_IGN;
|
---|
392 | }
|
---|
393 | }
|
---|
394 | else
|
---|
395 | #endif
|
---|
396 | {
|
---|
397 | /* fake */
|
---|
398 | #ifndef _MSC_VER
|
---|
399 | assert(0);
|
---|
400 | old.sa_handler = SIG_DFL;
|
---|
401 | old.sa_flags = 0;
|
---|
402 | sigemptyset(&shold.sh_mask);
|
---|
403 | sigaddset(&shold.sh_mask, signo);
|
---|
404 | #endif
|
---|
405 | shold.sh_flags = 0;
|
---|
406 | sh_sigemptyset(&shold.sh_mask);
|
---|
407 | sh_sigaddset(&shold.sh_mask, signo);
|
---|
408 | shold.sh_handler = SH_SIG_DFL;
|
---|
409 | }
|
---|
410 |
|
---|
411 | /* update globals */
|
---|
412 | #ifndef _MSC_VER
|
---|
413 | g_sig_state[signo].sa = old;
|
---|
414 | #else
|
---|
415 | g_sig_state[signo].sa.sa_handler = SIG_DFL;
|
---|
416 | g_sig_state[signo].sa.sa_flags = 0;
|
---|
417 | g_sig_state[signo].sa.sa_mask = shold.sh_mask;
|
---|
418 | #endif
|
---|
419 | TRACE2((psh, "sh_int_lazy_init_sigaction: signo=%d:%s sa_handler=%p sa_flags=%#x\n",
|
---|
420 | signo, sys_signame[signo], g_sig_state[signo].sa.sa_handler, g_sig_state[signo].sa.sa_flags));
|
---|
421 |
|
---|
422 | /* update all shells */
|
---|
423 | for (cur = g_sh_head; cur; cur = cur->next)
|
---|
424 | {
|
---|
425 | assert(cur->sigactions[signo].sh_handler == SH_SIG_UNK);
|
---|
426 | cur->sigactions[signo] = shold;
|
---|
427 | }
|
---|
428 | }
|
---|
429 |
|
---|
430 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
431 | }
|
---|
432 | }
|
---|
433 |
|
---|
434 | /**
|
---|
435 | * Perform the default signal action on the shell.
|
---|
436 | *
|
---|
437 | * @param psh The shell instance.
|
---|
438 | * @param signo The signal.
|
---|
439 | */
|
---|
440 | static void sh_sig_do_default(shinstance *psh, int signo)
|
---|
441 | {
|
---|
442 | /** @todo */
|
---|
443 | }
|
---|
444 |
|
---|
445 | /**
|
---|
446 | * Deliver a signal to a shell.
|
---|
447 | *
|
---|
448 | * @param psh The shell instance.
|
---|
449 | * @param pshDst The shell instance to signal.
|
---|
450 | * @param signo The signal.
|
---|
451 | * @param locked Whether we're owning the lock or not.
|
---|
452 | */
|
---|
453 | static void sh_sig_do_signal(shinstance *psh, shinstance *pshDst, int signo, int locked)
|
---|
454 | {
|
---|
455 | shsig_t pfn = pshDst->sigactions[signo].sh_handler;
|
---|
456 | if (pfn == SH_SIG_UNK)
|
---|
457 | {
|
---|
458 | sh_int_lazy_init_sigaction(pshDst, signo);
|
---|
459 | pfn = pshDst->sigactions[signo].sh_handler;
|
---|
460 | }
|
---|
461 |
|
---|
462 | if (pfn == SH_SIG_DFL)
|
---|
463 | sh_sig_do_default(pshDst, signo);
|
---|
464 | else if (pfn == SH_SIG_IGN)
|
---|
465 | /* ignore it */;
|
---|
466 | else
|
---|
467 | {
|
---|
468 | assert(pfn != SH_SIG_ERR);
|
---|
469 | pfn(pshDst, signo);
|
---|
470 | }
|
---|
471 | (void)locked;
|
---|
472 | }
|
---|
473 |
|
---|
474 | /**
|
---|
475 | * Handler for external signals.
|
---|
476 | *
|
---|
477 | * @param signo The signal.
|
---|
478 | */
|
---|
479 | static void sh_sig_common_handler(int signo)
|
---|
480 | {
|
---|
481 | shinstance *psh;
|
---|
482 |
|
---|
483 | fprintf(stderr, "sh_sig_common_handler: signo=%d:%s\n", signo, sys_signame[signo]);
|
---|
484 |
|
---|
485 | /*
|
---|
486 | * No need to take locks if there is only one shell.
|
---|
487 | * Since this will be the initial case, just avoid the deadlock
|
---|
488 | * hell for a litte while...
|
---|
489 | */
|
---|
490 | if (g_num_shells <= 1)
|
---|
491 | {
|
---|
492 | psh = g_sh_head;
|
---|
493 | if (psh)
|
---|
494 | sh_sig_do_signal(NULL, psh, signo, 0 /* no lock */);
|
---|
495 | }
|
---|
496 | else
|
---|
497 | {
|
---|
498 | shmtxtmp tmp;
|
---|
499 | shmtx_enter(&g_sh_mtx, &tmp);
|
---|
500 |
|
---|
501 | /** @todo signal focus chain or something? Atm there will only be one shell,
|
---|
502 | * so it's not really important until we go threaded for real... */
|
---|
503 | psh = g_sh_tail;
|
---|
504 | while (psh != NULL)
|
---|
505 | {
|
---|
506 | sh_sig_do_signal(NULL, psh, signo, 1 /* locked */);
|
---|
507 | psh = psh->prev;
|
---|
508 | }
|
---|
509 |
|
---|
510 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
511 | }
|
---|
512 | }
|
---|
513 |
|
---|
514 | int sh_sigaction(shinstance *psh, int signo, const struct shsigaction *newp, struct shsigaction *oldp)
|
---|
515 | {
|
---|
516 | if (newp)
|
---|
517 | TRACE2((psh, "sh_sigaction: signo=%d:%s newp=%p:{.sh_handler=%p, .sh_flags=%#x} oldp=%p\n",
|
---|
518 | signo, sys_signame[signo], newp, newp->sh_handler, newp->sh_flags, oldp));
|
---|
519 | else
|
---|
520 | TRACE2((psh, "sh_sigaction: signo=%d:%s newp=NULL oldp=%p\n", signo, sys_signame[signo], oldp));
|
---|
521 |
|
---|
522 | /*
|
---|
523 | * Input validation.
|
---|
524 | */
|
---|
525 | if (signo >= NSIG || signo <= 0)
|
---|
526 | {
|
---|
527 | errno = EINVAL;
|
---|
528 | return -1;
|
---|
529 | }
|
---|
530 |
|
---|
531 | /*
|
---|
532 | * Make sure our data is correct.
|
---|
533 | */
|
---|
534 | sh_int_lazy_init_sigaction(psh, signo);
|
---|
535 |
|
---|
536 | /*
|
---|
537 | * Get the old one if requested.
|
---|
538 | */
|
---|
539 | if (oldp)
|
---|
540 | *oldp = psh->sigactions[signo];
|
---|
541 |
|
---|
542 | /*
|
---|
543 | * Set the new one if it has changed.
|
---|
544 | *
|
---|
545 | * This will be attempted coordinated with the other signal handlers so
|
---|
546 | * that we can arrive at a common denominator.
|
---|
547 | */
|
---|
548 | if ( newp
|
---|
549 | && memcmp(&psh->sigactions[signo], newp, sizeof(*newp)))
|
---|
550 | {
|
---|
551 | shmtxtmp tmp;
|
---|
552 | shmtx_enter(&g_sh_mtx, &tmp);
|
---|
553 |
|
---|
554 | /* Undo the accounting for the current entry. */
|
---|
555 | if (psh->sigactions[signo].sh_handler == SH_SIG_IGN)
|
---|
556 | g_sig_state[signo].num_ignore--;
|
---|
557 | else if (psh->sigactions[signo].sh_handler != SH_SIG_DFL)
|
---|
558 | g_sig_state[signo].num_specific--;
|
---|
559 | if (psh->sigactions[signo].sh_flags & SA_RESTART)
|
---|
560 | g_sig_state[signo].num_restart--;
|
---|
561 |
|
---|
562 | /* Set the new entry. */
|
---|
563 | psh->sigactions[signo] = *newp;
|
---|
564 |
|
---|
565 | /* Add the bits for the new action entry. */
|
---|
566 | if (psh->sigactions[signo].sh_handler == SH_SIG_IGN)
|
---|
567 | g_sig_state[signo].num_ignore++;
|
---|
568 | else if (psh->sigactions[signo].sh_handler != SH_SIG_DFL)
|
---|
569 | g_sig_state[signo].num_specific++;
|
---|
570 | if (psh->sigactions[signo].sh_flags & SA_RESTART)
|
---|
571 | g_sig_state[signo].num_restart++;
|
---|
572 |
|
---|
573 | /*
|
---|
574 | * Calc new common action.
|
---|
575 | *
|
---|
576 | * This is quit a bit ASSUMPTIVE about the limited use. We will not
|
---|
577 | * bother synching the mask, and we pretend to care about SA_RESTART.
|
---|
578 | * The only thing we really actually care about is the sh_handler.
|
---|
579 | *
|
---|
580 | * On second though, it's possible we should just tie this to the root
|
---|
581 | * shell since it only really applies to external signal ...
|
---|
582 | */
|
---|
583 | if ( g_sig_state[signo].num_specific
|
---|
584 | || g_sig_state[signo].num_ignore != g_num_shells)
|
---|
585 | g_sig_state[signo].sa.sa_handler = sh_sig_common_handler;
|
---|
586 | else if (g_sig_state[signo].num_ignore)
|
---|
587 | g_sig_state[signo].sa.sa_handler = SIG_IGN;
|
---|
588 | else
|
---|
589 | g_sig_state[signo].sa.sa_handler = SIG_DFL;
|
---|
590 | g_sig_state[signo].sa.sa_flags = psh->sigactions[signo].sh_flags & SA_RESTART;
|
---|
591 |
|
---|
592 | TRACE2((psh, "sh_sigaction: setting signo=%d:%s to {.sa_handler=%p, .sa_flags=%#x}\n",
|
---|
593 | signo, sys_signame[signo], g_sig_state[signo].sa.sa_handler, g_sig_state[signo].sa.sa_flags));
|
---|
594 | #ifdef _MSC_VER
|
---|
595 | if (signal(signo, g_sig_state[signo].sa.sa_handler) == SIG_ERR)
|
---|
596 | #else
|
---|
597 | if (sigaction(signo, &g_sig_state[signo].sa, NULL))
|
---|
598 | #endif
|
---|
599 | assert(0);
|
---|
600 |
|
---|
601 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
602 | }
|
---|
603 |
|
---|
604 | return 0;
|
---|
605 | }
|
---|
606 |
|
---|
607 | shsig_t sh_signal(shinstance *psh, int signo, shsig_t handler)
|
---|
608 | {
|
---|
609 | shsigaction_t sa;
|
---|
610 | shsig_t ret;
|
---|
611 |
|
---|
612 | /*
|
---|
613 | * Implementation using sh_sigaction.
|
---|
614 | */
|
---|
615 | if (sh_sigaction(psh, signo, NULL, &sa))
|
---|
616 | return SH_SIG_ERR;
|
---|
617 |
|
---|
618 | ret = sa.sh_handler;
|
---|
619 | sa.sh_flags &= SA_RESTART;
|
---|
620 | sa.sh_handler = handler;
|
---|
621 | sh_sigemptyset(&sa.sh_mask);
|
---|
622 | sh_sigaddset(&sa.sh_mask, signo); /* ?? */
|
---|
623 | if (sh_sigaction(psh, signo, &sa, NULL))
|
---|
624 | return SH_SIG_ERR;
|
---|
625 |
|
---|
626 | return ret;
|
---|
627 | }
|
---|
628 |
|
---|
629 | int sh_siginterrupt(shinstance *psh, int signo, int interrupt)
|
---|
630 | {
|
---|
631 | shsigaction_t sa;
|
---|
632 | int oldflags = 0;
|
---|
633 |
|
---|
634 | /*
|
---|
635 | * Implementation using sh_sigaction.
|
---|
636 | */
|
---|
637 | if (sh_sigaction(psh, signo, NULL, &sa))
|
---|
638 | return -1;
|
---|
639 | oldflags = sa.sh_flags;
|
---|
640 | if (interrupt)
|
---|
641 | sa.sh_flags &= ~SA_RESTART;
|
---|
642 | else
|
---|
643 | sa.sh_flags |= ~SA_RESTART;
|
---|
644 | if (!((oldflags ^ sa.sh_flags) & SA_RESTART))
|
---|
645 | return 0; /* unchanged. */
|
---|
646 |
|
---|
647 | return sh_sigaction(psh, signo, &sa, NULL);
|
---|
648 | }
|
---|
649 |
|
---|
650 | void sh_sigemptyset(shsigset_t *setp)
|
---|
651 | {
|
---|
652 | memset(setp, 0, sizeof(*setp));
|
---|
653 | }
|
---|
654 |
|
---|
655 | void sh_sigfillset(shsigset_t *setp)
|
---|
656 | {
|
---|
657 | memset(setp, 0xff, sizeof(*setp));
|
---|
658 | }
|
---|
659 |
|
---|
660 | void sh_sigaddset(shsigset_t *setp, int signo)
|
---|
661 | {
|
---|
662 | #ifdef _MSC_VER
|
---|
663 | *setp |= 1U << signo;
|
---|
664 | #else
|
---|
665 | sigaddset(setp, signo);
|
---|
666 | #endif
|
---|
667 | }
|
---|
668 |
|
---|
669 | void sh_sigdelset(shsigset_t *setp, int signo)
|
---|
670 | {
|
---|
671 | #ifdef _MSC_VER
|
---|
672 | *setp &= ~(1U << signo);
|
---|
673 | #else
|
---|
674 | sigdelset(setp, signo);
|
---|
675 | #endif
|
---|
676 | }
|
---|
677 |
|
---|
678 | int sh_sigismember(shsigset_t const *setp, int signo)
|
---|
679 | {
|
---|
680 | #ifdef _MSC_VER
|
---|
681 | return !!(*setp & (1U << signo));
|
---|
682 | #else
|
---|
683 | return !!sigismember(setp, signo);
|
---|
684 | #endif
|
---|
685 | }
|
---|
686 |
|
---|
687 | int sh_sigprocmask(shinstance *psh, int operation, shsigset_t const *newp, shsigset_t *oldp)
|
---|
688 | {
|
---|
689 | int rc;
|
---|
690 |
|
---|
691 | if ( operation != SIG_BLOCK
|
---|
692 | && operation != SIG_UNBLOCK
|
---|
693 | && operation != SIG_SETMASK)
|
---|
694 | {
|
---|
695 | errno = EINVAL;
|
---|
696 | return -1;
|
---|
697 | }
|
---|
698 |
|
---|
699 | #if defined(SH_FORKED_MODE) && !defined(_MSC_VER)
|
---|
700 | rc = sigprocmask(operation, newp, oldp);
|
---|
701 | if (!rc && newp)
|
---|
702 | psh->sigmask = *newp;
|
---|
703 |
|
---|
704 | #else
|
---|
705 | if (oldp)
|
---|
706 | *oldp = psh->sigmask;
|
---|
707 | if (newp)
|
---|
708 | {
|
---|
709 | /* calc the new mask */
|
---|
710 | shsigset_t mask = psh->sigmask;
|
---|
711 | switch (operation)
|
---|
712 | {
|
---|
713 | case SIG_BLOCK:
|
---|
714 | for (rc = 0; rc < NSIG; rc++)
|
---|
715 | if (sh_sigismember(newp, rc))
|
---|
716 | sh_sigaddset(&mask, rc);
|
---|
717 | break;
|
---|
718 | case SIG_UNBLOCK:
|
---|
719 | for (rc = 0; rc < NSIG; rc++)
|
---|
720 | if (sh_sigismember(newp, rc))
|
---|
721 | sh_sigdelset(&mask, rc);
|
---|
722 | break;
|
---|
723 | case SIG_SETMASK:
|
---|
724 | mask = *newp;
|
---|
725 | break;
|
---|
726 | }
|
---|
727 |
|
---|
728 | # if defined(_MSC_VER)
|
---|
729 | rc = 0;
|
---|
730 | # else
|
---|
731 | rc = sigprocmask(operation, &mask, NULL);
|
---|
732 | if (!rc)
|
---|
733 | # endif
|
---|
734 | psh->sigmask = mask;
|
---|
735 | }
|
---|
736 |
|
---|
737 | #endif
|
---|
738 | return rc;
|
---|
739 | }
|
---|
740 |
|
---|
741 | SH_NORETURN_1 void sh_abort(shinstance *psh)
|
---|
742 | {
|
---|
743 | shsigset_t set;
|
---|
744 | TRACE2((psh, "sh_abort\n"));
|
---|
745 |
|
---|
746 | /* block other async signals */
|
---|
747 | sh_sigfillset(&set);
|
---|
748 | sh_sigdelset(&set, SIGABRT);
|
---|
749 | sh_sigprocmask(psh, SIG_SETMASK, &set, NULL);
|
---|
750 |
|
---|
751 | sh_sig_do_signal(psh, psh, SIGABRT, 0 /* no lock */);
|
---|
752 |
|
---|
753 | /** @todo die in a nicer manner. */
|
---|
754 | *(char *)1 = 3;
|
---|
755 |
|
---|
756 | TRACE2((psh, "sh_abort returns!\n"));
|
---|
757 | (void)psh;
|
---|
758 | abort();
|
---|
759 | }
|
---|
760 |
|
---|
761 | void sh_raise_sigint(shinstance *psh)
|
---|
762 | {
|
---|
763 | TRACE2((psh, "sh_raise(SIGINT)\n"));
|
---|
764 |
|
---|
765 | sh_sig_do_signal(psh, psh, SIGINT, 0 /* no lock */);
|
---|
766 |
|
---|
767 | TRACE2((psh, "sh_raise(SIGINT) returns\n"));
|
---|
768 | }
|
---|
769 |
|
---|
770 | int sh_kill(shinstance *psh, pid_t pid, int signo)
|
---|
771 | {
|
---|
772 | shinstance *pshDst;
|
---|
773 | shmtxtmp tmp;
|
---|
774 | int rc;
|
---|
775 |
|
---|
776 | /*
|
---|
777 | * Self or any of the subshells?
|
---|
778 | */
|
---|
779 | shmtx_enter(&g_sh_mtx, &tmp);
|
---|
780 |
|
---|
781 | pshDst = g_sh_tail;
|
---|
782 | while (pshDst != NULL)
|
---|
783 | {
|
---|
784 | if (pshDst->pid == pid)
|
---|
785 | {
|
---|
786 | TRACE2((psh, "sh_kill(%d, %d): pshDst=%p\n", pid, signo, pshDst));
|
---|
787 | sh_sig_do_signal(psh, pshDst, signo, 1 /* locked */);
|
---|
788 |
|
---|
789 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
790 | return 0;
|
---|
791 | }
|
---|
792 | pshDst = pshDst->prev;
|
---|
793 | }
|
---|
794 |
|
---|
795 | shmtx_leave(&g_sh_mtx, &tmp);
|
---|
796 |
|
---|
797 | /*
|
---|
798 | * Some other process, call kill where possible
|
---|
799 | */
|
---|
800 | #if defined(SH_FORKED_MODE)
|
---|
801 | # ifdef _MSC_VER
|
---|
802 | errno = ENOSYS;
|
---|
803 | rc = -1;
|
---|
804 | # else
|
---|
805 | fprintf(stderr, "kill(%d, %d)\n", pid, signo);
|
---|
806 | rc = kill(pid, signo);
|
---|
807 | # endif
|
---|
808 |
|
---|
809 | #else
|
---|
810 | #endif
|
---|
811 |
|
---|
812 | TRACE2((psh, "sh_kill(%d, %d) -> %d [%d]\n", pid, signo, rc, errno));
|
---|
813 | return rc;
|
---|
814 | }
|
---|
815 |
|
---|
816 | int sh_killpg(shinstance *psh, pid_t pgid, int signo)
|
---|
817 | {
|
---|
818 | int rc;
|
---|
819 |
|
---|
820 | #if defined(SH_FORKED_MODE)
|
---|
821 | # ifdef _MSC_VER
|
---|
822 | errno = ENOSYS;
|
---|
823 | rc = -1;
|
---|
824 | # else
|
---|
825 | //fprintf(stderr, "killpg(%d, %d)\n", pgid, signo);
|
---|
826 | rc = killpg(pgid, signo);
|
---|
827 | # endif
|
---|
828 |
|
---|
829 | #else
|
---|
830 | #endif
|
---|
831 |
|
---|
832 | TRACE2((psh, "sh_killpg(%d, %d) -> %d [%d]\n", pgid, signo, rc, errno));
|
---|
833 | (void)psh;
|
---|
834 | return rc;
|
---|
835 | }
|
---|
836 |
|
---|
837 | clock_t sh_times(shinstance *psh, shtms *tmsp)
|
---|
838 | {
|
---|
839 | #if defined(SH_FORKED_MODE)
|
---|
840 | (void)psh;
|
---|
841 | # ifdef _MSC_VER
|
---|
842 | errno = ENOSYS;
|
---|
843 | return (clock_t)-1;
|
---|
844 | # else
|
---|
845 | return times(tmsp);
|
---|
846 | # endif
|
---|
847 |
|
---|
848 | #else
|
---|
849 | #endif
|
---|
850 | }
|
---|
851 |
|
---|
852 | int sh_sysconf_clk_tck(void)
|
---|
853 | {
|
---|
854 | #ifdef _MSC_VER
|
---|
855 | return CLK_TCK;
|
---|
856 | #else
|
---|
857 | return sysconf(_SC_CLK_TCK);
|
---|
858 | #endif
|
---|
859 | }
|
---|
860 |
|
---|
861 | /**
|
---|
862 | * Adds a child to the shell
|
---|
863 | *
|
---|
864 | * @returns 0 on success, on failure -1 and errno set to ENOMEM.
|
---|
865 | *
|
---|
866 | * @param psh The shell instance.
|
---|
867 | * @param pid The child pid.
|
---|
868 | * @param hChild Windows child handle.
|
---|
869 | */
|
---|
870 | int sh_add_child(shinstance *psh, pid_t pid, void *hChild)
|
---|
871 | {
|
---|
872 | /* get a free table entry. */
|
---|
873 | int i = psh->num_children++;
|
---|
874 | if (!(i % 32))
|
---|
875 | {
|
---|
876 | void *ptr = sh_realloc(psh, psh->children, sizeof(*psh->children) * (i + 32));
|
---|
877 | if (!ptr)
|
---|
878 | {
|
---|
879 | psh->num_children--;
|
---|
880 | errno = ENOMEM;
|
---|
881 | return -1;
|
---|
882 | }
|
---|
883 | psh->children = ptr;
|
---|
884 | }
|
---|
885 |
|
---|
886 | /* add it */
|
---|
887 | psh->children[i].pid = pid;
|
---|
888 | #if K_OS == K_OS_WINDOWS
|
---|
889 | psh->children[i].hChild = hChild;
|
---|
890 | #endif
|
---|
891 | (void)hChild;
|
---|
892 | return 0;
|
---|
893 | }
|
---|
894 | #include <setjmp.h>
|
---|
895 |
|
---|
896 | pid_t sh_fork(shinstance *psh)
|
---|
897 | {
|
---|
898 | pid_t pid;
|
---|
899 | TRACE2((psh, "sh_fork\n"));
|
---|
900 |
|
---|
901 | #if K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
|
---|
902 | pid = shfork_do_it(psh);
|
---|
903 |
|
---|
904 | #elif defined(SH_FORKED_MODE)
|
---|
905 | # ifdef _MSC_VER
|
---|
906 | pid = -1;
|
---|
907 | errno = ENOSYS;
|
---|
908 | # else
|
---|
909 | pid = fork();
|
---|
910 | # endif
|
---|
911 |
|
---|
912 | #else
|
---|
913 |
|
---|
914 | #endif
|
---|
915 |
|
---|
916 | /* child: update the pid */
|
---|
917 | if (!pid)
|
---|
918 | # ifdef _MSC_VER
|
---|
919 | psh->pid = _getpid();
|
---|
920 | # else
|
---|
921 | psh->pid = getpid();
|
---|
922 | # endif
|
---|
923 |
|
---|
924 | TRACE2((psh, "sh_fork -> %d [%d]\n", pid, errno));
|
---|
925 | (void)psh;
|
---|
926 | return pid;
|
---|
927 | }
|
---|
928 |
|
---|
929 | /** waitpid() */
|
---|
930 | pid_t sh_waitpid(shinstance *psh, pid_t pid, int *statusp, int flags)
|
---|
931 | {
|
---|
932 | pid_t pidret;
|
---|
933 | #if K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
|
---|
934 | DWORD dwRet;
|
---|
935 | HANDLE hChild = INVALID_HANDLE_VALUE;
|
---|
936 | int i;
|
---|
937 |
|
---|
938 | *statusp = 0;
|
---|
939 | pidret = -1;
|
---|
940 | if (pid != -1)
|
---|
941 | {
|
---|
942 | /*
|
---|
943 | * A specific child, try look it up in the child process table
|
---|
944 | * and wait for it.
|
---|
945 | */
|
---|
946 | for (i = 0; i < psh->num_children; i++)
|
---|
947 | if (psh->children[i].pid == pid)
|
---|
948 | break;
|
---|
949 | if (i < psh->num_children)
|
---|
950 | {
|
---|
951 | dwRet = WaitForSingleObject(psh->children[i].hChild,
|
---|
952 | flags & WNOHANG ? 0 : INFINITE);
|
---|
953 | if (dwRet == WAIT_OBJECT_0)
|
---|
954 | hChild = psh->children[i].hChild;
|
---|
955 | else if (dwRet == WAIT_TIMEOUT)
|
---|
956 | {
|
---|
957 | i = -1; /* don't try close anything */
|
---|
958 | pidret = 0;
|
---|
959 | }
|
---|
960 | else
|
---|
961 | errno = ECHILD;
|
---|
962 | }
|
---|
963 | else
|
---|
964 | errno = ECHILD;
|
---|
965 | }
|
---|
966 | else if (psh->num_children <= MAXIMUM_WAIT_OBJECTS)
|
---|
967 | {
|
---|
968 | HANDLE ahChildren[64];
|
---|
969 | for (i = 0; i < psh->num_children; i++)
|
---|
970 | ahChildren[i] = psh->children[i].hChild;
|
---|
971 | dwRet = WaitForMultipleObjects(psh->num_children, &ahChildren[0],
|
---|
972 | FALSE,
|
---|
973 | flags & WNOHANG ? 0 : INFINITE);
|
---|
974 | i = dwRet - WAIT_OBJECT_0;
|
---|
975 | if ((unsigned)i < (unsigned)psh->num_children)
|
---|
976 | {
|
---|
977 | hChild = psh->children[i].hChild;
|
---|
978 | }
|
---|
979 | else if (dwRet == WAIT_TIMEOUT)
|
---|
980 | {
|
---|
981 | i = -1; /* don't try close anything */
|
---|
982 | pidret = 0;
|
---|
983 | }
|
---|
984 | else
|
---|
985 | {
|
---|
986 | i = -1; /* don't try close anything */
|
---|
987 | errno = EINVAL;
|
---|
988 | }
|
---|
989 | }
|
---|
990 | else
|
---|
991 | {
|
---|
992 | fprintf(stderr, "panic! too many children!\n");
|
---|
993 | i = -1;
|
---|
994 | *(char *)1 = '\0'; /** @todo implement this! */
|
---|
995 | }
|
---|
996 |
|
---|
997 | /*
|
---|
998 | * Close the handle, and if we succeeded collect the exit code first.
|
---|
999 | */
|
---|
1000 | if ( i >= 0
|
---|
1001 | && i < psh->num_children)
|
---|
1002 | {
|
---|
1003 | if (hChild != INVALID_HANDLE_VALUE)
|
---|
1004 | {
|
---|
1005 | DWORD dwExitCode = 127;
|
---|
1006 | if (GetExitCodeProcess(hChild, &dwExitCode))
|
---|
1007 | {
|
---|
1008 | pidret = psh->children[i].pid;
|
---|
1009 | if (dwExitCode && !W_EXITCODE(dwExitCode, 0))
|
---|
1010 | dwExitCode |= 16;
|
---|
1011 | *statusp = W_EXITCODE(dwExitCode, 0);
|
---|
1012 | }
|
---|
1013 | else
|
---|
1014 | errno = EINVAL;
|
---|
1015 | }
|
---|
1016 |
|
---|
1017 | /* remove and close */
|
---|
1018 | hChild = psh->children[i].hChild;
|
---|
1019 | psh->num_children--;
|
---|
1020 | if (i < psh->num_children)
|
---|
1021 | psh->children[i] = psh->children[psh->num_children];
|
---|
1022 | i = CloseHandle(hChild); assert(i);
|
---|
1023 | }
|
---|
1024 |
|
---|
1025 | #elif defined(SH_FORKED_MODE)
|
---|
1026 | *statusp = 0;
|
---|
1027 | # ifdef _MSC_VER
|
---|
1028 | pidret = -1;
|
---|
1029 | errno = ENOSYS;
|
---|
1030 | # else
|
---|
1031 | pidret = waitpid(pid, statusp, flags);
|
---|
1032 | # endif
|
---|
1033 |
|
---|
1034 | #else
|
---|
1035 | #endif
|
---|
1036 |
|
---|
1037 | TRACE2((psh, "waitpid(%d, %p, %#x) -> %d [%d] *statusp=%#x (rc=%d)\n", pid, statusp, flags,
|
---|
1038 | pidret, errno, *statusp, WEXITSTATUS(*statusp)));
|
---|
1039 | (void)psh;
|
---|
1040 | return pidret;
|
---|
1041 | }
|
---|
1042 |
|
---|
1043 | SH_NORETURN_1 void sh__exit(shinstance *psh, int rc)
|
---|
1044 | {
|
---|
1045 | TRACE2((psh, "sh__exit(%d)\n", rc));
|
---|
1046 | (void)psh;
|
---|
1047 |
|
---|
1048 | #if defined(SH_FORKED_MODE)
|
---|
1049 | _exit(rc);
|
---|
1050 |
|
---|
1051 | #else
|
---|
1052 | #endif
|
---|
1053 | }
|
---|
1054 |
|
---|
1055 | int sh_execve(shinstance *psh, const char *exe, const char * const *argv, const char * const *envp)
|
---|
1056 | {
|
---|
1057 | int rc;
|
---|
1058 |
|
---|
1059 | #ifdef DEBUG
|
---|
1060 | /* log it all */
|
---|
1061 | TRACE2((psh, "sh_execve(%p:{%s}, %p, %p}\n", exe, exe, argv, envp));
|
---|
1062 | for (rc = 0; argv[rc]; rc++)
|
---|
1063 | TRACE2((psh, " argv[%d]=%p:{%s}\n", rc, argv[rc], argv[rc]));
|
---|
1064 | #endif
|
---|
1065 |
|
---|
1066 | if (!envp)
|
---|
1067 | envp = sh_environ(psh);
|
---|
1068 |
|
---|
1069 | #if defined(SH_FORKED_MODE) && K_OS != K_OS_WINDOWS
|
---|
1070 | # ifdef _MSC_VER
|
---|
1071 | errno = 0;
|
---|
1072 | {
|
---|
1073 | intptr_t rc2 = _spawnve(_P_WAIT, exe, (char **)argv, (char **)envp);
|
---|
1074 | if (rc2 != -1)
|
---|
1075 | {
|
---|
1076 | TRACE2((psh, "sh_execve: child exited, rc=%d. (errno=%d)\n", rc, errno));
|
---|
1077 | rc = (int)rc2;
|
---|
1078 | if (!rc && rc2)
|
---|
1079 | rc = 16;
|
---|
1080 | exit(rc);
|
---|
1081 | }
|
---|
1082 | }
|
---|
1083 | rc = -1;
|
---|
1084 | # else
|
---|
1085 | rc = execve(exe, (char **)argv, (char **)envp);
|
---|
1086 | # endif
|
---|
1087 |
|
---|
1088 | #else
|
---|
1089 | # if K_OS == K_OS_WINDOWS
|
---|
1090 | {
|
---|
1091 | /*
|
---|
1092 | * This ain't quite straight forward on Windows...
|
---|
1093 | */
|
---|
1094 | PROCESS_INFORMATION ProcInfo;
|
---|
1095 | STARTUPINFO StrtInfo;
|
---|
1096 | intptr_t hndls[3];
|
---|
1097 | char *cwd = shfile_getcwd(&psh->fdtab, NULL, 0);
|
---|
1098 | char *cmdline;
|
---|
1099 | size_t cmdline_size;
|
---|
1100 | char *envblock;
|
---|
1101 | size_t env_size;
|
---|
1102 | char *p;
|
---|
1103 | int i;
|
---|
1104 |
|
---|
1105 | /* Create the environment block. */
|
---|
1106 | if (!envp)
|
---|
1107 | envp = sh_environ(psh);
|
---|
1108 | env_size = 2;
|
---|
1109 | for (i = 0; envp[i]; i++)
|
---|
1110 | env_size += strlen(envp[i]) + 1;
|
---|
1111 | envblock = p = sh_malloc(psh, env_size);
|
---|
1112 | for (i = 0; envp[i]; i++)
|
---|
1113 | {
|
---|
1114 | size_t len = strlen(envp[i]) + 1;
|
---|
1115 | memcpy(p, envp[i], len);
|
---|
1116 | p += len;
|
---|
1117 | }
|
---|
1118 | *p = '\0';
|
---|
1119 |
|
---|
1120 | /* Create the command line. */
|
---|
1121 | cmdline_size = 2;
|
---|
1122 | for (i = 0; argv[i]; i++)
|
---|
1123 | cmdline_size += strlen(argv[i]) + 3;
|
---|
1124 | cmdline = p = sh_malloc(psh, env_size);
|
---|
1125 | for (i = 0; argv[i]; i++)
|
---|
1126 | {
|
---|
1127 | size_t len = strlen(argv[i]);
|
---|
1128 | int quoted = !!strpbrk(argv[i], " \t"); /** @todo Do this quoting business right. */
|
---|
1129 | if (i != 0)
|
---|
1130 | *(p++) = ' ';
|
---|
1131 | if (quoted)
|
---|
1132 | *(p++) = '"';
|
---|
1133 | memcpy(p, argv[i], len);
|
---|
1134 | p += len;
|
---|
1135 | if (quoted)
|
---|
1136 | *(p++) = '"';
|
---|
1137 | }
|
---|
1138 | p[0] = p[1] = '\0';
|
---|
1139 |
|
---|
1140 | /* Init the info structure */
|
---|
1141 | memset(&StrtInfo, '\0', sizeof(StrtInfo));
|
---|
1142 | StrtInfo.cb = sizeof(StrtInfo);
|
---|
1143 |
|
---|
1144 | /* File handles. */
|
---|
1145 | StrtInfo.lpReserved2 = shfile_exec_win(&psh->fdtab, 1 /* prepare */, &StrtInfo.cbReserved2, hndls);
|
---|
1146 | StrtInfo.hStdInput = (HANDLE)hndls[0];
|
---|
1147 | StrtInfo.hStdOutput = (HANDLE)hndls[1];
|
---|
1148 | StrtInfo.hStdError = (HANDLE)hndls[2];
|
---|
1149 |
|
---|
1150 | /* Get going... */
|
---|
1151 | if (CreateProcess(exe,
|
---|
1152 | cmdline,
|
---|
1153 | NULL, /* pProcessAttributes */
|
---|
1154 | NULL, /* pThreadAttributes */
|
---|
1155 | TRUE, /* bInheritHandles */
|
---|
1156 | 0, /* dwCreationFlags */
|
---|
1157 | envblock,
|
---|
1158 | cwd,
|
---|
1159 | &StrtInfo,
|
---|
1160 | &ProcInfo))
|
---|
1161 | {
|
---|
1162 | DWORD dwErr;
|
---|
1163 | DWORD dwExitCode;
|
---|
1164 |
|
---|
1165 | CloseHandle(ProcInfo.hThread);
|
---|
1166 | dwErr = WaitForSingleObject(ProcInfo.hProcess, INFINITE);
|
---|
1167 | assert(dwErr == WAIT_OBJECT_0);
|
---|
1168 |
|
---|
1169 | if (GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
|
---|
1170 | {
|
---|
1171 | CloseHandle(ProcInfo.hProcess);
|
---|
1172 | _exit(dwExitCode);
|
---|
1173 | }
|
---|
1174 | errno = EINVAL;
|
---|
1175 | }
|
---|
1176 |
|
---|
1177 | shfile_exec_win(&psh->fdtab, 0 /* done */, NULL, NULL);
|
---|
1178 | }
|
---|
1179 | rc = -1;
|
---|
1180 |
|
---|
1181 | # else
|
---|
1182 | errno = ENOSYS;
|
---|
1183 | rc = -1;
|
---|
1184 | # endif
|
---|
1185 | #endif
|
---|
1186 |
|
---|
1187 | TRACE2((psh, "sh_execve -> %d [%d]\n", rc, errno));
|
---|
1188 | (void)psh;
|
---|
1189 | return (int)rc;
|
---|
1190 | }
|
---|
1191 |
|
---|
1192 | uid_t sh_getuid(shinstance *psh)
|
---|
1193 | {
|
---|
1194 | #if defined(SH_FORKED_MODE)
|
---|
1195 | # ifdef _MSC_VER
|
---|
1196 | uid_t uid = 0;
|
---|
1197 | # else
|
---|
1198 | uid_t uid = getuid();
|
---|
1199 | # endif
|
---|
1200 |
|
---|
1201 | #else
|
---|
1202 | #endif
|
---|
1203 |
|
---|
1204 | TRACE2((psh, "sh_getuid() -> %d [%d]\n", uid, errno));
|
---|
1205 | (void)psh;
|
---|
1206 | return uid;
|
---|
1207 | }
|
---|
1208 |
|
---|
1209 | uid_t sh_geteuid(shinstance *psh)
|
---|
1210 | {
|
---|
1211 | #if defined(SH_FORKED_MODE)
|
---|
1212 | # ifdef _MSC_VER
|
---|
1213 | uid_t euid = 0;
|
---|
1214 | # else
|
---|
1215 | uid_t euid = geteuid();
|
---|
1216 | # endif
|
---|
1217 |
|
---|
1218 | #else
|
---|
1219 | #endif
|
---|
1220 |
|
---|
1221 | TRACE2((psh, "sh_geteuid() -> %d [%d]\n", euid, errno));
|
---|
1222 | (void)psh;
|
---|
1223 | return euid;
|
---|
1224 | }
|
---|
1225 |
|
---|
1226 | gid_t sh_getgid(shinstance *psh)
|
---|
1227 | {
|
---|
1228 | #if defined(SH_FORKED_MODE)
|
---|
1229 | # ifdef _MSC_VER
|
---|
1230 | gid_t gid = 0;
|
---|
1231 | # else
|
---|
1232 | gid_t gid = getgid();
|
---|
1233 | # endif
|
---|
1234 |
|
---|
1235 | #else
|
---|
1236 | #endif
|
---|
1237 |
|
---|
1238 | TRACE2((psh, "sh_getgid() -> %d [%d]\n", gid, errno));
|
---|
1239 | (void)psh;
|
---|
1240 | return gid;
|
---|
1241 | }
|
---|
1242 |
|
---|
1243 | gid_t sh_getegid(shinstance *psh)
|
---|
1244 | {
|
---|
1245 | #if defined(SH_FORKED_MODE)
|
---|
1246 | # ifdef _MSC_VER
|
---|
1247 | gid_t egid = 0;
|
---|
1248 | # else
|
---|
1249 | gid_t egid = getegid();
|
---|
1250 | # endif
|
---|
1251 |
|
---|
1252 | #else
|
---|
1253 | #endif
|
---|
1254 |
|
---|
1255 | TRACE2((psh, "sh_getegid() -> %d [%d]\n", egid, errno));
|
---|
1256 | (void)psh;
|
---|
1257 | return egid;
|
---|
1258 | }
|
---|
1259 |
|
---|
1260 | pid_t sh_getpid(shinstance *psh)
|
---|
1261 | {
|
---|
1262 | pid_t pid;
|
---|
1263 |
|
---|
1264 | #if defined(SH_FORKED_MODE)
|
---|
1265 | # ifdef _MSC_VER
|
---|
1266 | pid = _getpid();
|
---|
1267 | # else
|
---|
1268 | pid = getpid();
|
---|
1269 | # endif
|
---|
1270 | #else
|
---|
1271 | #endif
|
---|
1272 |
|
---|
1273 | (void)psh;
|
---|
1274 | return pid;
|
---|
1275 | }
|
---|
1276 |
|
---|
1277 | pid_t sh_getpgrp(shinstance *psh)
|
---|
1278 | {
|
---|
1279 | #if defined(SH_FORKED_MODE)
|
---|
1280 | # ifdef _MSC_VER
|
---|
1281 | pid_t pgrp = _getpid();
|
---|
1282 | # else
|
---|
1283 | pid_t pgrp = getpgrp();
|
---|
1284 | # endif
|
---|
1285 |
|
---|
1286 | #else
|
---|
1287 | #endif
|
---|
1288 |
|
---|
1289 | TRACE2((psh, "sh_getpgrp() -> %d [%d]\n", pgrp, errno));
|
---|
1290 | (void)psh;
|
---|
1291 | return pgrp;
|
---|
1292 | }
|
---|
1293 |
|
---|
1294 | pid_t sh_getpgid(shinstance *psh, pid_t pid)
|
---|
1295 | {
|
---|
1296 | #if defined(SH_FORKED_MODE)
|
---|
1297 | # ifdef _MSC_VER
|
---|
1298 | pid_t pgid = pid;
|
---|
1299 | # else
|
---|
1300 | pid_t pgid = getpgid(pid);
|
---|
1301 | # endif
|
---|
1302 |
|
---|
1303 | #else
|
---|
1304 | #endif
|
---|
1305 |
|
---|
1306 | TRACE2((psh, "sh_getpgid(%d) -> %d [%d]\n", pid, pgid, errno));
|
---|
1307 | (void)psh;
|
---|
1308 | return pgid;
|
---|
1309 | }
|
---|
1310 |
|
---|
1311 | int sh_setpgid(shinstance *psh, pid_t pid, pid_t pgid)
|
---|
1312 | {
|
---|
1313 | #if defined(SH_FORKED_MODE)
|
---|
1314 | # ifdef _MSC_VER
|
---|
1315 | int rc = -1;
|
---|
1316 | errno = ENOSYS;
|
---|
1317 | # else
|
---|
1318 | int rc = setpgid(pid, pgid);
|
---|
1319 | # endif
|
---|
1320 |
|
---|
1321 | #else
|
---|
1322 | #endif
|
---|
1323 |
|
---|
1324 | TRACE2((psh, "sh_setpgid(%d, %d) -> %d [%d]\n", pid, pgid, rc, errno));
|
---|
1325 | (void)psh;
|
---|
1326 | return rc;
|
---|
1327 | }
|
---|
1328 |
|
---|
1329 | pid_t sh_tcgetpgrp(shinstance *psh, int fd)
|
---|
1330 | {
|
---|
1331 | pid_t pgrp;
|
---|
1332 |
|
---|
1333 | #if defined(SH_FORKED_MODE)
|
---|
1334 | # ifdef _MSC_VER
|
---|
1335 | pgrp = -1;
|
---|
1336 | errno = ENOSYS;
|
---|
1337 | # else
|
---|
1338 | pgrp = tcgetpgrp(fd);
|
---|
1339 | # endif
|
---|
1340 |
|
---|
1341 | #else
|
---|
1342 | #endif
|
---|
1343 |
|
---|
1344 | TRACE2((psh, "sh_tcgetpgrp(%d) -> %d [%d]\n", fd, pgrp, errno));
|
---|
1345 | (void)psh;
|
---|
1346 | return pgrp;
|
---|
1347 | }
|
---|
1348 |
|
---|
1349 | int sh_tcsetpgrp(shinstance *psh, int fd, pid_t pgrp)
|
---|
1350 | {
|
---|
1351 | int rc;
|
---|
1352 | TRACE2((psh, "sh_tcsetpgrp(%d, %d)\n", fd, pgrp));
|
---|
1353 |
|
---|
1354 | #if defined(SH_FORKED_MODE)
|
---|
1355 | # ifdef _MSC_VER
|
---|
1356 | rc = -1;
|
---|
1357 | errno = ENOSYS;
|
---|
1358 | # else
|
---|
1359 | rc = tcsetpgrp(fd, pgrp);
|
---|
1360 | # endif
|
---|
1361 |
|
---|
1362 | #else
|
---|
1363 | #endif
|
---|
1364 |
|
---|
1365 | TRACE2((psh, "sh_tcsetpgrp(%d, %d) -> %d [%d]\n", fd, pgrp, rc, errno));
|
---|
1366 | (void)psh;
|
---|
1367 | return rc;
|
---|
1368 | }
|
---|
1369 |
|
---|
1370 | int sh_getrlimit(shinstance *psh, int resid, shrlimit *limp)
|
---|
1371 | {
|
---|
1372 | #if defined(SH_FORKED_MODE)
|
---|
1373 | # ifdef _MSC_VER
|
---|
1374 | int rc = -1;
|
---|
1375 | errno = ENOSYS;
|
---|
1376 | # else
|
---|
1377 | int rc = getrlimit(resid, limp);
|
---|
1378 | # endif
|
---|
1379 |
|
---|
1380 | #else
|
---|
1381 | /* returned the stored limit */
|
---|
1382 | #endif
|
---|
1383 |
|
---|
1384 | TRACE2((psh, "sh_getrlimit(%d, %p) -> %d [%d] {%ld,%ld}\n",
|
---|
1385 | resid, limp, rc, errno, (long)limp->rlim_cur, (long)limp->rlim_max));
|
---|
1386 | (void)psh;
|
---|
1387 | return rc;
|
---|
1388 | }
|
---|
1389 |
|
---|
1390 | int sh_setrlimit(shinstance *psh, int resid, const shrlimit *limp)
|
---|
1391 | {
|
---|
1392 | #if defined(SH_FORKED_MODE)
|
---|
1393 | # ifdef _MSC_VER
|
---|
1394 | int rc = -1;
|
---|
1395 | errno = ENOSYS;
|
---|
1396 | # else
|
---|
1397 | int rc = setrlimit(resid, limp);
|
---|
1398 | # endif
|
---|
1399 |
|
---|
1400 | #else
|
---|
1401 | /* if max(shell) < limp; then setrlimit; fi
|
---|
1402 | if success; then store limit for later retrival and maxing. */
|
---|
1403 |
|
---|
1404 | #endif
|
---|
1405 |
|
---|
1406 | TRACE2((psh, "sh_setrlimit(%d, %p:{%ld,%ld}) -> %d [%d]\n",
|
---|
1407 | resid, limp, (long)limp->rlim_cur, (long)limp->rlim_max, rc, errno));
|
---|
1408 | (void)psh;
|
---|
1409 | return rc;
|
---|
1410 | }
|
---|
1411 |
|
---|