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);
}
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);
}
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);
}
/*
* 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);
}
/* 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_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_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_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_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_dlclose(char *args)
{
vp_stack_t stack;
HINSTANCE handle;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));
if (!FreeLibrary(handle))
return lasterror();
vp_stack_free(&_result);
return NULL;
}
const char *
vp_kill(char *args)
{
vp_stack_t stack;
HANDLE handle;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));
if (!TerminateProcess(handle, 2) || !CloseHandle(handle))
return vp_stack_return_error(&_result, "kill() error: %s",
lasterror());
return NULL;
}
const char *
vp_close_handle(char *args)
{
vp_stack_t stack;
HANDLE handle;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));
if (!CloseHandle(handle))
return vp_stack_return_error(&_result,
"CloseHandle() error: %s", lasterror());
return NULL;
}
const char *
vp_file_close(char *args)
{
vp_stack_t stack;
int fd;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));
if (close(fd) == -1)
return vp_stack_return_error(&_result, "close() error: %s",
strerror(errno));
return NULL;
}
const char *
vp_pipe_close(char *args)
{
vp_stack_t stack;
int fd;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &fd));
if (!CloseHandle((HANDLE)_get_osfhandle(fd)))
return vp_stack_return_error(&_result, "CloseHandle() error: %s",
lasterror());
return NULL;
}
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_dlclose(char *args)
{
vp_stack_t stack;
void *handle;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%p", &handle));
/* On FreeBSD6, to call dlclose() twice with same pointer causes SIGSEGV */
if (dlclose(handle) == -1)
return dlerror();
vp_stack_free(&_result);
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);
}
const char *
vp_kill(char *args)
{
vp_stack_t stack;
pid_t pid;
int sig;
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));
if (kill(pid, sig) == -1)
return vp_stack_return_error(&_result, "kill() error: %s",
strerror(errno));
return NULL;
}
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_open(char *args)
{
vp_stack_t stack;
char *path;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_str(&stack, &path));
if ((size_t)ShellExecute(NULL, "open", path, NULL, NULL, SW_SHOWNORMAL) < 32) {
return vp_stack_return_error(&_result, "ShellExecute() error: %s",
lasterror());
}
return NULL;
}
const char *
vp_pty_set_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));
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)));
if (ioctl(fd, TIOCSWINSZ, &ws) < 0)
return vp_stack_return_error(&_result, "ioctl() error: %s",
strerror(errno));
return NULL;
}
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);
}
/*
* 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_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_socket_close(char *args)
{
vp_stack_t stack;
int sock;
VP_RETURN_IF_FAIL(vp_stack_from_args(&stack, args));
VP_RETURN_IF_FAIL(vp_stack_pop_num(&stack, "%d", &sock));
if (closesocket(sock) == SOCKET_ERROR) {
return vp_stack_return_error(&_result, "closesocket() error: %d",
WSAGetLastError());
}
if (--sockets_number == 0)
{
WSACleanup();
}
return NULL;
}
static const char *
vp_stack_push_str(vp_stack_t *stack, const char *str)
{
size_t needsize;
needsize = (stack->top - stack->buf) + strlen(str) + sizeof(VP_EOV_STR);
VP_RETURN_IF_FAIL(vp_stack_reserve(stack, needsize));
stack->top += sprintf(stack->top, "%s%c", str, VP_EOV);
return NULL;
}
