const char *
vp_dlopen(char *args)
{
vp_stack_t stack;
char *path;
void *handle;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));
handle = dlopen(path, RTLD_LAZY);
if (handle == NULL)
return dlerror();
vp_stack_push_num(&_result, "%p", handle);
return vp_stack_return(&_result);
}
const char *
vp_waitpid(char *args)
{
vp_stack_t stack;
HANDLE handle;
DWORD exitcode;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));
if (!GetExitCodeProcess(handle, &exitcode))
return vp_stack_return_error(&_result,
"GetExitCodeProcess() error: %s", lasterror());
vp_stack_push_str(&_result, (exitcode == STILL_ACTIVE) ? "run" : "exit");
vp_stack_push_num(&_result, "%u", exitcode);
return vp_stack_return(&_result);
}
const char *
vp_socket_write(char *args)
{
vp_stack_t stack;
int sock;
char *buf;
size_t size;
int timeout;
struct timeval tv;
size_t nleft;
int n;
fd_set fdset;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sock));
VP_RETURN_IF_FAIL(vp_stack_pop_bin(&stack, &buf, &size));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));
tv.tv_sec = timeout / 1000;
tv.tv_usec = (timeout - tv.tv_sec * 1000) * 1000;
FD_ZERO(&fdset);
FD_SET((unsigned)sock, &fdset);
nleft = 0;
while (nleft < size) {
n = select(0, NULL, &fdset, NULL, (timeout == -1) ? NULL : &tv);
if (n == SOCKET_ERROR) {
return vp_stack_return_error(&_result, "select() error: %d",
WSAGetLastError());
} else if (n == 0) {
/* timeout */
break;
}
n = send(sock, buf + nleft, (int)(size - nleft), 0);
if (n == -1)
return vp_stack_return_error(&_result, "send() error: %s",
strerror(errno));
nleft += n;
/* try write more bytes without waiting */
timeout = 0;
}
vp_stack_push_num(&_result, "%u", nleft);
return vp_stack_return(&_result);
}
/*
* This is based on socket.diff.gz written by Yasuhiro Matsumoto.
* see: http://marc.theaimsgroup.com/?l=vim-dev&m=105289857008664&w=2
*/
const char *
vp_socket_open(char *args)
{
vp_stack_t stack;
char *host;
char *port;
char *p;
int n;
unsigned short nport;
int sock;
struct sockaddr_in sockaddr;
struct hostent *hostent;
struct servent *servent;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &host));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &port));
n = strtol(port, &p, 10);
if (p == port + strlen(port)) {
nport = htons(n);
} else {
servent = getservbyname(port, NULL);
if (servent == NULL)
return vp_stack_return_error(&_result, "getservbyname() error: %s",
port);
nport = servent->s_port;
}
sock = socket(PF_INET, SOCK_STREAM, 0);
hostent = gethostbyname(host);
sockaddr.sin_family = AF_INET;
sockaddr.sin_port = nport;
sockaddr.sin_addr = *((struct in_addr*)*hostent->h_addr_list);
if (connect(sock, (struct sockaddr*)&sockaddr, sizeof(struct sockaddr_in))
== -1)
return vp_stack_return_error(&_result, "connect() error: %s",
strerror(errno));
vp_stack_push_num(&_result, "%d", sock);
return vp_stack_return(&_result);
}
const char *
vp_kill(char *args)
{
vp_stack_t stack;
pid_t pid;
int sig;
int ret;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &pid));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sig));
ret = kill(pid, sig);
if (ret < 0)
return vp_stack_return_error(&_result, "kill() error: %s",
strerror(errno));
vp_stack_push_num(&_result, "%d", ret);
return vp_stack_return(&_result);
}
const char *
vp_file_write(char *args)
{
vp_stack_t stack;
int fd;
char *buf;
size_t size;
int timeout;
size_t nleft;
DWORD ret;
int n;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));
VP_RETURN_IF_FAIL(vp_stack_pop_bin(&stack, &buf, &size));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));
nleft = 0;
while (nleft < size) {
ret = WaitForSingleObject((HANDLE)_get_osfhandle(fd), timeout);
if (ret == WAIT_FAILED) {
return vp_stack_return_error(&_result, "WaitForSingleObject() error: %s",
lasterror());
} else if (ret == WAIT_TIMEOUT) {
/* timeout */
break;
}
n = write(fd, buf + nleft, (unsigned int)(size - nleft));
if (n == -1) {
return vp_stack_return_error(&_result, "write() error: %s",
strerror(errno));
}
nleft += n;
/* try write more bytes without waiting */
timeout = 0;
}
vp_stack_push_num(&_result, "%u", nleft);
return vp_stack_return(&_result);
}
const char *
vp_delete_trash(char *args)
{
vp_stack_t stack;
char *filename;
char *buf;
size_t len;
SHFILEOPSTRUCT fs;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &filename));
len = strlen(filename);
buf = malloc(len + 2);
if (buf == NULL) {
return vp_stack_return_error(&_result, "malloc() error: %s",
"Memory cannot allocate");
}
/* Copy filename + '\0\0' */
strcpy(buf, filename);
buf[len + 1] = 0;
ZeroMemory(&fs, sizeof(SHFILEOPSTRUCT));
fs.hwnd = NULL;
fs.wFunc = FO_DELETE;
fs.pFrom = buf;
fs.pTo = NULL;
fs.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;
vp_stack_push_num(&_result, "%d", SHFileOperation(&fs));
free(buf);
return vp_stack_return(&_result);
}
const char *
vp_pty_open(char *args)
{
vp_stack_t stack;
int argc;
int fd[3][2];
pid_t pid;
struct winsize ws = {0, 0, 0, 0};
int dummy;
int hstdin, hstderr, hstdout;
int fdm;
int npipe;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));
if (npipe != 2 && npipe != 3)
return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_col)));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_row)));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));
/* Set pipe */
if (hstdin) {
fd[0][0] = hstdin;
fd[0][1] = 0;
}
if (hstdout == 1) {
if (pipe(fd[1]) < 0) {
return vp_stack_return_error(&_result, "pipe() error: %s",
strerror(errno));
}
} else if (hstdout) {
fd[1][1] = hstdout;
fd[1][0] = 0;
}
if (npipe == 3) {
if (hstderr == 1) {
if (pipe(fd[2]) < 0) {
return vp_stack_return_error(&_result, "pipe() error: %s",
strerror(errno));
}
} else if (hstderr == 1) {
fd[2][1] = hstderr;
fd[2][0] = 0;
} else {
if (openpty(&fd[2][0], &fd[2][1], NULL, NULL, &ws) < 0) {
return vp_stack_return_error(&_result, "openpty() error: %s",
strerror(errno));
}
}
}
pid = forkpty(&fdm, NULL, NULL, &ws);
if (hstdin == 0) {
fd[0][1] = fdm;
}
if (hstdout == 0) {
fd[1][0] = fdm;
}
if (hstdin == 0 && hstdout == 0) {
fd[1][0] = dup(fdm);
}
if (pid < 0) {
return vp_stack_return_error(&_result, "fork() error: %s",
strerror(errno));
} else if (pid == 0) {
/* child */
char **argv;
int i;
/* Close pipe */
if (hstdout == 1) {
close(fd[1][0]);
}
if (npipe == 3 && hstderr == 1) {
close(fd[2][0]);
}
if (hstdin && fd[0][0] != STDIN_FILENO) {
if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {
goto child_error;
}
close(fd[0][0]);
}
if (hstdout && fd[1][1] != STDOUT_FILENO) {
/* Set termios. */
if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {
goto child_error;
}
close(fd[1][1]);
}
if (npipe == 3 && fd[2][1] != STDERR_FILENO) {
if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {
goto child_error;
}
close(fd[2][1]);
}
argv = malloc(sizeof(char *) * (argc+1));
if (argv == NULL) {
goto child_error;
}
for (i = 0; i < argc; ++i) {
if (vp_stack_pop_str(&stack, &(argv[i]))) {
free(argv);
goto child_error;
}
}
argv[argc] = NULL;
if (execvp(argv[0], argv) < 0) {
/* error */
free(argv);
goto child_error;
}
free(argv);
} else {
/* parent */
if (hstdout == 1) {
close(fd[1][1]);
}
if (npipe == 3 && (hstderr == 0 || hstderr == 1)) {
close(fd[2][1]);
}
vp_stack_push_num(&_result, "%d", pid);
vp_stack_push_num(&_result, "%d", fd[0][1]);
vp_stack_push_num(&_result, "%d", fd[1][0]);
if (npipe == 3) {
vp_stack_push_num(&_result, "%d", fd[2][0]);
}
return vp_stack_return(&_result);
}
/* DO NOT REACH HERE */
return NULL;
/* error */
child_error:
dummy = write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
const char *
vp_pipe_open(char *args)
{
vp_stack_t stack;
int npipe, hstdin, hstderr, hstdout;
int argc;
int fd[3][2];
pid_t pid;
int dummy;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));
if (npipe != 2 && npipe != 3)
return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));
if (hstdin) {
fd[0][0] = hstdin;
fd[0][1] = 0;
} else {
if (pipe(fd[0]) < 0) {
return vp_stack_return_error(&_result, "pipe() error: %s",
strerror(errno));
}
}
if (hstdout) {
fd[1][1] = hstdout;
fd[1][0] = 0;
} else {
if (pipe(fd[1]) < 0) {
return vp_stack_return_error(&_result, "pipe() error: %s",
strerror(errno));
}
}
if (npipe == 3) {
if (hstderr) {
fd[2][1] = hstderr;
fd[2][0] = 0;
} else {
if (pipe(fd[2]) < 0) {
return vp_stack_return_error(&_result, "pipe() error: %s",
strerror(errno));
}
}
}
pid = fork();
if (pid < 0) {
return vp_stack_return_error(&_result, "fork() error: %s",
strerror(errno));
} else if (pid == 0) {
/* child */
char **argv;
int i;
if (!hstdin) {
close(fd[0][1]);
}
if (!hstdout) {
close(fd[1][0]);
}
if (npipe == 3 && !hstderr) {
close(fd[2][0]);
}
if (fd[0][0] != STDIN_FILENO) {
if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {
goto child_error;
}
close(fd[0][0]);
}
if (fd[1][1] != STDOUT_FILENO) {
if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {
goto child_error;
}
close(fd[1][1]);
}
if (npipe == 2) {
if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {
goto child_error;
}
} else if (fd[2][1] != STDERR_FILENO) {
if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {
goto child_error;
}
close(fd[2][1]);
}
argv = malloc(sizeof(char *) * (argc+1));
if (argv == NULL) {
goto child_error;
}
for (i = 0; i < argc; ++i) {
if (vp_stack_pop_str(&stack, &(argv[i]))) {
free(argv);
goto child_error;
}
}
argv[argc] = NULL;
if (execvp(argv[0], argv) < 0) {
free(argv);
goto child_error;
}
free(argv);
} else {
/* parent */
if (!hstdin) {
close(fd[0][0]);
}
if (!hstdout) {
close(fd[1][1]);
}
if (npipe == 3 && !hstderr) {
close(fd[2][1]);
}
vp_stack_push_num(&_result, "%d", pid);
vp_stack_push_num(&_result, "%d", fd[0][1]);
vp_stack_push_num(&_result, "%d", fd[1][0]);
if (npipe == 3)
vp_stack_push_num(&_result, "%d", fd[2][0]);
return vp_stack_return(&_result);
}
/* DO NOT REACH HEAR */
return NULL;
/* error */
child_error:
dummy = write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
const char *
vp_file_read(char *args)
{
vp_stack_t stack;
int fd;
int nr;
int timeout;
int n;
char buf[VP_READ_BUFSIZE];
struct pollfd pfd = {0, POLLIN, 0};
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &nr));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));
pfd.fd = fd;
vp_stack_push_str(&_result, ""); /* initialize */
while (nr != 0) {
n = poll(&pfd, 1, timeout);
if (n == -1) {
/* eof or error */
vp_stack_push_num(&_result, "%d", 1);
return vp_stack_return(&_result);
} else if (n == 0) {
/* timeout */
break;
}
if (pfd.revents & POLLIN) {
if (nr > 0)
n = read(fd, buf,
(VP_READ_BUFSIZE < nr) ? VP_READ_BUFSIZE : nr);
else
n = read(fd, buf, VP_READ_BUFSIZE);
if (n == -1) {
return vp_stack_return_error(&_result, "read() error: %s",
strerror(errno));
} else if (n == 0) {
/* eof */
vp_stack_push_num(&_result, "%d", 1);
return vp_stack_return(&_result);
}
/* decrease stack top for concatenate. */
_result.top--;
vp_stack_push_bin(&_result, buf, n);
if (nr > 0)
nr -= n;
/* try read more bytes without waiting */
timeout = 0;
continue;
} else if (pfd.revents & (POLLERR | POLLHUP)) {
/* eof or error */
vp_stack_push_num(&_result, "%d", 1);
return vp_stack_return(&_result);
} else if (pfd.revents & POLLNVAL) {
return vp_stack_return_error(&_result, "poll() POLLNVAL: %d",
pfd.revents);
}
/* DO NOT REACH HERE */
return vp_stack_return_error(&_result, "poll() unknown status: %d",
pfd.revents);
}
vp_stack_push_num(&_result, "%d", 0);
return vp_stack_return(&_result);
}
const char *
vp_file_open(char *args)
{
vp_stack_t stack;
char *path;
char *flags;
int mode; /* used when flags have O_CREAT */
int f = 0;
int fd;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &flags));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &mode));
#ifdef O_RDONLY
if (strstr(flags, "O_RDONLY")) f |= O_RDONLY;
#endif
#ifdef O_WRONLY
if (strstr(flags, "O_WRONLY")) f |= O_WRONLY;
#endif
#ifdef O_RDRW
if (strstr(flags, "O_RDRW")) f |= O_RDWR;
#endif
#ifdef O_NONBLOCK
if (strstr(flags, "O_NONBLOCK")) f |= O_NONBLOCK;
#endif
#ifdef O_APPEND
if (strstr(flags, "O_APPEND")) f |= O_APPEND;
#endif
#ifdef O_CREAT
if (strstr(flags, "O_CREAT")) f |= O_CREAT;
#endif
#ifdef O_EXCL
if (strstr(flags, "O_EXCL")) f |= O_EXCL;
#endif
#ifdef O_TRUNC
if (strstr(flags, "O_TRUNC")) f |= O_TRUNC;
#endif
#ifdef O_SHLOCK
if (strstr(flags, "O_SHLOCK")) f |= O_SHLOCK;
#endif
#ifdef O_EXLOCK
if (strstr(flags, "O_EXLOCK")) f |= O_EXLOCK;
#endif
#ifdef O_DIRECT
if (strstr(flags, "O_DIRECT")) f |= O_DIRECT;
#endif
#ifdef O_FSYNC
if (strstr(flags, "O_FSYNC")) f |= O_FSYNC;
#endif
#ifdef O_NOFOLLOW
if (strstr(flags, "O_NOFOLLOW")) f |= O_NOFOLLOW;
#endif
#ifdef O_TEMPORARY
if (strstr(flags, "O_TEMPORARY")) f |= O_TEMPORARY;
#endif
#ifdef O_RANDOM
if (strstr(flags, "O_RANDOM")) f |= O_RANDOM;
#endif
#ifdef O_SEQUENTIAL
if (strstr(flags, "O_SEQENTIAL")) f |= O_SEQUENTIAL;
#endif
#ifdef O_BINARY
if (strstr(flags, "O_BINARY")) f |= O_BINARY;
#endif
#ifdef O_TEXT
if (strstr(flags, "O_TEXT")) f |= O_TEXT;
#endif
#ifdef O_INHERIT
if (strstr(flags, "O_INHERIT")) f |= O_INHERIT;
#endif
#ifdef _O_SHORT_LIVED
if (strstr(flags, "O_SHORT_LIVED")) f |= _O_SHORT_LIVED;
#endif
fd = open(path, f, mode);
if (fd == -1)
return vp_stack_return_error(&_result, "open() error: %s",
strerror(errno));
vp_stack_push_num(&_result, "%d", fd);
return vp_stack_return(&_result);
}
const char *
vp_dlversion(char *args)
{
vp_stack_push_num(&_result, "%2d%02d", 7, 0);
return vp_stack_return(&_result);
}
const char *
vp_pipe_open(char *args)
{
vp_stack_t stack;
int npipe;
int argc;
char *argv[VP_ARGC_MAX];
int fd[3][2];
pid_t pid;
int i;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));
if (npipe != 2 && npipe != 3)
return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));
if (argc < 1 || VP_ARGC_MAX <= argc)
return vp_stack_return_error(&_result, "argc range error. too many arguments. please use xargs.");
for (i = 0; i < argc; ++i)
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &(argv[i])));
argv[argc] = NULL;
if (pipe(fd[0]) < 0 || pipe(fd[1]) < 0 || (npipe == 3 && pipe(fd[2]) < 0))
return vp_stack_return_error(&_result, "pipe() error: %s",
strerror(errno));
pid = fork();
if (pid < 0) {
return vp_stack_return_error(&_result, "fork() error: %s",
strerror(errno));
} else if (pid == 0) {
/* child */
close(fd[0][1]);
close(fd[1][0]);
if (npipe == 3)
close(fd[2][0]);
if (fd[0][0] != STDIN_FILENO) {
if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {
write(fd[1][1], strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
close(fd[0][0]);
}
if (fd[1][1] != STDOUT_FILENO) {
if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {
write(fd[1][1], strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
close(fd[1][1]);
}
if (npipe == 2) {
if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {
write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
} else if (fd[2][1] != STDERR_FILENO) {
if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {
write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
close(fd[2][1]);
}
if (execv(argv[0], argv) < 0) {
/* error */
write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
} else {
/* parent */
close(fd[0][0]);
close(fd[1][1]);
if (npipe == 3)
close(fd[2][1]);
vp_stack_push_num(&_result, "%d", pid);
vp_stack_push_num(&_result, "%d", fd[0][1]);
vp_stack_push_num(&_result, "%d", fd[1][0]);
if (npipe == 3)
vp_stack_push_num(&_result, "%d", fd[2][0]);
return vp_stack_return(&_result);
}
/* DO NOT REACH HEAR */
return NULL;
}
const char *
vp_fd_read(char *args, int is_pty_pipe)
{
#ifdef __linux__
# define VP_POLLIN (POLLIN | POLLHUP)
#else
# define VP_POLLIN (POLLIN)
#endif
vp_stack_t stack;
int fd;
int cnt;
int timeout;
int n;
char *buf;
char *eof;
unsigned int size = 0;
struct pollfd pfd = {0, POLLIN, 0};
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &cnt));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &timeout));
if (cnt < 0 || VP_READ_BUFSIZE < cnt) {
cnt = VP_READ_BUFSIZE;
}
/* initialize buffer */
_result.top = _result.buf;
vp_stack_push_num(&_result, "%d", 0); /* set eof to 0 */
eof = _result.top - 1;
buf = _result.top;
*(buf++) = VP_EOV;
buf += VP_HEADER_SIZE;
pfd.fd = fd;
while (cnt > 0) {
n = poll(&pfd, 1, timeout);
if (n == -1) {
/* eof or error */
*eof = '1';
break;
} else if (n == 0) {
/* timeout */
break;
}
if (pfd.revents & VP_POLLIN) {
n = read(fd, buf, cnt);
if (n == -1) {
if (pfd.revents & POLLERR
|| pfd.revents & POLLNVAL
|| pfd.revents & POLLWRNORM
/* Cygwin(after ver.2.0) fails pty read and returns
* POLLIN. */
|| (!is_pty_pipe && pfd.revents & POLLIN)
) {
return vp_stack_return_error(&_result,
"read() error: revents = %d, error = %s",
pfd.revents, strerror(errno));
}
/* eof */
*eof = '1';
break;
} else if (n == 0) {
/* eof */
*eof = '1';
break;
}
/* decrease stack top for concatenate. */
cnt -= n;
buf += n;
size += n;
/* try read more bytes without waiting */
timeout = 0;
continue;
} else if (pfd.revents & (POLLERR | POLLHUP)) {
/* eof or error */
*eof = '1';
break;
} else if (pfd.revents & POLLNVAL) {
return vp_stack_return_error(&_result, "poll() POLLNVAL: %d",
pfd.revents);
}
/* DO NOT REACH HERE */
return vp_stack_return_error(&_result, "poll() unknown status: %d",
pfd.revents);
}
vp_encode_size(size, _result.top + 1);
_result.top = buf;
return vp_stack_return(&_result);
#undef VP_POLLIN
}
const char *
vp_pipe_open(char *args)
{
#define VP_GOTO_ERROR(_fmt) do { errfmt = (_fmt); goto error; } while(0)
vp_stack_t stack;
int npipe, hstdin, hstderr, hstdout;
int argc;
int fd[3][2] = {{0}};
pid_t pid;
int dummy;
char *errfmt;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));
if (npipe != 2 && npipe != 3)
return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));
if (hstdin > 0) {
fd[0][0] = hstdin;
fd[0][1] = 0;
} else {
if (pipe(fd[0]) < 0) {
VP_GOTO_ERROR("pipe() error: %s");
}
}
if (hstdout > 0) {
fd[1][1] = hstdout;
fd[1][0] = 0;
} else {
if (pipe(fd[1]) < 0) {
VP_GOTO_ERROR("pipe() error: %s");
}
}
if (hstderr > 0) {
fd[2][1] = hstderr;
fd[2][0] = 0;
} else if (npipe == 3 && hstderr == 0) {
if (pipe(fd[2]) < 0) {
VP_GOTO_ERROR("pipe() error: %s");
}
}
pid = fork();
if (pid < 0) {
VP_GOTO_ERROR("fork() error: %s");
} else if (pid == 0) {
/* child */
char **argv;
int i;
/* Set process group. */
setpgid(0, 0);
if (fd[0][1] > 0) {
close(fd[0][1]);
}
if (fd[1][0] > 0) {
close(fd[1][0]);
}
if (fd[2][0] > 0) {
close(fd[2][0]);
}
if (fd[0][0] > 0) {
if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {
goto child_error;
}
close(fd[0][0]);
}
if (fd[1][1] > 0) {
if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {
goto child_error;
}
close(fd[1][1]);
}
if (fd[2][1] > 0) {
if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {
goto child_error;
}
close(fd[2][1]);
} else if (npipe == 2) {
if (dup2(STDOUT_FILENO, STDERR_FILENO) != STDERR_FILENO) {
goto child_error;
}
}
{
#ifndef TIOCNOTTY
setsid();
#else
/* Ignore tty. */
char name[L_ctermid];
if (ctermid(name)[0] != '\0') {
int tfd;
if ((tfd = open(name, O_RDONLY)) != -1) {
ioctl(tfd, TIOCNOTTY, NULL);
close(tfd);
}
}
#endif
}
argv = malloc(sizeof(char *) * (argc+1));
if (argv == NULL) {
goto child_error;
}
for (i = 0; i < argc; ++i) {
if (vp_stack_pop_str(&stack, &(argv[i]))) {
free(argv);
goto child_error;
}
}
argv[argc] = NULL;
execv(argv[0], argv);
/* error */
goto child_error;
} else {
/* parent */
if (fd[0][0] > 0) {
close(fd[0][0]);
}
if (fd[1][1] > 0) {
close(fd[1][1]);
}
if (fd[2][1] > 0) {
close(fd[2][1]);
}
vp_stack_push_num(&_result, "%d", pid);
vp_stack_push_num(&_result, "%d", fd[0][1]);
vp_stack_push_num(&_result, "%d", fd[1][0]);
if (npipe == 3) {
vp_stack_push_num(&_result, "%d", fd[2][0]);
}
return vp_stack_return(&_result);
}
/* DO NOT REACH HERE */
return NULL;
/* error */
error:
close_allfd(fd);
return vp_stack_return_error(&_result, errfmt, strerror(errno));
child_error:
dummy = write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
#undef VP_GOTO_ERROR
}
/*
* http://support.microsoft.com/kb/190351/
*/
const char *
vp_pipe_open(char *args)
{
vp_stack_t stack;
int npipe, hstdin, hstderr, hstdout;
char *cmdline;
HANDLE hInputWrite = INVALID_HANDLE_VALUE, hInputRead;
HANDLE hOutputWrite, hOutputRead = INVALID_HANDLE_VALUE;
HANDLE hErrorWrite, hErrorRead = INVALID_HANDLE_VALUE;
SECURITY_ATTRIBUTES sa;
PROCESS_INFORMATION pi;
STARTUPINFO si;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));
if (npipe != 2 && npipe != 3)
return vp_stack_return_error(&_result, "npipe range error");
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &cmdline));
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
if (hstdin) {
/* Get handle. */
hInputRead = (HANDLE)_get_osfhandle(hstdin);
} else {
HANDLE hInputWriteTmp;
/* Create pipe. */
if (!CreatePipe(&hInputRead, &hInputWriteTmp, &sa, 0))
return vp_stack_return_error(&_result, "CreatePipe() error: %s",
lasterror());
if (!DuplicateHandle(GetCurrentProcess(),
hInputWriteTmp,
GetCurrentProcess(),
&hInputWrite,
0,
FALSE,
DUPLICATE_SAME_ACCESS))
return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",
lasterror());
if (!CloseHandle(hInputWriteTmp))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
}
if (hstdout) {
/* Get handle. */
hOutputWrite = (HANDLE)_get_osfhandle(hstdout);
} else {
HANDLE hOutputReadTmp;
/* Create pipe. */
if (!CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))
return vp_stack_return_error(&_result, "CreatePipe() error: %s",
lasterror());
if (!DuplicateHandle(GetCurrentProcess(),
hOutputReadTmp,
GetCurrentProcess(),
&hOutputRead,
0,
TRUE,
DUPLICATE_SAME_ACCESS))
return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",
lasterror());
if (!CloseHandle(hOutputReadTmp))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
}
if (npipe == 2) {
if (!DuplicateHandle(GetCurrentProcess(),
hOutputWrite,
GetCurrentProcess(),
&hErrorWrite,
0,
TRUE,
DUPLICATE_SAME_ACCESS))
return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",
lasterror());
} else {
if (hstderr) {
/* Get handle. */
hErrorWrite = (HANDLE)_get_osfhandle(hstderr);
} else {
HANDLE hErrorReadTmp;
/* Create pipe. */
if (!CreatePipe(&hErrorReadTmp, &hErrorWrite, &sa, 0))
return vp_stack_return_error(&_result, "CreatePipe() error: %s",
lasterror());
if (!DuplicateHandle(GetCurrentProcess(),
hErrorReadTmp,
GetCurrentProcess(),
&hErrorRead,
0,
TRUE,
DUPLICATE_SAME_ACCESS))
return vp_stack_return_error(&_result, "DuplicateHandle() error: %s",
lasterror());
if (!CloseHandle(hErrorReadTmp))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
}
}
ZeroMemory(&si, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
/*si.dwFlags = STARTF_USESTDHANDLES;*/
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.wShowWindow = SW_HIDE;
si.hStdInput = hInputRead;
si.hStdOutput = hOutputWrite;
si.hStdError = hErrorWrite;
if (!CreateProcess(NULL, cmdline, NULL, NULL, TRUE,
CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi))
/*0, NULL, NULL, &si, &pi))*/
/*DETACHED_PROCESS, NULL, NULL, &si, &pi))*/
/*CREATE_NO_WINDOW, NULL, NULL, &si, &pi))*/
return vp_stack_return_error(&_result, "CreateProcess() error: %s %s",
lasterror());
if (!CloseHandle(pi.hThread))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
if (!CloseHandle(hInputRead))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
if (!CloseHandle(hOutputWrite))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
if (!CloseHandle(hErrorWrite))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
vp_stack_push_num(&_result, "%p", pi.hProcess);
vp_stack_push_num(&_result, "%d", hstdin ?
0 : _open_osfhandle((size_t)hInputWrite, 0));
vp_stack_push_num(&_result, "%d", hstdout ?
0 : _open_osfhandle((size_t)hOutputRead, _O_RDONLY));
if (npipe == 3)
vp_stack_push_num(&_result, "%d", hstderr ?
0 : _open_osfhandle((size_t)hErrorRead, _O_RDONLY));
return vp_stack_return(&_result);
}
const char *
vp_pty_open(char *args)
{
#define VP_GOTO_ERROR(_fmt) do { errfmt = (_fmt); goto error; } while(0)
vp_stack_t stack;
int argc;
int fd[3][2] = {{0}};
pid_t pid;
struct winsize ws = {0, 0, 0, 0};
int dummy;
int hstdin, hstderr, hstdout;
int fdm;
int npipe;
char *errfmt;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &npipe));
if (npipe != 2 && npipe != 3)
return vp_stack_return_error(&_result, "npipe range error. wrong pipes.");
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_col)));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%hu", &(ws.ws_row)));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdin));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstdout));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &hstderr));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &argc));
/* Set pipe */
if (hstdin > 0) {
fd[0][0] = hstdin;
fd[0][1] = 0;
}
if (hstdout > 1) {
fd[1][1] = hstdout;
fd[1][0] = 0;
} else if (hstdout == 1) {
if (pipe(fd[1]) < 0) {
VP_GOTO_ERROR("pipe() error: %s");
}
}
if (hstderr > 1) {
fd[2][1] = hstderr;
fd[2][0] = 0;
} else if (npipe == 3) {
if (hstderr == 1){
if (pipe(fd[2]) < 0) {
VP_GOTO_ERROR("pipe() error: %s");
}
} else if (hstderr == 0) {
if (openpty(&fd[2][0], &fd[2][1], NULL, NULL, &ws) < 0) {
VP_GOTO_ERROR("openpty() error: %s");
}
VP_SET_NONBLOCK_IF_NEEDED(fd[2][0]);
}
}
pid = forkpty(&fdm, NULL, NULL, &ws);
if (pid < 0) {
VP_GOTO_ERROR("fork() error: %s");
} else if (pid == 0) {
/* child */
char **argv;
int i;
/* Close pipe */
if (fd[1][0] > 0) {
close(fd[1][0]);
}
if (fd[2][0] > 0) {
close(fd[2][0]);
}
if (fd[0][0] > 0) {
if (dup2(fd[0][0], STDIN_FILENO) != STDIN_FILENO) {
goto child_error;
}
close(fd[0][0]);
}
if (fd[1][1] > 0) {
if (dup2(fd[1][1], STDOUT_FILENO) != STDOUT_FILENO) {
goto child_error;
}
close(fd[1][1]);
}
if (fd[2][1] > 0) {
if (dup2(fd[2][1], STDERR_FILENO) != STDERR_FILENO) {
goto child_error;
}
close(fd[2][1]);
}
argv = malloc(sizeof(char *) * (argc+1));
if (argv == NULL) {
goto child_error;
}
for (i = 0; i < argc; ++i) {
if (vp_stack_pop_str(&stack, &(argv[i]))) {
free(argv);
goto child_error;
}
}
argv[argc] = NULL;
execv(argv[0], argv);
/* error */
goto child_error;
} else {
/* parent */
if (fd[1][1] > 0) {
close(fd[1][1]);
}
if (fd[2][1] > 0) {
close(fd[2][1]);
}
if (hstdin == 0) {
fd[0][1] = fdm;
}
if (hstdout == 0) {
fd[1][0] = hstdin == 0 ? dup(fdm) : fdm;
VP_SET_NONBLOCK_IF_NEEDED(fd[1][0]);
}
vp_stack_push_num(&_result, "%d", pid);
vp_stack_push_num(&_result, "%d", fd[0][1]);
vp_stack_push_num(&_result, "%d", fd[1][0]);
if (npipe == 3) {
vp_stack_push_num(&_result, "%d", fd[2][0]);
}
return vp_stack_return(&_result);
}
/* DO NOT REACH HERE */
return NULL;
/* error */
error:
close_allfd(fd);
return vp_stack_return_error(&_result, errfmt, strerror(errno));
child_error:
dummy = write(STDOUT_FILENO, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
#undef VP_GOTO_ERROR
}