File Explorer

1/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.2 *3 * Permission is hereby granted, free of charge, to any person obtaining a copy4 * of this software and associated documentation files (the "Software"), to5 * deal in the Software without restriction, including without limitation the6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or7 * sell copies of the Software, and to permit persons to whom the Software is8 * furnished to do so, subject to the following conditions:9 *10 * The above copyright notice and this permission notice shall be included in11 * all copies or substantial portions of the Software.12 *13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS19 * IN THE SOFTWARE.20 */21 22/* See https://github.com/libuv/libuv#documentation for documentation. */23 24#ifndef UV_H25#define UV_H26#ifdef __cplusplus27extern "C" {28#endif29 30#if defined(BUILDING_UV_SHARED) && defined(USING_UV_SHARED)31#error "Define either BUILDING_UV_SHARED or USING_UV_SHARED, not both."32#endif33 34#ifndef UV_EXTERN35#ifdef _WIN3236  /* Windows - set up dll import/export decorators. */37# if defined(BUILDING_UV_SHARED)38    /* Building shared library. */39#   define UV_EXTERN __declspec(dllexport)40# elif defined(USING_UV_SHARED)41    /* Using shared library. */42#   define UV_EXTERN __declspec(dllimport)43# else44    /* Building static library. */45#   define UV_EXTERN /* nothing */46# endif47#elif __GNUC__ >= 448# define UV_EXTERN __attribute__((visibility("default")))49#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x550) /* Sun Studio >= 8 */50# define UV_EXTERN __global51#else52# define UV_EXTERN /* nothing */53#endif54#endif /* UV_EXTERN */55 56#include "uv/errno.h"57#include "uv/version.h"58#include <stddef.h>59#include <stdio.h>60#include <stdint.h>61#include <math.h>62 63/* Internal type, do not use. */64struct uv__queue {65  struct uv__queue* next;66  struct uv__queue* prev;67};68 69#if defined(_WIN32)70# include "uv/win.h"71#else72# include "uv/unix.h"73#endif74 75/* Expand this list if necessary. */76#define UV_ERRNO_MAP(XX)                                                      \77  XX(E2BIG, "argument list too long")                                         \78  XX(EACCES, "permission denied")                                             \79  XX(EADDRINUSE, "address already in use")                                    \80  XX(EADDRNOTAVAIL, "address not available")                                  \81  XX(EAFNOSUPPORT, "address family not supported")                            \82  XX(EAGAIN, "resource temporarily unavailable")                              \83  XX(EAI_ADDRFAMILY, "address family not supported")                          \84  XX(EAI_AGAIN, "temporary failure")                                          \85  XX(EAI_BADFLAGS, "bad ai_flags value")                                      \86  XX(EAI_BADHINTS, "invalid value for hints")                                 \87  XX(EAI_CANCELED, "request canceled")                                        \88  XX(EAI_FAIL, "permanent failure")                                           \89  XX(EAI_FAMILY, "ai_family not supported")                                   \90  XX(EAI_MEMORY, "out of memory")                                             \91  XX(EAI_NODATA, "no address")                                                \92  XX(EAI_NONAME, "unknown node or service")                                   \93  XX(EAI_OVERFLOW, "argument buffer overflow")                                \94  XX(EAI_PROTOCOL, "resolved protocol is unknown")                            \95  XX(EAI_SERVICE, "service not available for socket type")                    \96  XX(EAI_SOCKTYPE, "socket type not supported")                               \97  XX(EALREADY, "connection already in progress")                              \98  XX(EBADF, "bad file descriptor")                                            \99  XX(EBUSY, "resource busy or locked")                                        \100  XX(ECANCELED, "operation canceled")                                         \101  XX(ECHARSET, "invalid Unicode character")                                   \102  XX(ECONNABORTED, "software caused connection abort")                        \103  XX(ECONNREFUSED, "connection refused")                                      \104  XX(ECONNRESET, "connection reset by peer")                                  \105  XX(EDESTADDRREQ, "destination address required")                            \106  XX(EEXIST, "file already exists")                                           \107  XX(EFAULT, "bad address in system call argument")                           \108  XX(EFBIG, "file too large")                                                 \109  XX(EHOSTUNREACH, "host is unreachable")                                     \110  XX(EINTR, "interrupted system call")                                        \111  XX(EINVAL, "invalid argument")                                              \112  XX(EIO, "i/o error")                                                        \113  XX(EISCONN, "socket is already connected")                                  \114  XX(EISDIR, "illegal operation on a directory")                              \115  XX(ELOOP, "too many symbolic links encountered")                            \116  XX(EMFILE, "too many open files")                                           \117  XX(EMSGSIZE, "message too long")                                            \118  XX(ENAMETOOLONG, "name too long")                                           \119  XX(ENETDOWN, "network is down")                                             \120  XX(ENETUNREACH, "network is unreachable")                                   \121  XX(ENFILE, "file table overflow")                                           \122  XX(ENOBUFS, "no buffer space available")                                    \123  XX(ENODEV, "no such device")                                                \124  XX(ENOENT, "no such file or directory")                                     \125  XX(ENOMEM, "not enough memory")                                             \126  XX(ENONET, "machine is not on the network")                                 \127  XX(ENOPROTOOPT, "protocol not available")                                   \128  XX(ENOSPC, "no space left on device")                                       \129  XX(ENOSYS, "function not implemented")                                      \130  XX(ENOTCONN, "socket is not connected")                                     \131  XX(ENOTDIR, "not a directory")                                              \132  XX(ENOTEMPTY, "directory not empty")                                        \133  XX(ENOTSOCK, "socket operation on non-socket")                              \134  XX(ENOTSUP, "operation not supported on socket")                            \135  XX(EOVERFLOW, "value too large for defined data type")                      \136  XX(EPERM, "operation not permitted")                                        \137  XX(EPIPE, "broken pipe")                                                    \138  XX(EPROTO, "protocol error")                                                \139  XX(EPROTONOSUPPORT, "protocol not supported")                               \140  XX(EPROTOTYPE, "protocol wrong type for socket")                            \141  XX(ERANGE, "result too large")                                              \142  XX(EROFS, "read-only file system")                                          \143  XX(ESHUTDOWN, "cannot send after transport endpoint shutdown")              \144  XX(ESPIPE, "invalid seek")                                                  \145  XX(ESRCH, "no such process")                                                \146  XX(ETIMEDOUT, "connection timed out")                                       \147  XX(ETXTBSY, "text file is busy")                                            \148  XX(EXDEV, "cross-device link not permitted")                                \149  XX(UNKNOWN, "unknown error")                                                \150  XX(EOF, "end of file")                                                      \151  XX(ENXIO, "no such device or address")                                      \152  XX(EMLINK, "too many links")                                                \153  XX(EHOSTDOWN, "host is down")                                               \154  XX(EREMOTEIO, "remote I/O error")                                           \155  XX(ENOTTY, "inappropriate ioctl for device")                                \156  XX(EFTYPE, "inappropriate file type or format")                             \157  XX(EILSEQ, "illegal byte sequence")                                         \158  XX(ESOCKTNOSUPPORT, "socket type not supported")                            \159  XX(ENODATA, "no data available")                                            \160  XX(EUNATCH, "protocol driver not attached")                                 \161  XX(ENOEXEC, "exec format error")                                            \162 163#define UV_HANDLE_TYPE_MAP(XX)                                                \164  XX(ASYNC, async)                                                            \165  XX(CHECK, check)                                                            \166  XX(FS_EVENT, fs_event)                                                      \167  XX(FS_POLL, fs_poll)                                                        \168  XX(HANDLE, handle)                                                          \169  XX(IDLE, idle)                                                              \170  XX(NAMED_PIPE, pipe)                                                        \171  XX(POLL, poll)                                                              \172  XX(PREPARE, prepare)                                                        \173  XX(PROCESS, process)                                                        \174  XX(STREAM, stream)                                                          \175  XX(TCP, tcp)                                                                \176  XX(TIMER, timer)                                                            \177  XX(TTY, tty)                                                                \178  XX(UDP, udp)                                                                \179  XX(SIGNAL, signal)                                                          \180 181#define UV_REQ_TYPE_MAP(XX)                                                   \182  XX(REQ, req)                                                                \183  XX(CONNECT, connect)                                                        \184  XX(WRITE, write)                                                            \185  XX(SHUTDOWN, shutdown)                                                      \186  XX(UDP_SEND, udp_send)                                                      \187  XX(FS, fs)                                                                  \188  XX(WORK, work)                                                              \189  XX(GETADDRINFO, getaddrinfo)                                                \190  XX(GETNAMEINFO, getnameinfo)                                                \191  XX(RANDOM, random)                                                          \192 193typedef enum {194#define XX(code, _) UV_ ## code = UV__ ## code,195  UV_ERRNO_MAP(XX)196#undef XX197  UV_ERRNO_MAX = UV__EOF - 1198} uv_errno_t;199 200typedef enum {201  UV_UNKNOWN_HANDLE = 0,202#define XX(uc, lc) UV_##uc,203  UV_HANDLE_TYPE_MAP(XX)204#undef XX205  UV_FILE,206  UV_HANDLE_TYPE_MAX207} uv_handle_type;208 209typedef enum {210  UV_UNKNOWN_REQ = 0,211#define XX(uc, lc) UV_##uc,212  UV_REQ_TYPE_MAP(XX)213#undef XX214  UV_REQ_TYPE_PRIVATE215  UV_REQ_TYPE_MAX216} uv_req_type;217 218 219/* Handle types. */220typedef struct uv_loop_s uv_loop_t;221typedef struct uv_handle_s uv_handle_t;222typedef struct uv_dir_s uv_dir_t;223typedef struct uv_stream_s uv_stream_t;224typedef struct uv_tcp_s uv_tcp_t;225typedef struct uv_udp_s uv_udp_t;226typedef struct uv_pipe_s uv_pipe_t;227typedef struct uv_tty_s uv_tty_t;228typedef struct uv_poll_s uv_poll_t;229typedef struct uv_timer_s uv_timer_t;230typedef struct uv_prepare_s uv_prepare_t;231typedef struct uv_check_s uv_check_t;232typedef struct uv_idle_s uv_idle_t;233typedef struct uv_async_s uv_async_t;234typedef struct uv_process_s uv_process_t;235typedef struct uv_fs_event_s uv_fs_event_t;236typedef struct uv_fs_poll_s uv_fs_poll_t;237typedef struct uv_signal_s uv_signal_t;238 239/* Request types. */240typedef struct uv_req_s uv_req_t;241typedef struct uv_getaddrinfo_s uv_getaddrinfo_t;242typedef struct uv_getnameinfo_s uv_getnameinfo_t;243typedef struct uv_shutdown_s uv_shutdown_t;244typedef struct uv_write_s uv_write_t;245typedef struct uv_connect_s uv_connect_t;246typedef struct uv_udp_send_s uv_udp_send_t;247typedef struct uv_fs_s uv_fs_t;248typedef struct uv_work_s uv_work_t;249typedef struct uv_random_s uv_random_t;250 251/* None of the above. */252typedef struct uv_env_item_s uv_env_item_t;253typedef struct uv_cpu_info_s uv_cpu_info_t;254typedef struct uv_interface_address_s uv_interface_address_t;255typedef struct uv_dirent_s uv_dirent_t;256typedef struct uv_passwd_s uv_passwd_t;257typedef struct uv_group_s uv_group_t;258typedef struct uv_utsname_s uv_utsname_t;259typedef struct uv_statfs_s uv_statfs_t;260 261typedef struct uv_metrics_s uv_metrics_t;262 263typedef enum {264  UV_LOOP_BLOCK_SIGNAL = 0,265  UV_METRICS_IDLE_TIME,266  UV_LOOP_USE_IO_URING_SQPOLL267#define UV_LOOP_USE_IO_URING_SQPOLL UV_LOOP_USE_IO_URING_SQPOLL268} uv_loop_option;269 270typedef enum {271  UV_RUN_DEFAULT = 0,272  UV_RUN_ONCE,273  UV_RUN_NOWAIT274} uv_run_mode;275 276 277UV_EXTERN unsigned int uv_version(void);278UV_EXTERN const char* uv_version_string(void);279 280typedef void* (*uv_malloc_func)(size_t size);281typedef void* (*uv_realloc_func)(void* ptr, size_t size);282typedef void* (*uv_calloc_func)(size_t count, size_t size);283typedef void (*uv_free_func)(void* ptr);284 285UV_EXTERN void uv_library_shutdown(void);286 287UV_EXTERN int uv_replace_allocator(uv_malloc_func malloc_func,288                                   uv_realloc_func realloc_func,289                                   uv_calloc_func calloc_func,290                                   uv_free_func free_func);291 292UV_EXTERN uv_loop_t* uv_default_loop(void);293UV_EXTERN int uv_loop_init(uv_loop_t* loop);294UV_EXTERN int uv_loop_close(uv_loop_t* loop);295/*296 * NOTE:297 *  This function is DEPRECATED, users should298 *  allocate the loop manually and use uv_loop_init instead.299 */300UV_EXTERN uv_loop_t* uv_loop_new(void);301/*302 * NOTE:303 *  This function is DEPRECATED. Users should use304 *  uv_loop_close and free the memory manually instead.305 */306UV_EXTERN void uv_loop_delete(uv_loop_t*);307UV_EXTERN size_t uv_loop_size(void);308UV_EXTERN int uv_loop_alive(const uv_loop_t* loop);309UV_EXTERN int uv_loop_configure(uv_loop_t* loop, uv_loop_option option, ...);310UV_EXTERN int uv_loop_fork(uv_loop_t* loop);311 312UV_EXTERN int uv_run(uv_loop_t*, uv_run_mode mode);313UV_EXTERN void uv_stop(uv_loop_t*);314 315UV_EXTERN void uv_ref(uv_handle_t*);316UV_EXTERN void uv_unref(uv_handle_t*);317UV_EXTERN int uv_has_ref(const uv_handle_t*);318 319UV_EXTERN void uv_update_time(uv_loop_t*);320UV_EXTERN uint64_t uv_now(const uv_loop_t*);321 322UV_EXTERN int uv_backend_fd(const uv_loop_t*);323UV_EXTERN int uv_backend_timeout(const uv_loop_t*);324 325typedef void (*uv_alloc_cb)(uv_handle_t* handle,326                            size_t suggested_size,327                            uv_buf_t* buf);328typedef void (*uv_read_cb)(uv_stream_t* stream,329                           ssize_t nread,330                           const uv_buf_t* buf);331typedef void (*uv_write_cb)(uv_write_t* req, int status);332typedef void (*uv_connect_cb)(uv_connect_t* req, int status);333typedef void (*uv_shutdown_cb)(uv_shutdown_t* req, int status);334typedef void (*uv_connection_cb)(uv_stream_t* server, int status);335typedef void (*uv_close_cb)(uv_handle_t* handle);336typedef void (*uv_poll_cb)(uv_poll_t* handle, int status, int events);337typedef void (*uv_timer_cb)(uv_timer_t* handle);338typedef void (*uv_async_cb)(uv_async_t* handle);339typedef void (*uv_prepare_cb)(uv_prepare_t* handle);340typedef void (*uv_check_cb)(uv_check_t* handle);341typedef void (*uv_idle_cb)(uv_idle_t* handle);342typedef void (*uv_exit_cb)(uv_process_t*, int64_t exit_status, int term_signal);343typedef void (*uv_walk_cb)(uv_handle_t* handle, void* arg);344typedef void (*uv_fs_cb)(uv_fs_t* req);345typedef void (*uv_work_cb)(uv_work_t* req);346typedef void (*uv_after_work_cb)(uv_work_t* req, int status);347typedef void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* req,348                                  int status,349                                  struct addrinfo* res);350typedef void (*uv_getnameinfo_cb)(uv_getnameinfo_t* req,351                                  int status,352                                  const char* hostname,353                                  const char* service);354typedef void (*uv_random_cb)(uv_random_t* req,355                             int status,356                             void* buf,357                             size_t buflen);358 359typedef enum {360  UV_CLOCK_MONOTONIC,361  UV_CLOCK_REALTIME362} uv_clock_id;363 364/* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 */365typedef struct {366  long tv_sec;367  long tv_nsec;368} uv_timespec_t;369 370typedef struct {371  int64_t tv_sec;372  int32_t tv_nsec;373} uv_timespec64_t;374 375/* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 */376typedef struct {377  long tv_sec;378  long tv_usec;379} uv_timeval_t;380 381typedef struct {382  int64_t tv_sec;383  int32_t tv_usec;384} uv_timeval64_t;385 386typedef struct {387  uint64_t st_dev;388  uint64_t st_mode;389  uint64_t st_nlink;390  uint64_t st_uid;391  uint64_t st_gid;392  uint64_t st_rdev;393  uint64_t st_ino;394  uint64_t st_size;395  uint64_t st_blksize;396  uint64_t st_blocks;397  uint64_t st_flags;398  uint64_t st_gen;399  uv_timespec_t st_atim;400  uv_timespec_t st_mtim;401  uv_timespec_t st_ctim;402  uv_timespec_t st_birthtim;403} uv_stat_t;404 405 406typedef void (*uv_fs_event_cb)(uv_fs_event_t* handle,407                               const char* filename,408                               int events,409                               int status);410 411typedef void (*uv_fs_poll_cb)(uv_fs_poll_t* handle,412                              int status,413                              const uv_stat_t* prev,414                              const uv_stat_t* curr);415 416typedef void (*uv_signal_cb)(uv_signal_t* handle, int signum);417 418 419typedef enum {420  UV_LEAVE_GROUP = 0,421  UV_JOIN_GROUP422} uv_membership;423 424 425UV_EXTERN int uv_translate_sys_error(int sys_errno);426 427UV_EXTERN const char* uv_strerror(int err);428UV_EXTERN char* uv_strerror_r(int err, char* buf, size_t buflen);429 430UV_EXTERN const char* uv_err_name(int err);431UV_EXTERN char* uv_err_name_r(int err, char* buf, size_t buflen);432 433 434#define UV_REQ_FIELDS                                                         \435  /* public */                                                                \436  void* data;                                                                 \437  /* read-only */                                                             \438  uv_req_type type;                                                           \439  /* private */                                                               \440  void* reserved[6];                                                          \441  UV_REQ_PRIVATE_FIELDS                                                       \442 443/* Abstract base class of all requests. */444struct uv_req_s {445  UV_REQ_FIELDS446};447 448 449/* Platform-specific request types. */450UV_PRIVATE_REQ_TYPES451 452 453UV_EXTERN int uv_shutdown(uv_shutdown_t* req,454                          uv_stream_t* handle,455                          uv_shutdown_cb cb);456 457struct uv_shutdown_s {458  UV_REQ_FIELDS459  uv_stream_t* handle;460  uv_shutdown_cb cb;461  UV_SHUTDOWN_PRIVATE_FIELDS462};463 464 465#define UV_HANDLE_FIELDS                                                      \466  /* public */                                                                \467  void* data;                                                                 \468  /* read-only */                                                             \469  uv_loop_t* loop;                                                            \470  uv_handle_type type;                                                        \471  /* private */                                                               \472  uv_close_cb close_cb;                                                       \473  struct uv__queue handle_queue;                                              \474  union {                                                                     \475    int fd;                                                                   \476    void* reserved[4];                                                        \477  } u;                                                                        \478  UV_HANDLE_PRIVATE_FIELDS                                                    \479 480/* The abstract base class of all handles. */481struct uv_handle_s {482  UV_HANDLE_FIELDS483};484 485UV_EXTERN size_t uv_handle_size(uv_handle_type type);486UV_EXTERN uv_handle_type uv_handle_get_type(const uv_handle_t* handle);487UV_EXTERN const char* uv_handle_type_name(uv_handle_type type);488UV_EXTERN void* uv_handle_get_data(const uv_handle_t* handle);489UV_EXTERN uv_loop_t* uv_handle_get_loop(const uv_handle_t* handle);490UV_EXTERN void uv_handle_set_data(uv_handle_t* handle, void* data);491 492UV_EXTERN size_t uv_req_size(uv_req_type type);493UV_EXTERN void* uv_req_get_data(const uv_req_t* req);494UV_EXTERN void uv_req_set_data(uv_req_t* req, void* data);495UV_EXTERN uv_req_type uv_req_get_type(const uv_req_t* req);496UV_EXTERN const char* uv_req_type_name(uv_req_type type);497 498UV_EXTERN int uv_is_active(const uv_handle_t* handle);499 500UV_EXTERN void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg);501 502/* Helpers for ad hoc debugging, no API/ABI stability guaranteed. */503UV_EXTERN void uv_print_all_handles(uv_loop_t* loop, FILE* stream);504UV_EXTERN void uv_print_active_handles(uv_loop_t* loop, FILE* stream);505 506UV_EXTERN void uv_close(uv_handle_t* handle, uv_close_cb close_cb);507 508UV_EXTERN int uv_send_buffer_size(uv_handle_t* handle, int* value);509UV_EXTERN int uv_recv_buffer_size(uv_handle_t* handle, int* value);510 511UV_EXTERN int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd);512 513UV_EXTERN uv_buf_t uv_buf_init(char* base, unsigned int len);514 515UV_EXTERN int uv_pipe(uv_file fds[2], int read_flags, int write_flags);516UV_EXTERN int uv_socketpair(int type,517                            int protocol,518                            uv_os_sock_t socket_vector[2],519                            int flags0,520                            int flags1);521 522#define UV_STREAM_FIELDS                                                      \523  /* number of bytes queued for writing */                                    \524  size_t write_queue_size;                                                    \525  uv_alloc_cb alloc_cb;                                                       \526  uv_read_cb read_cb;                                                         \527  /* private */                                                               \528  UV_STREAM_PRIVATE_FIELDS529 530/*531 * uv_stream_t is a subclass of uv_handle_t.532 *533 * uv_stream is an abstract class.534 *535 * uv_stream_t is the parent class of uv_tcp_t, uv_pipe_t and uv_tty_t.536 */537struct uv_stream_s {538  UV_HANDLE_FIELDS539  UV_STREAM_FIELDS540};541 542UV_EXTERN size_t uv_stream_get_write_queue_size(const uv_stream_t* stream);543 544UV_EXTERN int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb);545UV_EXTERN int uv_accept(uv_stream_t* server, uv_stream_t* client);546 547UV_EXTERN int uv_read_start(uv_stream_t*,548                            uv_alloc_cb alloc_cb,549                            uv_read_cb read_cb);550UV_EXTERN int uv_read_stop(uv_stream_t*);551 552UV_EXTERN int uv_write(uv_write_t* req,553                       uv_stream_t* handle,554                       const uv_buf_t bufs[],555                       unsigned int nbufs,556                       uv_write_cb cb);557UV_EXTERN int uv_write2(uv_write_t* req,558                        uv_stream_t* handle,559                        const uv_buf_t bufs[],560                        unsigned int nbufs,561                        uv_stream_t* send_handle,562                        uv_write_cb cb);563UV_EXTERN int uv_try_write(uv_stream_t* handle,564                           const uv_buf_t bufs[],565                           unsigned int nbufs);566UV_EXTERN int uv_try_write2(uv_stream_t* handle,567                            const uv_buf_t bufs[],568                            unsigned int nbufs,569                            uv_stream_t* send_handle);570 571/* uv_write_t is a subclass of uv_req_t. */572struct uv_write_s {573  UV_REQ_FIELDS574  uv_write_cb cb;575  uv_stream_t* send_handle; /* TODO: make private and unix-only in v2.x. */576  uv_stream_t* handle;577  UV_WRITE_PRIVATE_FIELDS578};579 580 581UV_EXTERN int uv_is_readable(const uv_stream_t* handle);582UV_EXTERN int uv_is_writable(const uv_stream_t* handle);583 584UV_EXTERN int uv_stream_set_blocking(uv_stream_t* handle, int blocking);585 586UV_EXTERN int uv_is_closing(const uv_handle_t* handle);587 588 589/*590 * uv_tcp_t is a subclass of uv_stream_t.591 *592 * Represents a TCP stream or TCP server.593 */594struct uv_tcp_s {595  UV_HANDLE_FIELDS596  UV_STREAM_FIELDS597  UV_TCP_PRIVATE_FIELDS598};599 600UV_EXTERN int uv_tcp_init(uv_loop_t*, uv_tcp_t* handle);601UV_EXTERN int uv_tcp_init_ex(uv_loop_t*, uv_tcp_t* handle, unsigned int flags);602UV_EXTERN int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock);603UV_EXTERN int uv_tcp_nodelay(uv_tcp_t* handle, int enable);604UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle,605                               int enable,606                               unsigned int delay);607UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable);608 609enum uv_tcp_flags {610  /* Used with uv_tcp_bind, when an IPv6 address is used. */611  UV_TCP_IPV6ONLY = 1,612 613  /* Enable SO_REUSEPORT socket option when binding the handle.614   * This allows completely duplicate bindings by multiple processes615   * or threads if they all set SO_REUSEPORT before binding the port.616   * Incoming connections are distributed across the participating617   * listener sockets.618   *619   * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+,620   * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now.621   */622  UV_TCP_REUSEPORT = 2,623};624 625UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle,626                          const struct sockaddr* addr,627                          unsigned int flags);628UV_EXTERN int uv_tcp_getsockname(const uv_tcp_t* handle,629                                 struct sockaddr* name,630                                 int* namelen);631UV_EXTERN int uv_tcp_getpeername(const uv_tcp_t* handle,632                                 struct sockaddr* name,633                                 int* namelen);634UV_EXTERN int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb);635UV_EXTERN int uv_tcp_connect(uv_connect_t* req,636                             uv_tcp_t* handle,637                             const struct sockaddr* addr,638                             uv_connect_cb cb);639 640/* uv_connect_t is a subclass of uv_req_t. */641struct uv_connect_s {642  UV_REQ_FIELDS643  uv_connect_cb cb;644  uv_stream_t* handle;645  UV_CONNECT_PRIVATE_FIELDS646};647 648 649/*650 * UDP support.651 */652 653enum uv_udp_flags {654  /* Disables dual stack mode. */655  UV_UDP_IPV6ONLY = 1,656  /*657   * Indicates message was truncated because read buffer was too small. The658   * remainder was discarded by the OS. Used in uv_udp_recv_cb.659   */660  UV_UDP_PARTIAL = 2,661  /*662   * Indicates if SO_REUSEADDR will be set when binding the handle.663   * This sets the SO_REUSEPORT socket flag on the BSDs (except for664   * DragonFlyBSD), OS X, and other platforms where SO_REUSEPORTs don't665   * have the capability of load balancing, as the opposite of what666   * UV_UDP_REUSEPORT would do. On other Unix platforms, it sets the667   * SO_REUSEADDR flag. What that means is that multiple threads or668   * processes can bind to the same address without error (provided669   * they all set the flag) but only the last one to bind will receive670   * any traffic, in effect "stealing" the port from the previous listener.671   */672  UV_UDP_REUSEADDR = 4,673  /*674   * Indicates that the message was received by recvmmsg, so the buffer provided675   * must not be freed by the recv_cb callback.676   */677  UV_UDP_MMSG_CHUNK = 8,678  /*679   * Indicates that the buffer provided has been fully utilized by recvmmsg and680   * that it should now be freed by the recv_cb callback. When this flag is set681   * in uv_udp_recv_cb, nread will always be 0 and addr will always be NULL.682   */683  UV_UDP_MMSG_FREE = 16,684  /*685   * Indicates if IP_RECVERR/IPV6_RECVERR will be set when binding the handle.686   * This sets IP_RECVERR for IPv4 and IPV6_RECVERR for IPv6 UDP sockets on687   * Linux. This stops the Linux kernel from suppressing some ICMP error688   * messages and enables full ICMP error reporting for faster failover.689   * This flag is no-op on platforms other than Linux.690   */691  UV_UDP_LINUX_RECVERR = 32,692  /*693   * Indicates if SO_REUSEPORT will be set when binding the handle.694   * This sets the SO_REUSEPORT socket option on supported platforms.695   * Unlike UV_UDP_REUSEADDR, this flag will make multiple threads or696   * processes that are binding to the same address and port "share"697   * the port, which means incoming datagrams are distributed across698   * the receiving sockets among threads or processes.699   *700   * This flag is available only on Linux 3.9+, DragonFlyBSD 3.6+,701   * FreeBSD 12.0+, Solaris 11.4, and AIX 7.2.5+ for now.702   */703  UV_UDP_REUSEPORT = 64,704  /*705   * Indicates that recvmmsg should be used, if available.706   */707  UV_UDP_RECVMMSG = 256708};709 710typedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status);711typedef void (*uv_udp_recv_cb)(uv_udp_t* handle,712                               ssize_t nread,713                               const uv_buf_t* buf,714                               const struct sockaddr* addr,715                               unsigned flags);716 717/* uv_udp_t is a subclass of uv_handle_t. */718struct uv_udp_s {719  UV_HANDLE_FIELDS720  /* read-only */721  /*722   * Number of bytes queued for sending. This field strictly shows how much723   * information is currently queued.724   */725  size_t send_queue_size;726  /*727   * Number of send requests currently in the queue awaiting to be processed.728   */729  size_t send_queue_count;730  UV_UDP_PRIVATE_FIELDS731};732 733/* uv_udp_send_t is a subclass of uv_req_t. */734struct uv_udp_send_s {735  UV_REQ_FIELDS736  uv_udp_t* handle;737  uv_udp_send_cb cb;738  UV_UDP_SEND_PRIVATE_FIELDS739};740 741UV_EXTERN int uv_udp_init(uv_loop_t*, uv_udp_t* handle);742UV_EXTERN int uv_udp_init_ex(uv_loop_t*, uv_udp_t* handle, unsigned int flags);743UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock);744UV_EXTERN int uv_udp_bind(uv_udp_t* handle,745                          const struct sockaddr* addr,746                          unsigned int flags);747UV_EXTERN int uv_udp_connect(uv_udp_t* handle, const struct sockaddr* addr);748 749UV_EXTERN int uv_udp_getpeername(const uv_udp_t* handle,750                                 struct sockaddr* name,751                                 int* namelen);752UV_EXTERN int uv_udp_getsockname(const uv_udp_t* handle,753                                 struct sockaddr* name,754                                 int* namelen);755UV_EXTERN int uv_udp_set_membership(uv_udp_t* handle,756                                    const char* multicast_addr,757                                    const char* interface_addr,758                                    uv_membership membership);759UV_EXTERN int uv_udp_set_source_membership(uv_udp_t* handle,760                                           const char* multicast_addr,761                                           const char* interface_addr,762                                           const char* source_addr,763                                           uv_membership membership);764UV_EXTERN int uv_udp_set_multicast_loop(uv_udp_t* handle, int on);765UV_EXTERN int uv_udp_set_multicast_ttl(uv_udp_t* handle, int ttl);766UV_EXTERN int uv_udp_set_multicast_interface(uv_udp_t* handle,767                                             const char* interface_addr);768UV_EXTERN int uv_udp_set_broadcast(uv_udp_t* handle, int on);769UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl);770UV_EXTERN int uv_udp_send(uv_udp_send_t* req,771                          uv_udp_t* handle,772                          const uv_buf_t bufs[],773                          unsigned int nbufs,774                          const struct sockaddr* addr,775                          uv_udp_send_cb send_cb);776UV_EXTERN int uv_udp_try_send(uv_udp_t* handle,777                              const uv_buf_t bufs[],778                              unsigned int nbufs,779                              const struct sockaddr* addr);780UV_EXTERN int uv_udp_try_send2(uv_udp_t* handle,781                               unsigned int count,782                               uv_buf_t* bufs[/*count*/],783                               unsigned int nbufs[/*count*/],784                               struct sockaddr* addrs[/*count*/],785                               unsigned int flags);786UV_EXTERN int uv_udp_recv_start(uv_udp_t* handle,787                                uv_alloc_cb alloc_cb,788                                uv_udp_recv_cb recv_cb);789UV_EXTERN int uv_udp_using_recvmmsg(const uv_udp_t* handle);790UV_EXTERN int uv_udp_recv_stop(uv_udp_t* handle);791UV_EXTERN size_t uv_udp_get_send_queue_size(const uv_udp_t* handle);792UV_EXTERN size_t uv_udp_get_send_queue_count(const uv_udp_t* handle);793 794 795/*796 * uv_tty_t is a subclass of uv_stream_t.797 *798 * Representing a stream for the console.799 */800struct uv_tty_s {801  UV_HANDLE_FIELDS802  UV_STREAM_FIELDS803  UV_TTY_PRIVATE_FIELDS804};805 806typedef enum {807  /* Initial/normal terminal mode */808  UV_TTY_MODE_NORMAL,809  /*810   * Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled).811   * May become equivalent to UV_TTY_MODE_RAW_VT in future libuv versions.812   */813  UV_TTY_MODE_RAW,814  /* Binary-safe I/O mode for IPC (Unix-only) */815  UV_TTY_MODE_IO,816  /* Raw input mode. On Windows ENABLE_VIRTUAL_TERMINAL_INPUT is also set. */817  UV_TTY_MODE_RAW_VT818} uv_tty_mode_t;819 820typedef enum {821  /*822   * The console supports handling of virtual terminal sequences823   * (Windows10 new console, ConEmu)824   */825  UV_TTY_SUPPORTED,826  /* The console cannot process the virtual terminal sequence.  (Legacy827   * console)828   */829  UV_TTY_UNSUPPORTED830} uv_tty_vtermstate_t;831 832 833UV_EXTERN int uv_tty_init(uv_loop_t*, uv_tty_t*, uv_file fd, int readable);834UV_EXTERN int uv_tty_set_mode(uv_tty_t*, uv_tty_mode_t mode);835UV_EXTERN int uv_tty_reset_mode(void);836UV_EXTERN int uv_tty_get_winsize(uv_tty_t*, int* width, int* height);837UV_EXTERN void uv_tty_set_vterm_state(uv_tty_vtermstate_t state);838UV_EXTERN int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state);839 840#ifdef __cplusplus841extern "C++" {842 843inline int uv_tty_set_mode(uv_tty_t* handle, int mode) {844  return uv_tty_set_mode(handle, static_cast<uv_tty_mode_t>(mode));845}846 847}848#endif849 850UV_EXTERN uv_handle_type uv_guess_handle(uv_file file);851 852enum {853  UV_PIPE_NO_TRUNCATE = 1u << 0854};855 856/*857 * uv_pipe_t is a subclass of uv_stream_t.858 *859 * Representing a pipe stream or pipe server. On Windows this is a Named860 * Pipe. On Unix this is a Unix domain socket.861 */862struct uv_pipe_s {863  UV_HANDLE_FIELDS864  UV_STREAM_FIELDS865  int ipc; /* non-zero if this pipe is used for passing handles */866  UV_PIPE_PRIVATE_FIELDS867};868 869UV_EXTERN int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle, int ipc);870UV_EXTERN int uv_pipe_open(uv_pipe_t*, uv_file file);871UV_EXTERN int uv_pipe_bind(uv_pipe_t* handle, const char* name);872UV_EXTERN int uv_pipe_bind2(uv_pipe_t* handle,873                            const char* name,874                            size_t namelen,875                            unsigned int flags);876UV_EXTERN void uv_pipe_connect(uv_connect_t* req,877                               uv_pipe_t* handle,878                               const char* name,879                               uv_connect_cb cb);880UV_EXTERN int uv_pipe_connect2(uv_connect_t* req,881                               uv_pipe_t* handle,882                               const char* name,883                               size_t namelen,884                               unsigned int flags,885                               uv_connect_cb cb);886UV_EXTERN int uv_pipe_getsockname(const uv_pipe_t* handle,887                                  char* buffer,888                                  size_t* size);889UV_EXTERN int uv_pipe_getpeername(const uv_pipe_t* handle,890                                  char* buffer,891                                  size_t* size);892UV_EXTERN void uv_pipe_pending_instances(uv_pipe_t* handle, int count);893UV_EXTERN int uv_pipe_pending_count(uv_pipe_t* handle);894UV_EXTERN uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle);895UV_EXTERN int uv_pipe_chmod(uv_pipe_t* handle, int flags);896 897 898struct uv_poll_s {899  UV_HANDLE_FIELDS900  uv_poll_cb poll_cb;901  UV_POLL_PRIVATE_FIELDS902};903 904enum uv_poll_event {905  UV_READABLE = 1,906  UV_WRITABLE = 2,907  UV_DISCONNECT = 4,908  UV_PRIORITIZED = 8909};910 911UV_EXTERN int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd);912UV_EXTERN int uv_poll_init_socket(uv_loop_t* loop,913                                  uv_poll_t* handle,914                                  uv_os_sock_t socket);915UV_EXTERN int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb);916UV_EXTERN int uv_poll_stop(uv_poll_t* handle);917 918 919struct uv_prepare_s {920  UV_HANDLE_FIELDS921  UV_PREPARE_PRIVATE_FIELDS922};923 924UV_EXTERN int uv_prepare_init(uv_loop_t*, uv_prepare_t* prepare);925UV_EXTERN int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb);926UV_EXTERN int uv_prepare_stop(uv_prepare_t* prepare);927 928 929struct uv_check_s {930  UV_HANDLE_FIELDS931  UV_CHECK_PRIVATE_FIELDS932};933 934UV_EXTERN int uv_check_init(uv_loop_t*, uv_check_t* check);935UV_EXTERN int uv_check_start(uv_check_t* check, uv_check_cb cb);936UV_EXTERN int uv_check_stop(uv_check_t* check);937 938 939struct uv_idle_s {940  UV_HANDLE_FIELDS941  UV_IDLE_PRIVATE_FIELDS942};943 944UV_EXTERN int uv_idle_init(uv_loop_t*, uv_idle_t* idle);945UV_EXTERN int uv_idle_start(uv_idle_t* idle, uv_idle_cb cb);946UV_EXTERN int uv_idle_stop(uv_idle_t* idle);947 948 949struct uv_async_s {950  UV_HANDLE_FIELDS951  UV_ASYNC_PRIVATE_FIELDS952};953 954UV_EXTERN int uv_async_init(uv_loop_t*,955                            uv_async_t* async,956                            uv_async_cb async_cb);957UV_EXTERN int uv_async_send(uv_async_t* async);958 959 960/*961 * uv_timer_t is a subclass of uv_handle_t.962 *963 * Used to get woken up at a specified time in the future.964 */965struct uv_timer_s {966  UV_HANDLE_FIELDS967  UV_TIMER_PRIVATE_FIELDS968};969 970UV_EXTERN int uv_timer_init(uv_loop_t*, uv_timer_t* handle);971UV_EXTERN int uv_timer_start(uv_timer_t* handle,972                             uv_timer_cb cb,973                             uint64_t timeout,974                             uint64_t repeat);975UV_EXTERN int uv_timer_stop(uv_timer_t* handle);976UV_EXTERN int uv_timer_again(uv_timer_t* handle);977UV_EXTERN void uv_timer_set_repeat(uv_timer_t* handle, uint64_t repeat);978UV_EXTERN uint64_t uv_timer_get_repeat(const uv_timer_t* handle);979UV_EXTERN uint64_t uv_timer_get_due_in(const uv_timer_t* handle);980 981 982/*983 * uv_getaddrinfo_t is a subclass of uv_req_t.984 *985 * Request object for uv_getaddrinfo.986 */987struct uv_getaddrinfo_s {988  UV_REQ_FIELDS989  /* read-only */990  uv_loop_t* loop;991  /* struct addrinfo* addrinfo is marked as private, but it really isn't. */992  UV_GETADDRINFO_PRIVATE_FIELDS993};994 995 996UV_EXTERN int uv_getaddrinfo(uv_loop_t* loop,997                             uv_getaddrinfo_t* req,998                             uv_getaddrinfo_cb getaddrinfo_cb,999                             const char* node,1000                             const char* service,1001                             const struct addrinfo* hints);1002UV_EXTERN void uv_freeaddrinfo(struct addrinfo* ai);1003 1004 1005/*1006* uv_getnameinfo_t is a subclass of uv_req_t.1007*1008* Request object for uv_getnameinfo.1009*/1010struct uv_getnameinfo_s {1011  UV_REQ_FIELDS1012  /* read-only */1013  uv_loop_t* loop;1014  /* host and service are marked as private, but they really aren't. */1015  UV_GETNAMEINFO_PRIVATE_FIELDS1016};1017 1018UV_EXTERN int uv_getnameinfo(uv_loop_t* loop,1019                             uv_getnameinfo_t* req,1020                             uv_getnameinfo_cb getnameinfo_cb,1021                             const struct sockaddr* addr,1022                             int flags);1023 1024 1025/* uv_spawn() options. */1026typedef enum {1027  UV_IGNORE         = 0x00,1028  UV_CREATE_PIPE    = 0x01,1029  UV_INHERIT_FD     = 0x02,1030  UV_INHERIT_STREAM = 0x04,1031 1032  /*1033   * When UV_CREATE_PIPE is specified, UV_READABLE_PIPE and UV_WRITABLE_PIPE1034   * determine the direction of flow, from the child process' perspective. Both1035   * flags may be specified to create a duplex data stream.1036   */1037  UV_READABLE_PIPE  = 0x10,1038  UV_WRITABLE_PIPE  = 0x20,1039 1040  /*1041   * When UV_CREATE_PIPE is specified, specifying UV_NONBLOCK_PIPE opens the1042   * handle in non-blocking mode in the child. This may cause loss of data,1043   * if the child is not designed to handle to encounter this mode,1044   * but can also be significantly more efficient.1045   */1046  UV_NONBLOCK_PIPE  = 0x40,1047  UV_OVERLAPPED_PIPE = 0x40 /* old name, for compatibility */1048} uv_stdio_flags;1049 1050typedef struct uv_stdio_container_s {1051  uv_stdio_flags flags;1052 1053  union {1054    uv_stream_t* stream;1055    int fd;1056  } data;1057} uv_stdio_container_t;1058 1059typedef struct uv_process_options_s {1060  uv_exit_cb exit_cb; /* Called after the process exits. */1061  const char* file;   /* Path to program to execute. */1062  /*1063   * Command line arguments. args[0] should be the path to the program. On1064   * Windows this uses CreateProcess which concatenates the arguments into a1065   * string this can cause some strange errors. See the note at1066   * windows_verbatim_arguments.1067   */1068  char** args;1069  /*1070   * This will be set as the environ variable in the subprocess. If this is1071   * NULL then the parents environ will be used.1072   */1073  char** env;1074  /*1075   * If non-null this represents a directory the subprocess should execute1076   * in. Stands for current working directory.1077   */1078  const char* cwd;1079  /*1080   * Various flags that control how uv_spawn() behaves. See the definition of1081   * `enum uv_process_flags` below.1082   */1083  unsigned int flags;1084  /*1085   * The `stdio` field points to an array of uv_stdio_container_t structs that1086   * describe the file descriptors that will be made available to the child1087   * process. The convention is that stdio[0] points to stdin, fd 1 is used for1088   * stdout, and fd 2 is stderr.1089   *1090   * Note that on windows file descriptors greater than 2 are available to the1091   * child process only if the child processes uses the MSVCRT runtime.1092   */1093  int stdio_count;1094  uv_stdio_container_t* stdio;1095  /*1096   * Libuv can change the child process' user/group id. This happens only when1097   * the appropriate bits are set in the flags fields. This is not supported on1098   * windows; uv_spawn() will fail and set the error to UV_ENOTSUP.1099   */1100  uv_uid_t uid;1101  uv_gid_t gid;1102} uv_process_options_t;1103 1104/*1105 * These are the flags that can be used for the uv_process_options.flags field.1106 */1107enum uv_process_flags {1108  /*1109   * Set the child process' user id. The user id is supplied in the `uid` field1110   * of the options struct. This does not work on windows; setting this flag1111   * will cause uv_spawn() to fail.1112   */1113  UV_PROCESS_SETUID = (1 << 0),1114  /*1115   * Set the child process' group id. The user id is supplied in the `gid`1116   * field of the options struct. This does not work on windows; setting this1117   * flag will cause uv_spawn() to fail.1118   */1119  UV_PROCESS_SETGID = (1 << 1),1120  /*1121   * Do not wrap any arguments in quotes, or perform any other escaping, when1122   * converting the argument list into a command line string. This option is1123   * only meaningful on Windows systems. On Unix it is silently ignored.1124   */1125  UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2),1126  /*1127   * Spawn the child process in a detached state - this will make it a process1128   * group leader, and will effectively enable the child to keep running after1129   * the parent exits.  Note that the child process will still keep the1130   * parent's event loop alive unless the parent process calls uv_unref() on1131   * the child's process handle.1132   */1133  UV_PROCESS_DETACHED = (1 << 3),1134  /*1135   * Hide the subprocess window that would normally be created. This option is1136   * only meaningful on Windows systems. On Unix it is silently ignored.1137   */1138  UV_PROCESS_WINDOWS_HIDE = (1 << 4),1139  /*1140   * Hide the subprocess console window that would normally be created. This1141   * option is only meaningful on Windows systems. On Unix it is silently1142   * ignored.1143   */1144  UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5),1145  /*1146   * Hide the subprocess GUI window that would normally be created. This1147   * option is only meaningful on Windows systems. On Unix it is silently1148   * ignored.1149   */1150  UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6),1151  /*1152   * On Windows, if the path to the program to execute, specified in1153   * uv_process_options_t's file field, has a directory component,1154   * search for the exact file name before trying variants with1155   * extensions like '.exe' or '.cmd'.1156   */1157  UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME = (1 << 7)1158};1159 1160/*1161 * uv_process_t is a subclass of uv_handle_t.1162 */1163struct uv_process_s {1164  UV_HANDLE_FIELDS1165  uv_exit_cb exit_cb;1166  int pid;1167  UV_PROCESS_PRIVATE_FIELDS1168};1169 1170UV_EXTERN int uv_spawn(uv_loop_t* loop,1171                       uv_process_t* handle,1172                       const uv_process_options_t* options);1173UV_EXTERN int uv_process_kill(uv_process_t*, int signum);1174UV_EXTERN int uv_kill(int pid, int signum);1175UV_EXTERN uv_pid_t uv_process_get_pid(const uv_process_t*);1176 1177 1178/*1179 * uv_work_t is a subclass of uv_req_t.1180 */1181struct uv_work_s {1182  UV_REQ_FIELDS1183  uv_loop_t* loop;1184  uv_work_cb work_cb;1185  uv_after_work_cb after_work_cb;1186  UV_WORK_PRIVATE_FIELDS1187};1188 1189UV_EXTERN int uv_queue_work(uv_loop_t* loop,1190                            uv_work_t* req,1191                            uv_work_cb work_cb,1192                            uv_after_work_cb after_work_cb);1193 1194UV_EXTERN int uv_cancel(uv_req_t* req);1195 1196 1197struct uv_cpu_times_s {1198  uint64_t user; /* milliseconds */1199  uint64_t nice; /* milliseconds */1200  uint64_t sys; /* milliseconds */1201  uint64_t idle; /* milliseconds */1202  uint64_t irq; /* milliseconds */1203};1204 1205struct uv_cpu_info_s {1206  char* model;1207  int speed;1208  struct uv_cpu_times_s cpu_times;1209};1210 1211struct uv_interface_address_s {1212  char* name;1213  char phys_addr[6];1214  int is_internal;1215  union {1216    struct sockaddr_in address4;1217    struct sockaddr_in6 address6;1218  } address;1219  union {1220    struct sockaddr_in netmask4;1221    struct sockaddr_in6 netmask6;1222  } netmask;1223};1224 1225struct uv_passwd_s {1226  char* username;1227  unsigned long uid;1228  unsigned long gid;1229  char* shell;1230  char* homedir;1231};1232 1233struct uv_group_s {1234  char* groupname;1235  unsigned long gid;1236  char** members;1237};1238 1239struct uv_utsname_s {1240  char sysname[256];1241  char release[256];1242  char version[256];1243  char machine[256];1244  /* This struct does not contain the nodename and domainname fields present in1245     the utsname type. domainname is a GNU extension. Both fields are referred1246     to as meaningless in the docs. */1247};1248 1249struct uv_statfs_s {1250  uint64_t f_type;1251  uint64_t f_bsize;1252  uint64_t f_blocks;1253  uint64_t f_bfree;1254  uint64_t f_bavail;1255  uint64_t f_files;1256  uint64_t f_ffree;1257  uint64_t f_spare[4];1258};1259 1260typedef enum {1261  UV_DIRENT_UNKNOWN,1262  UV_DIRENT_FILE,1263  UV_DIRENT_DIR,1264  UV_DIRENT_LINK,1265  UV_DIRENT_FIFO,1266  UV_DIRENT_SOCKET,1267  UV_DIRENT_CHAR,1268  UV_DIRENT_BLOCK1269} uv_dirent_type_t;1270 1271struct uv_dirent_s {1272  const char* name;1273  uv_dirent_type_t type;1274};1275 1276UV_EXTERN char** uv_setup_args(int argc, char** argv);1277UV_EXTERN int uv_get_process_title(char* buffer, size_t size);1278UV_EXTERN int uv_set_process_title(const char* title);1279UV_EXTERN int uv_resident_set_memory(size_t* rss);1280UV_EXTERN int uv_uptime(double* uptime);1281UV_EXTERN uv_os_fd_t uv_get_osfhandle(int fd);1282UV_EXTERN int uv_open_osfhandle(uv_os_fd_t os_fd);1283 1284typedef struct {1285   uv_timeval_t ru_utime; /* user CPU time used */1286   uv_timeval_t ru_stime; /* system CPU time used */1287   uint64_t ru_maxrss;    /* maximum resident set size */1288   uint64_t ru_ixrss;     /* integral shared memory size */1289   uint64_t ru_idrss;     /* integral unshared data size */1290   uint64_t ru_isrss;     /* integral unshared stack size */1291   uint64_t ru_minflt;    /* page reclaims (soft page faults) */1292   uint64_t ru_majflt;    /* page faults (hard page faults) */1293   uint64_t ru_nswap;     /* swaps */1294   uint64_t ru_inblock;   /* block input operations */1295   uint64_t ru_oublock;   /* block output operations */1296   uint64_t ru_msgsnd;    /* IPC messages sent */1297   uint64_t ru_msgrcv;    /* IPC messages received */1298   uint64_t ru_nsignals;  /* signals received */1299   uint64_t ru_nvcsw;     /* voluntary context switches */1300   uint64_t ru_nivcsw;    /* involuntary context switches */1301} uv_rusage_t;1302 1303UV_EXTERN int uv_getrusage(uv_rusage_t* rusage);1304UV_EXTERN int uv_getrusage_thread(uv_rusage_t* rusage);1305 1306UV_EXTERN int uv_os_homedir(char* buffer, size_t* size);1307UV_EXTERN int uv_os_tmpdir(char* buffer, size_t* size);1308UV_EXTERN int uv_os_get_passwd(uv_passwd_t* pwd);1309UV_EXTERN void uv_os_free_passwd(uv_passwd_t* pwd);1310UV_EXTERN int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid);1311UV_EXTERN int uv_os_get_group(uv_group_t* grp, uv_uid_t gid);1312UV_EXTERN void uv_os_free_group(uv_group_t* grp);1313UV_EXTERN uv_pid_t uv_os_getpid(void);1314UV_EXTERN uv_pid_t uv_os_getppid(void);1315 1316#if defined(__PASE__)1317/* On IBM i PASE, the highest process priority is -10 */1318# define UV_PRIORITY_LOW 39          /* RUNPTY(99) */1319# define UV_PRIORITY_BELOW_NORMAL 15 /* RUNPTY(50) */1320# define UV_PRIORITY_NORMAL 0        /* RUNPTY(20) */1321# define UV_PRIORITY_ABOVE_NORMAL -4 /* RUNTY(12) */1322# define UV_PRIORITY_HIGH -7         /* RUNPTY(6) */1323# define UV_PRIORITY_HIGHEST -10     /* RUNPTY(1) */1324#else1325# define UV_PRIORITY_LOW 191326# define UV_PRIORITY_BELOW_NORMAL 101327# define UV_PRIORITY_NORMAL 01328# define UV_PRIORITY_ABOVE_NORMAL -71329# define UV_PRIORITY_HIGH -141330# define UV_PRIORITY_HIGHEST -201331#endif1332 1333UV_EXTERN int uv_os_getpriority(uv_pid_t pid, int* priority);1334UV_EXTERN int uv_os_setpriority(uv_pid_t pid, int priority);1335 1336enum {1337  UV_THREAD_PRIORITY_HIGHEST = 2,1338  UV_THREAD_PRIORITY_ABOVE_NORMAL = 1,1339  UV_THREAD_PRIORITY_NORMAL = 0,1340  UV_THREAD_PRIORITY_BELOW_NORMAL = -1,1341  UV_THREAD_PRIORITY_LOWEST = -2,1342};1343 1344UV_EXTERN int uv_thread_getpriority(uv_thread_t tid, int* priority);1345UV_EXTERN int uv_thread_setpriority(uv_thread_t tid, int priority);1346 1347UV_EXTERN unsigned int uv_available_parallelism(void);1348UV_EXTERN int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count);1349UV_EXTERN void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count);1350UV_EXTERN int uv_cpumask_size(void);1351 1352UV_EXTERN int uv_interface_addresses(uv_interface_address_t** addresses,1353                                     int* count);1354UV_EXTERN void uv_free_interface_addresses(uv_interface_address_t* addresses,1355                                           int count);1356 1357struct uv_env_item_s {1358  char* name;1359  char* value;1360};1361 1362UV_EXTERN int uv_os_environ(uv_env_item_t** envitems, int* count);1363UV_EXTERN void uv_os_free_environ(uv_env_item_t* envitems, int count);1364UV_EXTERN int uv_os_getenv(const char* name, char* buffer, size_t* size);1365UV_EXTERN int uv_os_setenv(const char* name, const char* value);1366UV_EXTERN int uv_os_unsetenv(const char* name);1367 1368#ifdef MAXHOSTNAMELEN1369# define UV_MAXHOSTNAMESIZE (MAXHOSTNAMELEN + 1)1370#else1371  /*1372    Fallback for the maximum hostname size, including the null terminator. The1373    Windows gethostname() documentation states that 256 bytes will always be1374    large enough to hold the null-terminated hostname.1375  */1376# define UV_MAXHOSTNAMESIZE 2561377#endif1378 1379UV_EXTERN int uv_os_gethostname(char* buffer, size_t* size);1380 1381UV_EXTERN int uv_os_uname(uv_utsname_t* buffer);1382 1383struct uv_metrics_s {1384  uint64_t loop_count;1385  uint64_t events;1386  uint64_t events_waiting;1387  /* private */1388  uint64_t* reserved[13];1389};1390 1391UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics);1392UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop);1393 1394typedef enum {1395  UV_FS_UNKNOWN = -1,1396  UV_FS_CUSTOM,1397  UV_FS_OPEN,1398  UV_FS_CLOSE,1399  UV_FS_READ,1400  UV_FS_WRITE,1401  UV_FS_SENDFILE,1402  UV_FS_STAT,1403  UV_FS_LSTAT,1404  UV_FS_FSTAT,1405  UV_FS_FTRUNCATE,1406  UV_FS_UTIME,1407  UV_FS_FUTIME,1408  UV_FS_ACCESS,1409  UV_FS_CHMOD,1410  UV_FS_FCHMOD,1411  UV_FS_FSYNC,1412  UV_FS_FDATASYNC,1413  UV_FS_UNLINK,1414  UV_FS_RMDIR,1415  UV_FS_MKDIR,1416  UV_FS_MKDTEMP,1417  UV_FS_RENAME,1418  UV_FS_SCANDIR,1419  UV_FS_LINK,1420  UV_FS_SYMLINK,1421  UV_FS_READLINK,1422  UV_FS_CHOWN,1423  UV_FS_FCHOWN,1424  UV_FS_REALPATH,1425  UV_FS_COPYFILE,1426  UV_FS_LCHOWN,1427  UV_FS_OPENDIR,1428  UV_FS_READDIR,1429  UV_FS_CLOSEDIR,1430  UV_FS_STATFS,1431  UV_FS_MKSTEMP,1432  UV_FS_LUTIME1433} uv_fs_type;1434 1435struct uv_dir_s {1436  uv_dirent_t* dirents;1437  size_t nentries;1438  void* reserved[4];1439  UV_DIR_PRIVATE_FIELDS1440};1441 1442/* uv_fs_t is a subclass of uv_req_t. */1443struct uv_fs_s {1444  UV_REQ_FIELDS1445  uv_fs_type fs_type;1446  uv_loop_t* loop;1447  uv_fs_cb cb;1448  ssize_t result;1449  void* ptr;1450  const char* path;1451  uv_stat_t statbuf;  /* Stores the result of uv_fs_stat() and uv_fs_fstat(). */1452  UV_FS_PRIVATE_FIELDS1453};1454 1455UV_EXTERN uv_fs_type uv_fs_get_type(const uv_fs_t*);1456UV_EXTERN ssize_t uv_fs_get_result(const uv_fs_t*);1457UV_EXTERN int uv_fs_get_system_error(const uv_fs_t*);1458UV_EXTERN void* uv_fs_get_ptr(const uv_fs_t*);1459UV_EXTERN const char* uv_fs_get_path(const uv_fs_t*);1460UV_EXTERN uv_stat_t* uv_fs_get_statbuf(uv_fs_t*);1461 1462UV_EXTERN void uv_fs_req_cleanup(uv_fs_t* req);1463UV_EXTERN int uv_fs_close(uv_loop_t* loop,1464                          uv_fs_t* req,1465                          uv_file file,1466                          uv_fs_cb cb);1467UV_EXTERN int uv_fs_open(uv_loop_t* loop,1468                         uv_fs_t* req,1469                         const char* path,1470                         int flags,1471                         int mode,1472                         uv_fs_cb cb);1473UV_EXTERN int uv_fs_read(uv_loop_t* loop,1474                         uv_fs_t* req,1475                         uv_file file,1476                         const uv_buf_t bufs[],1477                         unsigned int nbufs,1478                         int64_t offset,1479                         uv_fs_cb cb);1480UV_EXTERN int uv_fs_unlink(uv_loop_t* loop,1481                           uv_fs_t* req,1482                           const char* path,1483                           uv_fs_cb cb);1484UV_EXTERN int uv_fs_write(uv_loop_t* loop,1485                          uv_fs_t* req,1486                          uv_file file,1487                          const uv_buf_t bufs[],1488                          unsigned int nbufs,1489                          int64_t offset,1490                          uv_fs_cb cb);1491/*1492 * This flag can be used with uv_fs_copyfile() to return an error if the1493 * destination already exists.1494 */1495#define UV_FS_COPYFILE_EXCL   0x00011496 1497/*1498 * This flag can be used with uv_fs_copyfile() to attempt to create a reflink.1499 * If copy-on-write is not supported, a fallback copy mechanism is used.1500 */1501#define UV_FS_COPYFILE_FICLONE 0x00021502 1503/*1504 * This flag can be used with uv_fs_copyfile() to attempt to create a reflink.1505 * If copy-on-write is not supported, an error is returned.1506 */1507#define UV_FS_COPYFILE_FICLONE_FORCE 0x00041508 1509UV_EXTERN int uv_fs_copyfile(uv_loop_t* loop,1510                             uv_fs_t* req,1511                             const char* path,1512                             const char* new_path,1513                             int flags,1514                             uv_fs_cb cb);1515UV_EXTERN int uv_fs_mkdir(uv_loop_t* loop,1516                          uv_fs_t* req,1517                          const char* path,1518                          int mode,1519                          uv_fs_cb cb);1520UV_EXTERN int uv_fs_mkdtemp(uv_loop_t* loop,1521                            uv_fs_t* req,1522                            const char* tpl,1523                            uv_fs_cb cb);1524UV_EXTERN int uv_fs_mkstemp(uv_loop_t* loop,1525                            uv_fs_t* req,1526                            const char* tpl,1527                            uv_fs_cb cb);1528UV_EXTERN int uv_fs_rmdir(uv_loop_t* loop,1529                          uv_fs_t* req,1530                          const char* path,1531                          uv_fs_cb cb);1532UV_EXTERN int uv_fs_scandir(uv_loop_t* loop,1533                            uv_fs_t* req,1534                            const char* path,1535                            int flags,1536                            uv_fs_cb cb);1537UV_EXTERN int uv_fs_scandir_next(uv_fs_t* req,1538                                 uv_dirent_t* ent);1539UV_EXTERN int uv_fs_opendir(uv_loop_t* loop,1540                            uv_fs_t* req,1541                            const char* path,1542                            uv_fs_cb cb);1543UV_EXTERN int uv_fs_readdir(uv_loop_t* loop,1544                            uv_fs_t* req,1545                            uv_dir_t* dir,1546                            uv_fs_cb cb);1547UV_EXTERN int uv_fs_closedir(uv_loop_t* loop,1548                             uv_fs_t* req,1549                             uv_dir_t* dir,1550                             uv_fs_cb cb);1551UV_EXTERN int uv_fs_stat(uv_loop_t* loop,1552                         uv_fs_t* req,1553                         const char* path,1554                         uv_fs_cb cb);1555UV_EXTERN int uv_fs_fstat(uv_loop_t* loop,1556                          uv_fs_t* req,1557                          uv_file file,1558                          uv_fs_cb cb);1559UV_EXTERN int uv_fs_rename(uv_loop_t* loop,1560                           uv_fs_t* req,1561                           const char* path,1562                           const char* new_path,1563                           uv_fs_cb cb);1564UV_EXTERN int uv_fs_fsync(uv_loop_t* loop,1565                          uv_fs_t* req,1566                          uv_file file,1567                          uv_fs_cb cb);1568UV_EXTERN int uv_fs_fdatasync(uv_loop_t* loop,1569                              uv_fs_t* req,1570                              uv_file file,1571                              uv_fs_cb cb);1572UV_EXTERN int uv_fs_ftruncate(uv_loop_t* loop,1573                              uv_fs_t* req,1574                              uv_file file,1575                              int64_t offset,1576                              uv_fs_cb cb);1577UV_EXTERN int uv_fs_sendfile(uv_loop_t* loop,1578                             uv_fs_t* req,1579                             uv_file out_fd,1580                             uv_file in_fd,1581                             int64_t in_offset,1582                             size_t length,1583                             uv_fs_cb cb);1584UV_EXTERN int uv_fs_access(uv_loop_t* loop,1585                           uv_fs_t* req,1586                           const char* path,1587                           int mode,1588                           uv_fs_cb cb);1589UV_EXTERN int uv_fs_chmod(uv_loop_t* loop,1590                          uv_fs_t* req,1591                          const char* path,1592                          int mode,1593                          uv_fs_cb cb);1594#define UV_FS_UTIME_NOW  (INFINITY)1595#define UV_FS_UTIME_OMIT (NAN)1596UV_EXTERN int uv_fs_utime(uv_loop_t* loop,1597                          uv_fs_t* req,1598                          const char* path,1599                          double atime,1600                          double mtime,1601                          uv_fs_cb cb);1602UV_EXTERN int uv_fs_futime(uv_loop_t* loop,1603                           uv_fs_t* req,1604                           uv_file file,1605                           double atime,1606                           double mtime,1607                           uv_fs_cb cb);1608UV_EXTERN int uv_fs_lutime(uv_loop_t* loop,1609                           uv_fs_t* req,1610                           const char* path,1611                           double atime,1612                           double mtime,1613                           uv_fs_cb cb);1614UV_EXTERN int uv_fs_lstat(uv_loop_t* loop,1615                          uv_fs_t* req,1616                          const char* path,1617                          uv_fs_cb cb);1618UV_EXTERN int uv_fs_link(uv_loop_t* loop,1619                         uv_fs_t* req,1620                         const char* path,1621                         const char* new_path,1622                         uv_fs_cb cb);1623 1624/*1625 * This flag can be used with uv_fs_symlink() on Windows to specify whether1626 * path argument points to a directory.1627 */1628#define UV_FS_SYMLINK_DIR          0x00011629 1630/*1631 * This flag can be used with uv_fs_symlink() on Windows to specify whether1632 * the symlink is to be created using junction points.1633 */1634#define UV_FS_SYMLINK_JUNCTION     0x00021635 1636UV_EXTERN int uv_fs_symlink(uv_loop_t* loop,1637                            uv_fs_t* req,1638                            const char* path,1639                            const char* new_path,1640                            int flags,1641                            uv_fs_cb cb);1642UV_EXTERN int uv_fs_readlink(uv_loop_t* loop,1643                             uv_fs_t* req,1644                             const char* path,1645                             uv_fs_cb cb);1646UV_EXTERN int uv_fs_realpath(uv_loop_t* loop,1647                             uv_fs_t* req,1648                             const char* path,1649                             uv_fs_cb cb);1650UV_EXTERN int uv_fs_fchmod(uv_loop_t* loop,1651                           uv_fs_t* req,1652                           uv_file file,1653                           int mode,1654                           uv_fs_cb cb);1655UV_EXTERN int uv_fs_chown(uv_loop_t* loop,1656                          uv_fs_t* req,1657                          const char* path,1658                          uv_uid_t uid,1659                          uv_gid_t gid,1660                          uv_fs_cb cb);1661UV_EXTERN int uv_fs_fchown(uv_loop_t* loop,1662                           uv_fs_t* req,1663                           uv_file file,1664                           uv_uid_t uid,1665                           uv_gid_t gid,1666                           uv_fs_cb cb);1667UV_EXTERN int uv_fs_lchown(uv_loop_t* loop,1668                           uv_fs_t* req,1669                           const char* path,1670                           uv_uid_t uid,1671                           uv_gid_t gid,1672                           uv_fs_cb cb);1673UV_EXTERN int uv_fs_statfs(uv_loop_t* loop,1674                           uv_fs_t* req,1675                           const char* path,1676                           uv_fs_cb cb);1677 1678 1679enum uv_fs_event {1680  UV_RENAME = 1,1681  UV_CHANGE = 21682};1683 1684 1685struct uv_fs_event_s {1686  UV_HANDLE_FIELDS1687  /* private */1688  char* path;1689  UV_FS_EVENT_PRIVATE_FIELDS1690};1691 1692 1693/*1694 * uv_fs_stat() based polling file watcher.1695 */1696struct uv_fs_poll_s {1697  UV_HANDLE_FIELDS1698  /* Private, don't touch. */1699  void* poll_ctx;1700};1701 1702UV_EXTERN int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle);1703UV_EXTERN int uv_fs_poll_start(uv_fs_poll_t* handle,1704                               uv_fs_poll_cb poll_cb,1705                               const char* path,1706                               unsigned int interval);1707UV_EXTERN int uv_fs_poll_stop(uv_fs_poll_t* handle);1708UV_EXTERN int uv_fs_poll_getpath(uv_fs_poll_t* handle,1709                                 char* buffer,1710                                 size_t* size);1711 1712 1713struct uv_signal_s {1714  UV_HANDLE_FIELDS1715  uv_signal_cb signal_cb;1716  int signum;1717  UV_SIGNAL_PRIVATE_FIELDS1718};1719 1720UV_EXTERN int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle);1721UV_EXTERN int uv_signal_start(uv_signal_t* handle,1722                              uv_signal_cb signal_cb,1723                              int signum);1724UV_EXTERN int uv_signal_start_oneshot(uv_signal_t* handle,1725                                      uv_signal_cb signal_cb,1726                                      int signum);1727UV_EXTERN int uv_signal_stop(uv_signal_t* handle);1728 1729UV_EXTERN void uv_loadavg(double avg[3]);1730 1731 1732/*1733 * Flags to be passed to uv_fs_event_start().1734 */1735enum uv_fs_event_flags {1736  /*1737   * By default, if the fs event watcher is given a directory name, we will1738   * watch for all events in that directory. This flags overrides this behavior1739   * and makes fs_event report only changes to the directory entry itself. This1740   * flag does not affect individual files watched.1741   * This flag is currently not implemented yet on any backend.1742   */1743  UV_FS_EVENT_WATCH_ENTRY = 1,1744 1745  /*1746   * By default uv_fs_event will try to use a kernel interface such as inotify1747   * or kqueue to detect events. This may not work on remote filesystems such1748   * as NFS mounts. This flag makes fs_event fall back to calling stat() on a1749   * regular interval.1750   * This flag is currently not implemented yet on any backend.1751   */1752  UV_FS_EVENT_STAT = 2,1753 1754  /*1755   * By default, event watcher, when watching directory, is not registering1756   * (is ignoring) changes in it's subdirectories.1757   * This flag will override this behaviour on platforms that support it.1758   */1759  UV_FS_EVENT_RECURSIVE = 41760};1761 1762 1763UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle);1764UV_EXTERN int uv_fs_event_start(uv_fs_event_t* handle,1765                                uv_fs_event_cb cb,1766                                const char* path,1767                                unsigned int flags);1768UV_EXTERN int uv_fs_event_stop(uv_fs_event_t* handle);1769UV_EXTERN int uv_fs_event_getpath(uv_fs_event_t* handle,1770                                  char* buffer,1771                                  size_t* size);1772 1773UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr);1774UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr);1775 1776UV_EXTERN int uv_ip4_name(const struct sockaddr_in* src, char* dst, size_t size);1777UV_EXTERN int uv_ip6_name(const struct sockaddr_in6* src, char* dst, size_t size);1778UV_EXTERN int uv_ip_name(const struct sockaddr* src, char* dst, size_t size);1779 1780UV_EXTERN int uv_inet_ntop(int af, const void* src, char* dst, size_t size);1781UV_EXTERN int uv_inet_pton(int af, const char* src, void* dst);1782 1783 1784struct uv_random_s {1785  UV_REQ_FIELDS1786  /* read-only */1787  uv_loop_t* loop;1788  /* private */1789  int status;1790  void* buf;1791  size_t buflen;1792  uv_random_cb cb;1793  struct uv__work work_req;1794};1795 1796UV_EXTERN int uv_random(uv_loop_t* loop,1797                        uv_random_t* req,1798                        void *buf,1799                        size_t buflen,1800                        unsigned flags,  /* For future extension; must be 0. */1801                        uv_random_cb cb);1802 1803#if defined(IF_NAMESIZE)1804# define UV_IF_NAMESIZE (IF_NAMESIZE + 1)1805#elif defined(IFNAMSIZ)1806# define UV_IF_NAMESIZE (IFNAMSIZ + 1)1807#else1808# define UV_IF_NAMESIZE (16 + 1)1809#endif1810 1811UV_EXTERN int uv_if_indextoname(unsigned int ifindex,1812                                char* buffer,1813                                size_t* size);1814UV_EXTERN int uv_if_indextoiid(unsigned int ifindex,1815                               char* buffer,1816                               size_t* size);1817 1818UV_EXTERN int uv_exepath(char* buffer, size_t* size);1819 1820UV_EXTERN int uv_cwd(char* buffer, size_t* size);1821 1822UV_EXTERN int uv_chdir(const char* dir);1823 1824UV_EXTERN uint64_t uv_get_free_memory(void);1825UV_EXTERN uint64_t uv_get_total_memory(void);1826UV_EXTERN uint64_t uv_get_constrained_memory(void);1827UV_EXTERN uint64_t uv_get_available_memory(void);1828 1829UV_EXTERN int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts);1830UV_EXTERN uint64_t uv_hrtime(void);1831UV_EXTERN void uv_sleep(unsigned int msec);1832 1833UV_EXTERN void uv_disable_stdio_inheritance(void);1834 1835UV_EXTERN int uv_dlopen(const char* filename, uv_lib_t* lib);1836UV_EXTERN void uv_dlclose(uv_lib_t* lib);1837UV_EXTERN int uv_dlsym(uv_lib_t* lib, const char* name, void** ptr);1838UV_EXTERN const char* uv_dlerror(const uv_lib_t* lib);1839 1840UV_EXTERN int uv_mutex_init(uv_mutex_t* handle);1841UV_EXTERN int uv_mutex_init_recursive(uv_mutex_t* handle);1842UV_EXTERN void uv_mutex_destroy(uv_mutex_t* handle);1843UV_EXTERN void uv_mutex_lock(uv_mutex_t* handle);1844UV_EXTERN int uv_mutex_trylock(uv_mutex_t* handle);1845UV_EXTERN void uv_mutex_unlock(uv_mutex_t* handle);1846 1847UV_EXTERN int uv_rwlock_init(uv_rwlock_t* rwlock);1848UV_EXTERN void uv_rwlock_destroy(uv_rwlock_t* rwlock);1849UV_EXTERN void uv_rwlock_rdlock(uv_rwlock_t* rwlock);1850UV_EXTERN int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock);1851UV_EXTERN void uv_rwlock_rdunlock(uv_rwlock_t* rwlock);1852UV_EXTERN void uv_rwlock_wrlock(uv_rwlock_t* rwlock);1853UV_EXTERN int uv_rwlock_trywrlock(uv_rwlock_t* rwlock);1854UV_EXTERN void uv_rwlock_wrunlock(uv_rwlock_t* rwlock);1855 1856UV_EXTERN int uv_sem_init(uv_sem_t* sem, unsigned int value);1857UV_EXTERN void uv_sem_destroy(uv_sem_t* sem);1858UV_EXTERN void uv_sem_post(uv_sem_t* sem);1859UV_EXTERN void uv_sem_wait(uv_sem_t* sem);1860UV_EXTERN int uv_sem_trywait(uv_sem_t* sem);1861 1862UV_EXTERN int uv_cond_init(uv_cond_t* cond);1863UV_EXTERN void uv_cond_destroy(uv_cond_t* cond);1864UV_EXTERN void uv_cond_signal(uv_cond_t* cond);1865UV_EXTERN void uv_cond_broadcast(uv_cond_t* cond);1866 1867UV_EXTERN int uv_barrier_init(uv_barrier_t* barrier, unsigned int count);1868UV_EXTERN void uv_barrier_destroy(uv_barrier_t* barrier);1869UV_EXTERN int uv_barrier_wait(uv_barrier_t* barrier);1870 1871UV_EXTERN void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex);1872UV_EXTERN int uv_cond_timedwait(uv_cond_t* cond,1873                                uv_mutex_t* mutex,1874                                uint64_t timeout);1875 1876UV_EXTERN void uv_once(uv_once_t* guard, void (*callback)(void));1877 1878UV_EXTERN int uv_key_create(uv_key_t* key);1879UV_EXTERN void uv_key_delete(uv_key_t* key);1880UV_EXTERN void* uv_key_get(uv_key_t* key);1881UV_EXTERN void uv_key_set(uv_key_t* key, void* value);1882 1883UV_EXTERN int uv_gettimeofday(uv_timeval64_t* tv);1884 1885typedef void (*uv_thread_cb)(void* arg);1886 1887UV_EXTERN int uv_thread_create(uv_thread_t* tid, uv_thread_cb entry, void* arg);1888UV_EXTERN int uv_thread_detach(uv_thread_t* tid);1889 1890typedef enum {1891  UV_THREAD_NO_FLAGS = 0x00,1892  UV_THREAD_HAS_STACK_SIZE = 0x011893} uv_thread_create_flags;1894 1895struct uv_thread_options_s {1896  unsigned int flags;1897  size_t stack_size;1898  /* More fields may be added at any time. */1899};1900 1901typedef struct uv_thread_options_s uv_thread_options_t;1902 1903UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid,1904                                  const uv_thread_options_t* params,1905                                  uv_thread_cb entry,1906                                  void* arg);1907UV_EXTERN int uv_thread_setaffinity(uv_thread_t* tid,1908                                    char* cpumask,1909                                    char* oldmask,1910                                    size_t mask_size);1911UV_EXTERN int uv_thread_getaffinity(uv_thread_t* tid,1912                                    char* cpumask,1913                                    size_t mask_size);1914UV_EXTERN int uv_thread_getcpu(void);1915UV_EXTERN uv_thread_t uv_thread_self(void);1916UV_EXTERN int uv_thread_join(uv_thread_t *tid);1917UV_EXTERN int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2);1918UV_EXTERN int uv_thread_setname(const char* name);1919UV_EXTERN int uv_thread_getname(uv_thread_t* tid, char* name, size_t size);1920 1921 1922/* The presence of these unions force similar struct layout. */1923#define XX(_, name) uv_ ## name ## _t name;1924union uv_any_handle {1925  UV_HANDLE_TYPE_MAP(XX)1926};1927 1928union uv_any_req {1929  UV_REQ_TYPE_MAP(XX)1930};1931#undef XX1932 1933 1934struct uv_loop_s {1935  /* User data - use this for whatever. */1936  void* data;1937  /* Loop reference counting. */1938  unsigned int active_handles;1939  struct uv__queue handle_queue;1940  union {1941    void* unused;1942    unsigned int count;1943  } active_reqs;1944  /* Internal storage for future extensions. */1945  void* internal_fields;1946  /* Internal flag to signal loop stop. */1947  unsigned int stop_flag;1948  UV_LOOP_PRIVATE_FIELDS1949};1950 1951UV_EXTERN void* uv_loop_get_data(const uv_loop_t*);1952UV_EXTERN void uv_loop_set_data(uv_loop_t*, void* data);1953 1954/* Unicode utilities needed for dealing with Windows. */1955UV_EXTERN size_t uv_utf16_length_as_wtf8(const uint16_t* utf16,1956                                         ssize_t utf16_len);1957UV_EXTERN int uv_utf16_to_wtf8(const uint16_t* utf16,1958                               ssize_t utf16_len,1959                               char** wtf8_ptr,1960                               size_t* wtf8_len_ptr);1961UV_EXTERN ssize_t uv_wtf8_length_as_utf16(const char* wtf8);1962UV_EXTERN void uv_wtf8_to_utf16(const char* wtf8,1963                                uint16_t* utf16,1964                                size_t utf16_len);1965 1966/* Don't export the private CPP symbols. */1967#undef UV_HANDLE_TYPE_PRIVATE1968#undef UV_REQ_TYPE_PRIVATE1969#undef UV_REQ_PRIVATE_FIELDS1970#undef UV_STREAM_PRIVATE_FIELDS1971#undef UV_TCP_PRIVATE_FIELDS1972#undef UV_PREPARE_PRIVATE_FIELDS1973#undef UV_CHECK_PRIVATE_FIELDS1974#undef UV_IDLE_PRIVATE_FIELDS1975#undef UV_ASYNC_PRIVATE_FIELDS1976#undef UV_TIMER_PRIVATE_FIELDS1977#undef UV_GETADDRINFO_PRIVATE_FIELDS1978#undef UV_GETNAMEINFO_PRIVATE_FIELDS1979#undef UV_FS_REQ_PRIVATE_FIELDS1980#undef UV_WORK_PRIVATE_FIELDS1981#undef UV_FS_EVENT_PRIVATE_FIELDS1982#undef UV_SIGNAL_PRIVATE_FIELDS1983#undef UV_LOOP_PRIVATE_FIELDS1984#undef UV_LOOP_PRIVATE_PLATFORM_FIELDS1985#undef UV__ERR1986 1987#ifdef __cplusplus1988}1989#endif1990#endif /* UV_H */1991