const char *
vp_socket_read(char *args)
{
vp_stack_t stack;
int sock;
int nr;
int timeout;
struct timeval tv;
int n;
char buf[VP_READ_BUFSIZE];
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_num(&stack, "%d", &nr));
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);
vp_stack_push_str(&_result, ""); /* initialize */
while (nr != 0) {
n = select(0, &fdset, NULL, 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;
}
if (nr > 0)
n = recv(sock, buf,
(VP_READ_BUFSIZE < nr) ? VP_READ_BUFSIZE : nr, 0);
else
n = recv(sock, buf, VP_READ_BUFSIZE, 0);
if (n == -1) {
return vp_stack_return_error(&_result, "recv() 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;
}
vp_stack_push_num(&_result, "%d", 0);
return vp_stack_return(&_result);
}
const char *
vp_pipe_read(char *args)
{
vp_stack_t stack;
int fd;
int nr;
int timeout;
DWORD n;
char buf[VP_READ_BUFSIZE];
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));
vp_stack_push_str(&_result, ""); /* initialize */
while (nr != 0) {
n = 0;
if (!PeekNamedPipe((HANDLE)_get_osfhandle(fd), buf,
(nr < 0) ? VP_READ_BUFSIZE : (VP_READ_BUFSIZE < nr) ? VP_READ_BUFSIZE : nr,
&n, NULL, NULL))
{
/* can be ERROR_HANDLE_EOF? */
if (GetLastError() == 0 || GetLastError() == ERROR_BROKEN_PIPE) {
/* error or eof */
if (n != 0) {
/* decrease stack top for concatenate. */
_result.top--;
vp_stack_push_bin(&_result, buf, n);
}
vp_stack_push_num(&_result, "%d", 1);
return vp_stack_return(&_result);
}
return vp_stack_return_error(&_result, "PeekNamedPipe() error: %08X %s",
GetLastError(), lasterror());
}
if (n == 0) {
break;
}
if (read(fd, buf, n) == -1)
return vp_stack_return_error(&_result, "read() error: %s",
strerror(errno));
/* 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;
}
vp_stack_push_num(&_result, "%d", 0);
return vp_stack_return(&_result);
}
const char *
vp_file_read(char *args)
{
vp_stack_t stack;
int fd;
int nr;
int timeout;
DWORD ret;
int n;
char buf[VP_READ_BUFSIZE];
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));
vp_stack_push_str(&_result, ""); /* initialize */
while (nr != 0) {
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;
}
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;
}
vp_stack_push_num(&_result, "%d", 0);
return vp_stack_return(&_result);
}
const char *
vp_waitpid(char *args)
{
vp_stack_t stack;
pid_t pid;
pid_t n;
int status;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &pid));
n = waitpid(pid, &status, WNOHANG | WUNTRACED);
if (n == -1)
return vp_stack_return_error(&_result, "waitpid() error: %s",
strerror(errno));
if (n == 0 || WIFCONTINUED(status)) {
vp_stack_push_str(&_result, "run");
vp_stack_push_num(&_result, "%d", 0);
} else if (WIFEXITED(status)) {
vp_stack_push_str(&_result, "exit");
vp_stack_push_num(&_result, "%d", WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
vp_stack_push_str(&_result, "signal");
vp_stack_push_num(&_result, "%d", WTERMSIG(status));
} else if (WIFSTOPPED(status)) {
vp_stack_push_str(&_result, "stop");
vp_stack_push_num(&_result, "%d", WSTOPSIG(status));
} else {
return vp_stack_return_error(&_result,
"waitpid() unknown status: status=%d", status);
}
return vp_stack_return(&_result);
}
/*
* Added by Richard Emberson
* Check to see if a host exists.
*/
const char *
vp_host_exists(char *args)
{
vp_stack_t stack;
char *host;
struct hostent *hostent;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &host));
if (sockets_number++ == 0)
{
WSADATA wsadata;
WSAStartup(2, &wsadata);
}
hostent = gethostbyname(host);
if (--sockets_number == 0)
{
WSACleanup();
}
if (hostent) {
vp_stack_push_num(&_result, "%d", 1);
} else {
vp_stack_push_num(&_result, "%d", 0);
}
return vp_stack_return(&_result);
}
const char *
vp_kill(char *args)
{
vp_stack_t stack;
pid_t pid, pgid;
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));
if (sig != 0) {
/* Kill by the process group. */
pgid = getpgid(pid);
if (pid == pgid) {
kill(-pgid, sig);
}
}
vp_stack_push_num(&_result, "%d", ret);
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 oflag = 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));
oflag = str_to_oflag(flags);
if (oflag == -1)
return vp_stack_return_error(&_result, "open flag error.");
fd = open(path, oflag, 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_decode(char *args)
{
vp_stack_t stack;
size_t len;
char *str;
char *p, *q;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &str));
len = strlen(str);
if (len % 2 != 0) {
return "vp_decode: invalid data length";
}
VP_RETURN_IF_FAIL(vp_stack_reserve(&_result,
(_result.top - _result.buf) + (len / 2) + sizeof(VP_EOV_STR)));
for (p = str, q = _result.top; p < str + len; ) {
char hb, lb;
hb = CHR2XD[(int)*(p++)];
lb = CHR2XD[(int)*(p++)];
if (hb != (char)-1 && lb != (char)-1) {
*(q++) = (hb << 4) | lb;
}
}
*(q++) = VP_EOV;
*q = '\0';
_result.top = q;
return vp_stack_return(&_result);
}
/* http://www.syuhitu.org/other/dir.html */
const char *
vp_readdir(char *args)
{
vp_stack_t stack;
char *dirname;
char buf[1024];
WIN32_FIND_DATA fd;
HANDLE h;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &dirname));
snprintf(buf, sizeof(buf), "%s\\*", dirname);
/* Get handle. */
h = FindFirstFileEx(buf, FindExInfoStandard, &fd,
FindExSearchNameMatch, NULL, 0
);
if (h == INVALID_HANDLE_VALUE) {
return vp_stack_return_error(&_result, "FindFirstFileEx() error: %s",
GetLastError());
}
do {
snprintf(buf, sizeof(buf), "%s/%s", dirname, fd.cFileName);
vp_stack_push_str(&_result, buf);
} while (FindNextFile(h, &fd));
FindClose(h);
return vp_stack_return(&_result);
}
const char *
vp_readdir(char *args)
{
vp_stack_t stack;
char *dirname;
char buf[1024];
DIR *dir;
struct dirent *dp;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &dirname));
if ((dir=opendir(dirname)) == NULL) {
return vp_stack_return_error(&_result, "opendir() error: %s",
strerror(errno));
}
for (dp = readdir(dir); dp != NULL; dp = readdir(dir)) {
snprintf(buf, sizeof(buf), "%s/%s", dirname, dp->d_name);
vp_stack_push_str(&_result, buf);
}
closedir(dir);
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;
int n;
struct pollfd pfd = {0, POLLOUT, 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", &timeout));
size = vp_decode_size(stack.top);
buf = stack.top + VP_HEADER_SIZE;
pfd.fd = fd;
nleft = 0;
while (nleft < size) {
n = poll(&pfd, 1, timeout);
if (n == -1) {
return vp_stack_return_error(&_result, "poll() error: %s",
strerror(errno));
} else if (n == 0) {
/* timeout */
break;
}
if (pfd.revents & POLLOUT) {
n = write(fd, buf + nleft, 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;
continue;
} else if (pfd.revents & (POLLERR | POLLHUP)) {
/* eof or error */
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: %s",
pfd.revents);
}
vp_stack_push_num(&_result, "%zu", nleft);
return vp_stack_return(&_result);
}
const char *
vp_pty_open(char *args)
{
vp_stack_t stack;
int argc;
char *argv[VP_ARGC_MAX];
int fdm;
pid_t pid;
struct winsize ws = {0, 0, 0, 0};
struct termios ti;
int i;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
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", &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 0
/* TODO: set termios parameter */
/* tcgetattr will fail when gvim is executed from gnome menu */
if (tcgetattr(STDIN_FILENO, &ti) < 0)
return vp_stack_return_error(&_result, "tcgetattr() error: %s",
strerror(errno));
pid = forkpty(&fdm, NULL, &ti, &ws);
#else
pid = forkpty(&fdm, NULL, NULL, &ws);
#endif
if (pid < 0) {
return vp_stack_return_error(&_result, "forkpty() error: %s",
strerror(errno));
} else if (pid == 0) {
/* child */
if (execv(argv[0], argv) < 0) {
/* error */
write(fdm, strerror(errno), strlen(strerror(errno)));
_exit(EXIT_FAILURE);
}
} else {
/* parent */
vp_stack_push_num(&_result, "%d", pid);
vp_stack_push_num(&_result, "%d", fdm);
/* XXX - ttyname(fdm) breaks in OS X */
vp_stack_push_str(&_result, "unused");
return vp_stack_return(&_result);
}
/* DO NOT REACH HERE */
return NULL;
}
const char *
vp_socket_open(char *args)
{
vp_stack_t stack;
char *host;
char *port;
int port_nr;
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));
if (sockets_number++ == 0)
{
WSADATA wsadata;
WSAStartup(2, &wsadata);
}
if (sscanf(port, "%d%n", &port_nr, &n) == 1 && port[n] == '\0') {
nport = htons((u_short)port_nr);
} else {
servent = getservbyname(port, NULL);
if (servent == NULL)
return vp_stack_return_error(&_result, "getservbyname() error: %s",
port);
nport = servent->s_port;
}
sock = (int)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);
}
/* push error message and return */
static const char *
vp_stack_return_error(vp_stack_t *stack, const char *fmt, ...)
{
va_list ap;
size_t needsize;
needsize = (stack->top - stack->buf) + VP_ERRMSG_SIZE;
if (vp_stack_reserve(stack, needsize) != NULL)
return fmt;
va_start(ap, fmt);
stack->top += vsnprintf(stack->top,
stack->size - (stack->top - stack->buf), fmt, ap);
va_end(ap);
return vp_stack_return(stack);
}
const char *
vp_dlopen(char *args)
{
vp_stack_t stack;
char *path;
HINSTANCE handle;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));
handle = LoadLibrary(path);
if (handle == NULL)
return lasterror();
vp_stack_push_num(&_result, "%p", handle);
return vp_stack_return(&_result);
}
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_pty_get_winsize(char *args)
{
vp_stack_t stack;
int fd;
struct winsize ws = {0, 0, 0, 0};
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));
if (ioctl(fd, TIOCGWINSZ, &ws) < 0)
return vp_stack_return_error(&_result, "ioctl() error: %s",
strerror(errno));
vp_stack_push_num(&_result, "%hu", ws.ws_col);
vp_stack_push_num(&_result, "%hu", ws.ws_row);
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);
}
/*
* Added by Richard Emberson
* Check to see if a host exists.
*/
const char *
vp_host_exists(char *args)
{
vp_stack_t stack;
char *host;
struct hostent *hostent;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &host));
hostent = gethostbyname(host);
if (hostent) {
vp_stack_push_num(&_result, "%d", 1);
} else {
vp_stack_push_num(&_result, "%d", 0);
}
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);
}
/*
* 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_decode(char *args)
{
vp_stack_t stack;
unsigned num = 0;
unsigned i = 0;
size_t length;
char *str;
char *buf;
char *p;
char *bp;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &str));
length = strlen(str);
buf = (char *)malloc(length/2 + 2);
if (buf == NULL) {
return vp_stack_return_error(&_result, "malloc() error: %s",
"Memory cannot allocate");
}
p = str;
bp = buf;
for (i = 0; i < length; i++, p++) {
if (isdigit(*p))
num |= (*p & 15);
else
num |= (*p & 15) + 9;
if (i % 2) {
*bp++ = num;
num = 0;
} else {
num <<= 4;
}
}
*bp = '\0';
vp_stack_push_str(&_result, buf);
free(buf);
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_decode(char *args)
{
vp_stack_t stack;
unsigned num;
unsigned i, bi;
size_t length, max_buf;
char *str;
char *buf;
char *p;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &str));
length = strlen(str);
max_buf = length/2 + 2;
buf = (char *)malloc(max_buf);
if (buf == NULL) {
return vp_stack_return_error(&_result, "malloc() error: %s",
"Memory cannot allocate");
}
p = str;
bi = 0;
num = 0;
for (i = 0; i < length; i++, p++) {
if (isdigit((int)*p))
num |= (*p & 15);
else
num |= (*p & 15) + 9;
if (i % 2 == 0) {
num <<= 4;
continue;
}
/* Write character. */
if (num == 0) {
/* Convert NULL character. */
max_buf += 1;
buf = (char *)realloc(buf, max_buf);
if (buf == NULL) {
return vp_stack_return_error(
&_result, "realloc() error: %s",
"Memory cannot allocate");
}
buf[bi] = '^';
bi++;
buf[bi] = '@';
bi++;
} else {
buf[bi] = num;
bi++;
}
num = 0;
}
buf[bi] = '\0';
vp_stack_push_str(&_result, buf);
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);
}
