自学教程：C++ vp_stack_from_args函数代码示例

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;}

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);}