mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
248 lines
8.7 KiB
C
248 lines
8.7 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
|
||
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
|
||
╞══════════════════════════════════════════════════════════════════════════════╡
|
||
│ Copyright 2021 Justine Alexandra Roberts Tunney │
|
||
│ │
|
||
│ Permission to use, copy, modify, and/or distribute this software for │
|
||
│ any purpose with or without fee is hereby granted, provided that the │
|
||
│ above copyright notice and this permission notice appear in all copies. │
|
||
│ │
|
||
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
||
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
||
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
||
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
||
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
||
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
||
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
||
│ PERFORMANCE OF THIS SOFTWARE. │
|
||
╚─────────────────────────────────────────────────────────────────────────────*/
|
||
#include "libc/proc/ntspawn.h"
|
||
#include "libc/calls/struct/sigset.internal.h"
|
||
#include "libc/calls/syscall_support-nt.internal.h"
|
||
#include "libc/intrin/strace.internal.h"
|
||
#include "libc/nt/createfile.h"
|
||
#include "libc/nt/enum/accessmask.h"
|
||
#include "libc/nt/enum/creationdisposition.h"
|
||
#include "libc/nt/enum/fileflagandattributes.h"
|
||
#include "libc/nt/enum/filesharemode.h"
|
||
#include "libc/nt/enum/processaccess.h"
|
||
#include "libc/nt/enum/processcreationflags.h"
|
||
#include "libc/nt/errors.h"
|
||
#include "libc/nt/events.h"
|
||
#include "libc/nt/files.h"
|
||
#include "libc/nt/memory.h"
|
||
#include "libc/nt/process.h"
|
||
#include "libc/nt/runtime.h"
|
||
#include "libc/nt/startupinfo.h"
|
||
#include "libc/nt/struct/processinformation.h"
|
||
#include "libc/nt/struct/procthreadattributelist.h"
|
||
#include "libc/nt/struct/startupinfo.h"
|
||
#include "libc/nt/struct/startupinfoex.h"
|
||
#include "libc/proc/ntspawn.h"
|
||
#include "libc/stdalign.internal.h"
|
||
#include "libc/str/str.h"
|
||
#include "libc/sysv/errfuns.h"
|
||
#ifdef __x86_64__
|
||
|
||
struct SpawnBlock {
|
||
char16_t path[PATH_MAX];
|
||
char16_t cmdline[32767];
|
||
char16_t envblock[32767];
|
||
char envbuf[32767];
|
||
};
|
||
|
||
static textwindows void *ntspawn_malloc(size_t size) {
|
||
return HeapAlloc(GetProcessHeap(), 0, size);
|
||
}
|
||
|
||
static textwindows void ntspawn_free(void *ptr) {
|
||
HeapFree(GetProcessHeap(), 0, ptr);
|
||
}
|
||
|
||
static textwindows ssize_t ntspawn_read(intptr_t fh, char *buf, size_t len) {
|
||
bool ok;
|
||
uint32_t got;
|
||
struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0)};
|
||
ok = (ReadFile(fh, buf, len, 0, &overlap) ||
|
||
GetLastError() == kNtErrorIoPending) &&
|
||
GetOverlappedResult(fh, &overlap, &got, true);
|
||
CloseHandle(overlap.hEvent);
|
||
return ok ? got : -1;
|
||
}
|
||
|
||
static textwindows int ntspawn2(struct NtSpawnArgs *a, struct SpawnBlock *sb) {
|
||
|
||
// make executable path
|
||
if (__mkntpathath(a->dirhand, a->prog, 0, sb->path) == -1)
|
||
return -1;
|
||
|
||
// open executable
|
||
char *p = sb->envbuf;
|
||
char *pe = p + sizeof(sb->envbuf);
|
||
intptr_t fh = CreateFile(
|
||
sb->path, kNtFileGenericRead,
|
||
kNtFileShareRead | kNtFileShareWrite | kNtFileShareDelete, 0,
|
||
kNtOpenExisting, kNtFileAttributeNormal | kNtFileFlagBackupSemantics, 0);
|
||
if (fh == -1)
|
||
return -1;
|
||
ssize_t got = ntspawn_read(fh, p, pe - p);
|
||
CloseHandle(fh);
|
||
if (got < 3)
|
||
return enoexec();
|
||
pe = p + got;
|
||
|
||
// handle shebang
|
||
size_t i = 0; // represents space of sb->cmdline consumed
|
||
if (p[0] == 'M' && p[1] == 'Z') {
|
||
// it's a windows executable
|
||
} else if (p[0] == '#' && p[1] == '!') {
|
||
p += 2;
|
||
// make sure we got a complete first line
|
||
pe = memchr(p, '\n', pe - p);
|
||
if (!pe)
|
||
return enoexec();
|
||
*pe = 0;
|
||
int argc = 0;
|
||
char *argv[4];
|
||
// it's legal to say "#! /bin/sh"
|
||
while (p < pe && (*p == ' ' || *p == '\t'))
|
||
++p;
|
||
if (p == pe)
|
||
return enoexec();
|
||
argv[argc++] = p;
|
||
// find the optional argument
|
||
while (p < pe && !(*p == ' ' || *p == '\t'))
|
||
++p;
|
||
if (p < pe) {
|
||
*p++ = 0;
|
||
while (p < pe && (*p == ' ' || *p == '\t'))
|
||
++p;
|
||
if (p < pe) {
|
||
argv[argc++] = p;
|
||
}
|
||
}
|
||
// now add the prog
|
||
argv[argc++] = (char *)a->prog;
|
||
argv[argc] = 0;
|
||
// ignore argv[0]
|
||
if (*a->argv)
|
||
++a->argv;
|
||
// prepend arguments
|
||
if ((i += mkntcmdline(sb->cmdline + i, argv, 32767 - i)) >= 32767 - 1)
|
||
return e2big();
|
||
sb->cmdline[i++] = ' ';
|
||
sb->cmdline[i] = 0;
|
||
// setup the true executable path
|
||
if (__mkntpathath(a->dirhand, argv[0], 0, sb->path) == -1)
|
||
return -1;
|
||
} else {
|
||
// it's something else
|
||
return enoexec();
|
||
}
|
||
|
||
// setup arguments and environment
|
||
if ((i += mkntcmdline(sb->cmdline + i, a->argv, 32767 - i)) >= 32767)
|
||
return e2big();
|
||
if (mkntenvblock(sb->envblock, a->envp, a->extravars, sb->envbuf) == -1)
|
||
return -1;
|
||
|
||
// create attribute list
|
||
// this code won't call malloc in practice
|
||
bool32 ok;
|
||
void *freeme = 0;
|
||
alignas(16) char memory[128];
|
||
size_t size = sizeof(memory);
|
||
struct NtProcThreadAttributeList *alist = (void *)memory;
|
||
uint32_t items = !!a->opt_hParentProcess + !!a->opt_lpExplicitHandleList;
|
||
ok = InitializeProcThreadAttributeList(alist, items, 0, &size);
|
||
if (!ok && GetLastError() == kNtErrorInsufficientBuffer) {
|
||
ok = !!(alist = freeme = ntspawn_malloc(size));
|
||
if (ok) {
|
||
ok = InitializeProcThreadAttributeList(alist, items, 0, &size);
|
||
}
|
||
}
|
||
if (ok && a->opt_hParentProcess) {
|
||
ok = UpdateProcThreadAttribute(
|
||
alist, 0, kNtProcThreadAttributeParentProcess, &a->opt_hParentProcess,
|
||
sizeof(a->opt_hParentProcess), 0, 0);
|
||
}
|
||
if (ok && a->opt_lpExplicitHandleList) {
|
||
ok = UpdateProcThreadAttribute(
|
||
alist, 0, kNtProcThreadAttributeHandleList, a->opt_lpExplicitHandleList,
|
||
a->dwExplicitHandleCount * sizeof(*a->opt_lpExplicitHandleList), 0, 0);
|
||
}
|
||
|
||
// create the process
|
||
int rc;
|
||
if (ok) {
|
||
struct NtStartupInfoEx info = {
|
||
.StartupInfo = *a->lpStartupInfo,
|
||
.StartupInfo.cb = sizeof(info),
|
||
.lpAttributeList = alist,
|
||
};
|
||
if (ok) {
|
||
if (CreateProcess(sb->path, sb->cmdline, 0, 0, true,
|
||
a->dwCreationFlags | kNtCreateUnicodeEnvironment |
|
||
kNtExtendedStartupinfoPresent |
|
||
kNtInheritParentAffinity |
|
||
GetPriorityClass(GetCurrentProcess()),
|
||
sb->envblock, a->opt_lpCurrentDirectory,
|
||
&info.StartupInfo, a->opt_out_lpProcessInformation)) {
|
||
rc = 0;
|
||
} else {
|
||
rc = -1;
|
||
STRACE("CreateProcess() failed w/ %d", GetLastError());
|
||
if (GetLastError() == kNtErrorSharingViolation) {
|
||
etxtbsy();
|
||
} else if (GetLastError() == kNtErrorInvalidName) {
|
||
enoent();
|
||
}
|
||
}
|
||
rc = __fix_enotdir(rc, sb->path);
|
||
}
|
||
} else {
|
||
rc = __winerr();
|
||
}
|
||
|
||
// clean up resources
|
||
if (alist)
|
||
DeleteProcThreadAttributeList(alist);
|
||
if (freeme)
|
||
ntspawn_free(freeme);
|
||
return rc;
|
||
}
|
||
|
||
/**
|
||
* Spawns process on Windows NT.
|
||
*
|
||
* This function delegates to CreateProcess() with UTF-8 → UTF-16
|
||
* translation and argv escaping. Please note this will NOT escape
|
||
* command interpreter syntax.
|
||
*
|
||
* @param prog won't be PATH searched
|
||
* @param argv specifies prog arguments
|
||
* @param envp[𝟶,m-2] specifies "foo=bar" environment variables, which
|
||
* don't need to be passed in sorted order; however, this function
|
||
* goes faster the closer they are to sorted
|
||
* @param envp[m-1] is NULL
|
||
* @param extravars is added to envp to avoid setenv() in caller
|
||
* @param opt_out_lpProcessInformation can be used to return process and
|
||
* thread IDs to parent, as well as open handles that need close()
|
||
* @return 0 on success, or -1 w/ errno
|
||
* @see spawnve() which abstracts this function
|
||
* @asyncsignalsafe
|
||
*/
|
||
textwindows int ntspawn(struct NtSpawnArgs *args) {
|
||
int rc;
|
||
struct SpawnBlock *sb;
|
||
BLOCK_SIGNALS;
|
||
if ((sb = ntspawn_malloc(sizeof(*sb)))) {
|
||
rc = ntspawn2(args, sb);
|
||
} else {
|
||
rc = -1;
|
||
}
|
||
ALLOW_SIGNALS;
|
||
return rc;
|
||
}
|
||
|
||
#endif /* __x86_64__ */
|