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