uv.h File Reference

#include "uv/errno.h"
#include "uv/version.h"
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include "uv/unix.h"

Go to the source code of this file.

Classes
struct	uv_timespec_t
struct	uv_stat_t
struct	uv_req_s
struct	uv_shutdown_s
struct	uv_handle_s
struct	uv_stream_s
struct	uv_write_s
struct	uv_tcp_s
struct	uv_connect_s
struct	uv_udp_s
struct	uv_udp_send_s
struct	uv_tty_s
struct	uv_pipe_s
struct	uv_poll_s
struct	uv_prepare_s
struct	uv_check_s
struct	uv_idle_s
struct	uv_async_s
struct	uv_timer_s
struct	uv_getaddrinfo_s
struct	uv_getnameinfo_s
struct	uv_stdio_container_s
struct	uv_process_options_s
struct	uv_process_s
struct	uv_work_s
struct	uv_cpu_times_s
struct	uv_cpu_info_s
struct	uv_interface_address_s
struct	uv_passwd_s
struct	uv_utsname_s
struct	uv_statfs_s
struct	uv_dirent_s
struct	uv_timeval_t
struct	uv_timeval64_t
struct	uv_rusage_t
struct	uv_env_item_s
struct	uv_dir_s
struct	uv_fs_s
struct	uv_fs_event_s
struct	uv_fs_poll_s
struct	uv_signal_s
struct	uv_random_s
struct	uv_thread_options_s
union	uv_any_handle
union	uv_any_req
struct	uv_loop_s

Macros
#define	UV_EXTERN   /* nothing */
#define	UV_ERRNO_MAP(XX)
#define	UV_HANDLE_TYPE_MAP(XX)
#define	UV_REQ_TYPE_MAP(XX)
#define	XX(code, _)   UV_ ## code = UV__ ## code,
#define	XX(uc, lc)   UV_##uc,
#define	XX(uc, lc)   UV_##uc,
#define	UV_REQ_FIELDS
#define	UV_HANDLE_FIELDS
#define	UV_STREAM_FIELDS
#define	UV_PRIORITY_LOW   19
#define	UV_PRIORITY_BELOW_NORMAL   10
#define	UV_PRIORITY_NORMAL   0
#define	UV_PRIORITY_ABOVE_NORMAL   -7
#define	UV_PRIORITY_HIGH   -14
#define	UV_PRIORITY_HIGHEST   -20
#define	UV_MAXHOSTNAMESIZE   256
#define	UV_FS_COPYFILE_EXCL   0x0001
#define	UV_FS_COPYFILE_FICLONE   0x0002
#define	UV_FS_COPYFILE_FICLONE_FORCE   0x0004
#define	UV_FS_SYMLINK_DIR   0x0001
#define	UV_FS_SYMLINK_JUNCTION   0x0002
#define	UV_IF_NAMESIZE   (16 + 1)
#define	XX(_, name)   uv_ ## name ## _t name;

Typedefs
typedef struct uv_loop_s	uv_loop_t
typedef struct uv_handle_s	uv_handle_t
typedef struct uv_dir_s	uv_dir_t
typedef struct uv_stream_s	uv_stream_t
typedef struct uv_tcp_s	uv_tcp_t
typedef struct uv_udp_s	uv_udp_t
typedef struct uv_pipe_s	uv_pipe_t
typedef struct uv_tty_s	uv_tty_t
typedef struct uv_poll_s	uv_poll_t
typedef struct uv_timer_s	uv_timer_t
typedef struct uv_prepare_s	uv_prepare_t
typedef struct uv_check_s	uv_check_t
typedef struct uv_idle_s	uv_idle_t
typedef struct uv_async_s	uv_async_t
typedef struct uv_process_s	uv_process_t
typedef struct uv_fs_event_s	uv_fs_event_t
typedef struct uv_fs_poll_s	uv_fs_poll_t
typedef struct uv_signal_s	uv_signal_t
typedef struct uv_req_s	uv_req_t
typedef struct uv_getaddrinfo_s	uv_getaddrinfo_t
typedef struct uv_getnameinfo_s	uv_getnameinfo_t
typedef struct uv_shutdown_s	uv_shutdown_t
typedef struct uv_write_s	uv_write_t
typedef struct uv_connect_s	uv_connect_t
typedef struct uv_udp_send_s	uv_udp_send_t
typedef struct uv_fs_s	uv_fs_t
typedef struct uv_work_s	uv_work_t
typedef struct uv_random_s	uv_random_t
typedef struct uv_env_item_s	uv_env_item_t
typedef struct uv_cpu_info_s	uv_cpu_info_t
typedef struct uv_interface_address_s	uv_interface_address_t
typedef struct uv_dirent_s	uv_dirent_t
typedef struct uv_passwd_s	uv_passwd_t
typedef struct uv_utsname_s	uv_utsname_t
typedef struct uv_statfs_s	uv_statfs_t
typedef void *(*	uv_malloc_func) (size_t size)
typedef void *(*	uv_realloc_func) (void *ptr, size_t size)
typedef void *(*	uv_calloc_func) (size_t count, size_t size)
typedef void(*	uv_free_func) (void *ptr)
typedef void(*	uv_alloc_cb) (uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)
typedef void(*	uv_read_cb) (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
typedef void(*	uv_write_cb) (uv_write_t *req, int status)
typedef void(*	uv_connect_cb) (uv_connect_t *req, int status)
typedef void(*	uv_shutdown_cb) (uv_shutdown_t *req, int status)
typedef void(*	uv_connection_cb) (uv_stream_t *server, int status)
typedef void(*	uv_close_cb) (uv_handle_t *handle)
typedef void(*	uv_poll_cb) (uv_poll_t *handle, int status, int events)
typedef void(*	uv_timer_cb) (uv_timer_t *handle)
typedef void(*	uv_async_cb) (uv_async_t *handle)
typedef void(*	uv_prepare_cb) (uv_prepare_t *handle)
typedef void(*	uv_check_cb) (uv_check_t *handle)
typedef void(*	uv_idle_cb) (uv_idle_t *handle)
typedef void(*	uv_exit_cb) (uv_process_t *, int64_t exit_status, int term_signal)
typedef void(*	uv_walk_cb) (uv_handle_t *handle, void *arg)
typedef void(*	uv_fs_cb) (uv_fs_t *req)
typedef void(*	uv_work_cb) (uv_work_t *req)
typedef void(*	uv_after_work_cb) (uv_work_t *req, int status)
typedef void(*	uv_getaddrinfo_cb) (uv_getaddrinfo_t *req, int status, struct addrinfo *res)
typedef void(*	uv_getnameinfo_cb) (uv_getnameinfo_t *req, int status, const char *hostname, const char *service)
typedef void(*	uv_random_cb) (uv_random_t *req, int status, void *buf, size_t buflen)
typedef void(*	uv_fs_event_cb) (uv_fs_event_t *handle, const char *filename, int events, int status)
typedef void(*	uv_fs_poll_cb) (uv_fs_poll_t *handle, int status, const uv_stat_t *prev, const uv_stat_t *curr)
typedef void(*	uv_signal_cb) (uv_signal_t *handle, int signum)
typedef void(*	uv_udp_send_cb) (uv_udp_send_t *req, int status)
typedef void(*	uv_udp_recv_cb) (uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, const struct sockaddr *addr, unsigned flags)
typedef struct uv_stdio_container_s	uv_stdio_container_t
typedef struct uv_process_options_s	uv_process_options_t
typedef void(*	uv_thread_cb) (void *arg)
typedef struct uv_thread_options_s	uv_thread_options_t

Enumerations
enum	uv_errno_t { UV_ERRNO_MAX = UV__EOF - 1 }
enum	uv_handle_type { UV_UNKNOWN_HANDLE = 0 , UV_FILE , UV_HANDLE_TYPE_MAX }
enum	uv_req_type { UV_UNKNOWN_REQ = 0 , UV_REQ_TYPE_MAX }
enum	uv_loop_option { UV_LOOP_BLOCK_SIGNAL = 0 , UV_METRICS_IDLE_TIME }
enum	uv_run_mode { UV_RUN_DEFAULT = 0 , UV_RUN_ONCE , UV_RUN_NOWAIT }
enum	uv_membership { UV_LEAVE_GROUP = 0 , UV_JOIN_GROUP }
enum	uv_tcp_flags { UV_TCP_IPV6ONLY = 1 }
enum	uv_udp_flags {   UV_UDP_IPV6ONLY = 1 , UV_UDP_PARTIAL = 2 , UV_UDP_REUSEADDR = 4 , UV_UDP_MMSG_CHUNK = 8 ,   UV_UDP_MMSG_FREE = 16 , UV_UDP_RECVMMSG = 256 }
enum	uv_tty_mode_t { UV_TTY_MODE_NORMAL , UV_TTY_MODE_RAW , UV_TTY_MODE_IO }
enum	uv_tty_vtermstate_t { UV_TTY_SUPPORTED , UV_TTY_UNSUPPORTED }
enum	uv_poll_event { UV_READABLE = 1 , UV_WRITABLE = 2 , UV_DISCONNECT = 4 , UV_PRIORITIZED = 8 }
enum	uv_stdio_flags {   UV_IGNORE = 0x00 , UV_CREATE_PIPE = 0x01 , UV_INHERIT_FD = 0x02 , UV_INHERIT_STREAM = 0x04 ,   UV_READABLE_PIPE = 0x10 , UV_WRITABLE_PIPE = 0x20 , UV_OVERLAPPED_PIPE = 0x40 }
enum	uv_process_flags {   UV_PROCESS_SETUID = (1 << 0) , UV_PROCESS_SETGID = (1 << 1) , UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2) , UV_PROCESS_DETACHED = (1 << 3) ,   UV_PROCESS_WINDOWS_HIDE = (1 << 4) , UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5) , UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6) }
enum	uv_dirent_type_t {   UV_DIRENT_UNKNOWN , UV_DIRENT_FILE , UV_DIRENT_DIR , UV_DIRENT_LINK ,   UV_DIRENT_FIFO , UV_DIRENT_SOCKET , UV_DIRENT_CHAR , UV_DIRENT_BLOCK }
enum	uv_fs_type {   UV_FS_UNKNOWN = -1 , UV_FS_CUSTOM , UV_FS_OPEN , UV_FS_CLOSE ,   UV_FS_READ , UV_FS_WRITE , UV_FS_SENDFILE , UV_FS_STAT ,   UV_FS_LSTAT , UV_FS_FSTAT , UV_FS_FTRUNCATE , UV_FS_UTIME ,   UV_FS_FUTIME , UV_FS_ACCESS , UV_FS_CHMOD , UV_FS_FCHMOD ,   UV_FS_FSYNC , UV_FS_FDATASYNC , UV_FS_UNLINK , UV_FS_RMDIR ,   UV_FS_MKDIR , UV_FS_MKDTEMP , UV_FS_RENAME , UV_FS_SCANDIR ,   UV_FS_LINK , UV_FS_SYMLINK , UV_FS_READLINK , UV_FS_CHOWN ,   UV_FS_FCHOWN , UV_FS_REALPATH , UV_FS_COPYFILE , UV_FS_LCHOWN ,   UV_FS_OPENDIR , UV_FS_READDIR , UV_FS_CLOSEDIR , UV_FS_STATFS ,   UV_FS_MKSTEMP , UV_FS_LUTIME }
enum	uv_fs_event { UV_RENAME = 1 , UV_CHANGE = 2 }
enum	uv_fs_event_flags { UV_FS_EVENT_WATCH_ENTRY = 1 , UV_FS_EVENT_STAT = 2 , UV_FS_EVENT_RECURSIVE = 4 }
enum	uv_thread_create_flags { UV_THREAD_NO_FLAGS = 0x00 , UV_THREAD_HAS_STACK_SIZE = 0x01 }

Functions
UV_EXTERN unsigned int	uv_version (void)
UV_EXTERN const char *	uv_version_string (void)
UV_EXTERN void	uv_library_shutdown (void)
UV_EXTERN int	uv_replace_allocator (uv_malloc_func malloc_func, uv_realloc_func realloc_func, uv_calloc_func calloc_func, uv_free_func free_func)
UV_EXTERN uv_loop_t *	uv_default_loop (void)
UV_EXTERN int	uv_loop_init (uv_loop_t *loop)
UV_EXTERN int	uv_loop_close (uv_loop_t *loop)
UV_EXTERN uv_loop_t *	uv_loop_new (void)
UV_EXTERN void	uv_loop_delete (uv_loop_t *)
UV_EXTERN size_t	uv_loop_size (void)
UV_EXTERN int	uv_loop_alive (const uv_loop_t *loop)
UV_EXTERN int	uv_loop_configure (uv_loop_t *loop, uv_loop_option option,...)
UV_EXTERN int	uv_loop_fork (uv_loop_t *loop)
UV_EXTERN int	uv_run (uv_loop_t *, uv_run_mode mode)
UV_EXTERN void	uv_stop (uv_loop_t *)
UV_EXTERN void	uv_ref (uv_handle_t *)
UV_EXTERN void	uv_unref (uv_handle_t *)
UV_EXTERN int	uv_has_ref (const uv_handle_t *)
UV_EXTERN void	uv_update_time (uv_loop_t *)
UV_EXTERN uint64_t	uv_now (const uv_loop_t *)
UV_EXTERN int	uv_backend_fd (const uv_loop_t *)
UV_EXTERN int	uv_backend_timeout (const uv_loop_t *)
UV_EXTERN int	uv_translate_sys_error (int sys_errno)
UV_EXTERN const char *	uv_strerror (int err)
UV_EXTERN char *	uv_strerror_r (int err, char *buf, size_t buflen)
UV_EXTERN const char *	uv_err_name (int err)
UV_EXTERN char *	uv_err_name_r (int err, char *buf, size_t buflen)
UV_PRIVATE_REQ_TYPES UV_EXTERN int	uv_shutdown (uv_shutdown_t *req, uv_stream_t *handle, uv_shutdown_cb cb)
UV_EXTERN size_t	uv_handle_size (uv_handle_type type)
UV_EXTERN uv_handle_type	uv_handle_get_type (const uv_handle_t *handle)
UV_EXTERN const char *	uv_handle_type_name (uv_handle_type type)
UV_EXTERN void *	uv_handle_get_data (const uv_handle_t *handle)
UV_EXTERN uv_loop_t *	uv_handle_get_loop (const uv_handle_t *handle)
UV_EXTERN void	uv_handle_set_data (uv_handle_t *handle, void *data)
UV_EXTERN size_t	uv_req_size (uv_req_type type)
UV_EXTERN void *	uv_req_get_data (const uv_req_t *req)
UV_EXTERN void	uv_req_set_data (uv_req_t *req, void *data)
UV_EXTERN uv_req_type	uv_req_get_type (const uv_req_t *req)
UV_EXTERN const char *	uv_req_type_name (uv_req_type type)
UV_EXTERN int	uv_is_active (const uv_handle_t *handle)
UV_EXTERN void	uv_walk (uv_loop_t *loop, uv_walk_cb walk_cb, void *arg)
UV_EXTERN void	uv_print_all_handles (uv_loop_t *loop, FILE *stream)
UV_EXTERN void	uv_print_active_handles (uv_loop_t *loop, FILE *stream)
UV_EXTERN void	uv_close (uv_handle_t *handle, uv_close_cb close_cb)
UV_EXTERN int	uv_send_buffer_size (uv_handle_t *handle, int *value)
UV_EXTERN int	uv_recv_buffer_size (uv_handle_t *handle, int *value)
UV_EXTERN int	uv_fileno (const uv_handle_t *handle, uv_os_fd_t *fd)
UV_EXTERN uv_buf_t	uv_buf_init (char *base, unsigned int len)
UV_EXTERN size_t	uv_stream_get_write_queue_size (const uv_stream_t *stream)
UV_EXTERN int	uv_listen (uv_stream_t *stream, int backlog, uv_connection_cb cb)
UV_EXTERN int	uv_accept (uv_stream_t *server, uv_stream_t *client)
UV_EXTERN int	uv_read_start (uv_stream_t *, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
UV_EXTERN int	uv_read_stop (uv_stream_t *)
UV_EXTERN int	uv_write (uv_write_t *req, uv_stream_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
UV_EXTERN int	uv_write2 (uv_write_t *req, uv_stream_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t *send_handle, uv_write_cb cb)
UV_EXTERN int	uv_try_write (uv_stream_t *handle, const uv_buf_t bufs[], unsigned int nbufs)
UV_EXTERN int	uv_is_readable (const uv_stream_t *handle)
UV_EXTERN int	uv_is_writable (const uv_stream_t *handle)
UV_EXTERN int	uv_stream_set_blocking (uv_stream_t *handle, int blocking)
UV_EXTERN int	uv_is_closing (const uv_handle_t *handle)
UV_EXTERN int	uv_tcp_init (uv_loop_t *, uv_tcp_t *handle)
UV_EXTERN int	uv_tcp_init_ex (uv_loop_t *, uv_tcp_t *handle, unsigned int flags)
UV_EXTERN int	uv_tcp_open (uv_tcp_t *handle, uv_os_sock_t sock)
UV_EXTERN int	uv_tcp_nodelay (uv_tcp_t *handle, int enable)
UV_EXTERN int	uv_tcp_keepalive (uv_tcp_t *handle, int enable, unsigned int delay)
UV_EXTERN int	uv_tcp_simultaneous_accepts (uv_tcp_t *handle, int enable)
UV_EXTERN int	uv_tcp_bind (uv_tcp_t *handle, const struct sockaddr *addr, unsigned int flags)
UV_EXTERN int	uv_tcp_getsockname (const uv_tcp_t *handle, struct sockaddr *name, int *namelen)
UV_EXTERN int	uv_tcp_getpeername (const uv_tcp_t *handle, struct sockaddr *name, int *namelen)
UV_EXTERN int	uv_tcp_close_reset (uv_tcp_t *handle, uv_close_cb close_cb)
UV_EXTERN int	uv_tcp_connect (uv_connect_t *req, uv_tcp_t *handle, const struct sockaddr *addr, uv_connect_cb cb)
UV_EXTERN int	uv_udp_init (uv_loop_t *, uv_udp_t *handle)
UV_EXTERN int	uv_udp_init_ex (uv_loop_t *, uv_udp_t *handle, unsigned int flags)
UV_EXTERN int	uv_udp_open (uv_udp_t *handle, uv_os_sock_t sock)
UV_EXTERN int	uv_udp_bind (uv_udp_t *handle, const struct sockaddr *addr, unsigned int flags)
UV_EXTERN int	uv_udp_connect (uv_udp_t *handle, const struct sockaddr *addr)
UV_EXTERN int	uv_udp_getpeername (const uv_udp_t *handle, struct sockaddr *name, int *namelen)
UV_EXTERN int	uv_udp_getsockname (const uv_udp_t *handle, struct sockaddr *name, int *namelen)
UV_EXTERN int	uv_udp_set_membership (uv_udp_t *handle, const char *multicast_addr, const char *interface_addr, uv_membership membership)
UV_EXTERN int	uv_udp_set_source_membership (uv_udp_t *handle, const char *multicast_addr, const char *interface_addr, const char *source_addr, uv_membership membership)
UV_EXTERN int	uv_udp_set_multicast_loop (uv_udp_t *handle, int on)
UV_EXTERN int	uv_udp_set_multicast_ttl (uv_udp_t *handle, int ttl)
UV_EXTERN int	uv_udp_set_multicast_interface (uv_udp_t *handle, const char *interface_addr)
UV_EXTERN int	uv_udp_set_broadcast (uv_udp_t *handle, int on)
UV_EXTERN int	uv_udp_set_ttl (uv_udp_t *handle, int ttl)
UV_EXTERN int	uv_udp_send (uv_udp_send_t *req, uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr, uv_udp_send_cb send_cb)
UV_EXTERN int	uv_udp_try_send (uv_udp_t *handle, const uv_buf_t bufs[], unsigned int nbufs, const struct sockaddr *addr)
UV_EXTERN int	uv_udp_recv_start (uv_udp_t *handle, uv_alloc_cb alloc_cb, uv_udp_recv_cb recv_cb)
UV_EXTERN int	uv_udp_using_recvmmsg (const uv_udp_t *handle)
UV_EXTERN int	uv_udp_recv_stop (uv_udp_t *handle)
UV_EXTERN size_t	uv_udp_get_send_queue_size (const uv_udp_t *handle)
UV_EXTERN size_t	uv_udp_get_send_queue_count (const uv_udp_t *handle)
UV_EXTERN int	uv_tty_init (uv_loop_t *, uv_tty_t *, uv_file fd, int readable)
UV_EXTERN int	uv_tty_set_mode (uv_tty_t *, uv_tty_mode_t mode)
UV_EXTERN int	uv_tty_reset_mode (void)
UV_EXTERN int	uv_tty_get_winsize (uv_tty_t *, int *width, int *height)
UV_EXTERN void	uv_tty_set_vterm_state (uv_tty_vtermstate_t state)
UV_EXTERN int	uv_tty_get_vterm_state (uv_tty_vtermstate_t *state)
UV_EXTERN uv_handle_type	uv_guess_handle (uv_file file)
UV_EXTERN int	uv_pipe_init (uv_loop_t *, uv_pipe_t *handle, int ipc)
UV_EXTERN int	uv_pipe_open (uv_pipe_t *, uv_file file)
UV_EXTERN int	uv_pipe_bind (uv_pipe_t *handle, const char *name)
UV_EXTERN void	uv_pipe_connect (uv_connect_t *req, uv_pipe_t *handle, const char *name, uv_connect_cb cb)
UV_EXTERN int	uv_pipe_getsockname (const uv_pipe_t *handle, char *buffer, size_t *size)
UV_EXTERN int	uv_pipe_getpeername (const uv_pipe_t *handle, char *buffer, size_t *size)
UV_EXTERN void	uv_pipe_pending_instances (uv_pipe_t *handle, int count)
UV_EXTERN int	uv_pipe_pending_count (uv_pipe_t *handle)
UV_EXTERN uv_handle_type	uv_pipe_pending_type (uv_pipe_t *handle)
UV_EXTERN int	uv_pipe_chmod (uv_pipe_t *handle, int flags)
UV_EXTERN int	uv_poll_init (uv_loop_t *loop, uv_poll_t *handle, int fd)
UV_EXTERN int	uv_poll_init_socket (uv_loop_t *loop, uv_poll_t *handle, uv_os_sock_t socket)
UV_EXTERN int	uv_poll_start (uv_poll_t *handle, int events, uv_poll_cb cb)
UV_EXTERN int	uv_poll_stop (uv_poll_t *handle)
UV_EXTERN int	uv_prepare_init (uv_loop_t *, uv_prepare_t *prepare)
UV_EXTERN int	uv_prepare_start (uv_prepare_t *prepare, uv_prepare_cb cb)
UV_EXTERN int	uv_prepare_stop (uv_prepare_t *prepare)
UV_EXTERN int	uv_check_init (uv_loop_t *, uv_check_t *check)
UV_EXTERN int	uv_check_start (uv_check_t *check, uv_check_cb cb)
UV_EXTERN int	uv_check_stop (uv_check_t *check)
UV_EXTERN int	uv_idle_init (uv_loop_t *, uv_idle_t *idle)
UV_EXTERN int	uv_idle_start (uv_idle_t *idle, uv_idle_cb cb)
UV_EXTERN int	uv_idle_stop (uv_idle_t *idle)
UV_EXTERN int	uv_async_init (uv_loop_t *, uv_async_t *async, uv_async_cb async_cb)
UV_EXTERN int	uv_async_send (uv_async_t *async)
UV_EXTERN int	uv_timer_init (uv_loop_t *, uv_timer_t *handle)
UV_EXTERN int	uv_timer_start (uv_timer_t *handle, uv_timer_cb cb, uint64_t timeout, uint64_t repeat)
UV_EXTERN int	uv_timer_stop (uv_timer_t *handle)
UV_EXTERN int	uv_timer_again (uv_timer_t *handle)
UV_EXTERN void	uv_timer_set_repeat (uv_timer_t *handle, uint64_t repeat)
UV_EXTERN uint64_t	uv_timer_get_repeat (const uv_timer_t *handle)
UV_EXTERN uint64_t	uv_timer_get_due_in (const uv_timer_t *handle)
UV_EXTERN int	uv_getaddrinfo (uv_loop_t *loop, uv_getaddrinfo_t *req, uv_getaddrinfo_cb getaddrinfo_cb, const char *node, const char *service, const struct addrinfo *hints)
UV_EXTERN void	uv_freeaddrinfo (struct addrinfo *ai)
UV_EXTERN int	uv_getnameinfo (uv_loop_t *loop, uv_getnameinfo_t *req, uv_getnameinfo_cb getnameinfo_cb, const struct sockaddr *addr, int flags)
UV_EXTERN int	uv_spawn (uv_loop_t *loop, uv_process_t *handle, const uv_process_options_t *options)
UV_EXTERN int	uv_process_kill (uv_process_t *, int signum)
UV_EXTERN int	uv_kill (int pid, int signum)
UV_EXTERN uv_pid_t	uv_process_get_pid (const uv_process_t *)
UV_EXTERN int	uv_queue_work (uv_loop_t *loop, uv_work_t *req, uv_work_cb work_cb, uv_after_work_cb after_work_cb)
UV_EXTERN int	uv_cancel (uv_req_t *req)
UV_EXTERN char **	uv_setup_args (int argc, char **argv)
UV_EXTERN int	uv_get_process_title (char *buffer, size_t size)
UV_EXTERN int	uv_set_process_title (const char *title)
UV_EXTERN int	uv_resident_set_memory (size_t *rss)
UV_EXTERN int	uv_uptime (double *uptime)
UV_EXTERN uv_os_fd_t	uv_get_osfhandle (int fd)
UV_EXTERN int	uv_open_osfhandle (uv_os_fd_t os_fd)
UV_EXTERN int	uv_getrusage (uv_rusage_t *rusage)
UV_EXTERN int	uv_os_homedir (char *buffer, size_t *size)
UV_EXTERN int	uv_os_tmpdir (char *buffer, size_t *size)
UV_EXTERN int	uv_os_get_passwd (uv_passwd_t *pwd)
UV_EXTERN void	uv_os_free_passwd (uv_passwd_t *pwd)
UV_EXTERN uv_pid_t	uv_os_getpid (void)
UV_EXTERN uv_pid_t	uv_os_getppid (void)
UV_EXTERN int	uv_os_getpriority (uv_pid_t pid, int *priority)
UV_EXTERN int	uv_os_setpriority (uv_pid_t pid, int priority)
UV_EXTERN int	uv_cpu_info (uv_cpu_info_t **cpu_infos, int *count)
UV_EXTERN void	uv_free_cpu_info (uv_cpu_info_t *cpu_infos, int count)
UV_EXTERN int	uv_interface_addresses (uv_interface_address_t **addresses, int *count)
UV_EXTERN void	uv_free_interface_addresses (uv_interface_address_t *addresses, int count)
UV_EXTERN int	uv_os_environ (uv_env_item_t **envitems, int *count)
UV_EXTERN void	uv_os_free_environ (uv_env_item_t *envitems, int count)
UV_EXTERN int	uv_os_getenv (const char *name, char *buffer, size_t *size)
UV_EXTERN int	uv_os_setenv (const char *name, const char *value)
UV_EXTERN int	uv_os_unsetenv (const char *name)
UV_EXTERN int	uv_os_gethostname (char *buffer, size_t *size)
UV_EXTERN int	uv_os_uname (uv_utsname_t *buffer)
UV_EXTERN uint64_t	uv_metrics_idle_time (uv_loop_t *loop)
UV_EXTERN uv_fs_type	uv_fs_get_type (const uv_fs_t *)
UV_EXTERN ssize_t	uv_fs_get_result (const uv_fs_t *)
UV_EXTERN int	uv_fs_get_system_error (const uv_fs_t *)
UV_EXTERN void *	uv_fs_get_ptr (const uv_fs_t *)
UV_EXTERN const char *	uv_fs_get_path (const uv_fs_t *)
UV_EXTERN uv_stat_t *	uv_fs_get_statbuf (uv_fs_t *)
UV_EXTERN void	uv_fs_req_cleanup (uv_fs_t *req)
UV_EXTERN int	uv_fs_close (uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
UV_EXTERN int	uv_fs_open (uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, int mode, uv_fs_cb cb)
UV_EXTERN int	uv_fs_read (uv_loop_t *loop, uv_fs_t *req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb)
UV_EXTERN int	uv_fs_unlink (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_write (uv_loop_t *loop, uv_fs_t *req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb)
UV_EXTERN int	uv_fs_copyfile (uv_loop_t *loop, uv_fs_t *req, const char *path, const char *new_path, int flags, uv_fs_cb cb)
UV_EXTERN int	uv_fs_mkdir (uv_loop_t *loop, uv_fs_t *req, const char *path, int mode, uv_fs_cb cb)
UV_EXTERN int	uv_fs_mkdtemp (uv_loop_t *loop, uv_fs_t *req, const char *tpl, uv_fs_cb cb)
UV_EXTERN int	uv_fs_mkstemp (uv_loop_t *loop, uv_fs_t *req, const char *tpl, uv_fs_cb cb)
UV_EXTERN int	uv_fs_rmdir (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_scandir (uv_loop_t *loop, uv_fs_t *req, const char *path, int flags, uv_fs_cb cb)
UV_EXTERN int	uv_fs_scandir_next (uv_fs_t *req, uv_dirent_t *ent)
UV_EXTERN int	uv_fs_opendir (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_readdir (uv_loop_t *loop, uv_fs_t *req, uv_dir_t *dir, uv_fs_cb cb)
UV_EXTERN int	uv_fs_closedir (uv_loop_t *loop, uv_fs_t *req, uv_dir_t *dir, uv_fs_cb cb)
UV_EXTERN int	uv_fs_stat (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_fstat (uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
UV_EXTERN int	uv_fs_rename (uv_loop_t *loop, uv_fs_t *req, const char *path, const char *new_path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_fsync (uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
UV_EXTERN int	uv_fs_fdatasync (uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_fs_cb cb)
UV_EXTERN int	uv_fs_ftruncate (uv_loop_t *loop, uv_fs_t *req, uv_file file, int64_t offset, uv_fs_cb cb)
UV_EXTERN int	uv_fs_sendfile (uv_loop_t *loop, uv_fs_t *req, uv_file out_fd, uv_file in_fd, int64_t in_offset, size_t length, uv_fs_cb cb)
UV_EXTERN int	uv_fs_access (uv_loop_t *loop, uv_fs_t *req, const char *path, int mode, uv_fs_cb cb)
UV_EXTERN int	uv_fs_chmod (uv_loop_t *loop, uv_fs_t *req, const char *path, int mode, uv_fs_cb cb)
UV_EXTERN int	uv_fs_utime (uv_loop_t *loop, uv_fs_t *req, const char *path, double atime, double mtime, uv_fs_cb cb)
UV_EXTERN int	uv_fs_futime (uv_loop_t *loop, uv_fs_t *req, uv_file file, double atime, double mtime, uv_fs_cb cb)
UV_EXTERN int	uv_fs_lutime (uv_loop_t *loop, uv_fs_t *req, const char *path, double atime, double mtime, uv_fs_cb cb)
UV_EXTERN int	uv_fs_lstat (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_link (uv_loop_t *loop, uv_fs_t *req, const char *path, const char *new_path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_symlink (uv_loop_t *loop, uv_fs_t *req, const char *path, const char *new_path, int flags, uv_fs_cb cb)
UV_EXTERN int	uv_fs_readlink (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_realpath (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_fchmod (uv_loop_t *loop, uv_fs_t *req, uv_file file, int mode, uv_fs_cb cb)
UV_EXTERN int	uv_fs_chown (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb)
UV_EXTERN int	uv_fs_fchown (uv_loop_t *loop, uv_fs_t *req, uv_file file, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb)
UV_EXTERN int	uv_fs_lchown (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb)
UV_EXTERN int	uv_fs_statfs (uv_loop_t *loop, uv_fs_t *req, const char *path, uv_fs_cb cb)
UV_EXTERN int	uv_fs_poll_init (uv_loop_t *loop, uv_fs_poll_t *handle)
UV_EXTERN int	uv_fs_poll_start (uv_fs_poll_t *handle, uv_fs_poll_cb poll_cb, const char *path, unsigned int interval)
UV_EXTERN int	uv_fs_poll_stop (uv_fs_poll_t *handle)
UV_EXTERN int	uv_fs_poll_getpath (uv_fs_poll_t *handle, char *buffer, size_t *size)
UV_EXTERN int	uv_signal_init (uv_loop_t *loop, uv_signal_t *handle)
UV_EXTERN int	uv_signal_start (uv_signal_t *handle, uv_signal_cb signal_cb, int signum)
UV_EXTERN int	uv_signal_start_oneshot (uv_signal_t *handle, uv_signal_cb signal_cb, int signum)
UV_EXTERN int	uv_signal_stop (uv_signal_t *handle)
UV_EXTERN void	uv_loadavg (double avg[3])
UV_EXTERN int	uv_fs_event_init (uv_loop_t *loop, uv_fs_event_t *handle)
UV_EXTERN int	uv_fs_event_start (uv_fs_event_t *handle, uv_fs_event_cb cb, const char *path, unsigned int flags)
UV_EXTERN int	uv_fs_event_stop (uv_fs_event_t *handle)
UV_EXTERN int	uv_fs_event_getpath (uv_fs_event_t *handle, char *buffer, size_t *size)
UV_EXTERN int	uv_ip4_addr (const char *ip, int port, struct sockaddr_in *addr)
UV_EXTERN int	uv_ip6_addr (const char *ip, int port, struct sockaddr_in6 *addr)
UV_EXTERN int	uv_ip4_name (const struct sockaddr_in *src, char *dst, size_t size)
UV_EXTERN int	uv_ip6_name (const struct sockaddr_in6 *src, char *dst, size_t size)
UV_EXTERN int	uv_inet_ntop (int af, const void *src, char *dst, size_t size)
UV_EXTERN int	uv_inet_pton (int af, const char *src, void *dst)
UV_EXTERN int	uv_random (uv_loop_t *loop, uv_random_t *req, void *buf, size_t buflen, unsigned flags, uv_random_cb cb)
UV_EXTERN int	uv_if_indextoname (unsigned int ifindex, char *buffer, size_t *size)
UV_EXTERN int	uv_if_indextoiid (unsigned int ifindex, char *buffer, size_t *size)
UV_EXTERN int	uv_exepath (char *buffer, size_t *size)
UV_EXTERN int	uv_cwd (char *buffer, size_t *size)
UV_EXTERN int	uv_chdir (const char *dir)
UV_EXTERN uint64_t	uv_get_free_memory (void)
UV_EXTERN uint64_t	uv_get_total_memory (void)
UV_EXTERN uint64_t	uv_get_constrained_memory (void)
UV_EXTERN uint64_t	uv_hrtime (void)
UV_EXTERN void	uv_sleep (unsigned int msec)
UV_EXTERN void	uv_disable_stdio_inheritance (void)
UV_EXTERN int	uv_dlopen (const char *filename, uv_lib_t *lib)
UV_EXTERN void	uv_dlclose (uv_lib_t *lib)
UV_EXTERN int	uv_dlsym (uv_lib_t *lib, const char *name, void **ptr)
UV_EXTERN const char *	uv_dlerror (const uv_lib_t *lib)
UV_EXTERN int	uv_mutex_init (uv_mutex_t *handle)
UV_EXTERN int	uv_mutex_init_recursive (uv_mutex_t *handle)
UV_EXTERN void	uv_mutex_destroy (uv_mutex_t *handle)
UV_EXTERN void	uv_mutex_lock (uv_mutex_t *handle)
UV_EXTERN int	uv_mutex_trylock (uv_mutex_t *handle)
UV_EXTERN void	uv_mutex_unlock (uv_mutex_t *handle)
UV_EXTERN int	uv_rwlock_init (uv_rwlock_t *rwlock)
UV_EXTERN void	uv_rwlock_destroy (uv_rwlock_t *rwlock)
UV_EXTERN void	uv_rwlock_rdlock (uv_rwlock_t *rwlock)
UV_EXTERN int	uv_rwlock_tryrdlock (uv_rwlock_t *rwlock)
UV_EXTERN void	uv_rwlock_rdunlock (uv_rwlock_t *rwlock)
UV_EXTERN void	uv_rwlock_wrlock (uv_rwlock_t *rwlock)
UV_EXTERN int	uv_rwlock_trywrlock (uv_rwlock_t *rwlock)
UV_EXTERN void	uv_rwlock_wrunlock (uv_rwlock_t *rwlock)
UV_EXTERN int	uv_sem_init (uv_sem_t *sem, unsigned int value)
UV_EXTERN void	uv_sem_destroy (uv_sem_t *sem)
UV_EXTERN void	uv_sem_post (uv_sem_t *sem)
UV_EXTERN void	uv_sem_wait (uv_sem_t *sem)
UV_EXTERN int	uv_sem_trywait (uv_sem_t *sem)
UV_EXTERN int	uv_cond_init (uv_cond_t *cond)
UV_EXTERN void	uv_cond_destroy (uv_cond_t *cond)
UV_EXTERN void	uv_cond_signal (uv_cond_t *cond)
UV_EXTERN void	uv_cond_broadcast (uv_cond_t *cond)
UV_EXTERN int	uv_barrier_init (uv_barrier_t *barrier, unsigned int count)
UV_EXTERN void	uv_barrier_destroy (uv_barrier_t *barrier)
UV_EXTERN int	uv_barrier_wait (uv_barrier_t *barrier)
UV_EXTERN void	uv_cond_wait (uv_cond_t *cond, uv_mutex_t *mutex)
UV_EXTERN int	uv_cond_timedwait (uv_cond_t *cond, uv_mutex_t *mutex, uint64_t timeout)
UV_EXTERN void	uv_once (uv_once_t *guard, void(*callback)(void))
UV_EXTERN int	uv_key_create (uv_key_t *key)
UV_EXTERN void	uv_key_delete (uv_key_t *key)
UV_EXTERN void *	uv_key_get (uv_key_t *key)
UV_EXTERN void	uv_key_set (uv_key_t *key, void *value)
UV_EXTERN int	uv_gettimeofday (uv_timeval64_t *tv)
UV_EXTERN int	uv_thread_create (uv_thread_t *tid, uv_thread_cb entry, void *arg)
UV_EXTERN int	uv_thread_create_ex (uv_thread_t *tid, const uv_thread_options_t *params, uv_thread_cb entry, void *arg)
UV_EXTERN uv_thread_t	uv_thread_self (void)
UV_EXTERN int	uv_thread_join (uv_thread_t *tid)
UV_EXTERN int	uv_thread_equal (const uv_thread_t *t1, const uv_thread_t *t2)
UV_EXTERN void *	uv_loop_get_data (const uv_loop_t *)
UV_EXTERN void	uv_loop_set_data (uv_loop_t *, void *data)

Macro Definition Documentation

UV_ERRNO_MAP

#define UV_ERRNO_MAP

(

XX

)

Definition at line 70 of file uv.h.

UV_EXTERN

#define UV_EXTERN   /* nothing */

Definition at line 49 of file uv.h.

UV_FS_COPYFILE_EXCL

#define UV_FS_COPYFILE_EXCL   0x0001

Definition at line 1358 of file uv.h.

UV_FS_COPYFILE_FICLONE

#define UV_FS_COPYFILE_FICLONE   0x0002

Definition at line 1364 of file uv.h.

UV_FS_COPYFILE_FICLONE_FORCE

#define UV_FS_COPYFILE_FICLONE_FORCE   0x0004

Definition at line 1370 of file uv.h.

UV_FS_SYMLINK_DIR

#define UV_FS_SYMLINK_DIR   0x0001

Definition at line 1489 of file uv.h.

UV_FS_SYMLINK_JUNCTION

#define UV_FS_SYMLINK_JUNCTION   0x0002

Definition at line 1495 of file uv.h.

UV_HANDLE_FIELDS

#define UV_HANDLE_FIELDS

Value:

  /* public */                                                                \
  void* data;                                                                 \
  /* read-only */                                                             \
  uv_loop_t* loop;                                                            \
  uv_handle_type type;                                                        \
  /* private */                                                               \
  uv_close_cb close_cb;                                                       \
  void* handle_queue[2];                                                      \
  union {                                                                     \
    int fd;                                                                   \
    void* reserved[4];                                                        \
  } u;                                                                        \
  UV_HANDLE_PRIVATE_FIELDS                                                    \

Definition at line 428 of file uv.h.

UV_HANDLE_TYPE_MAP

#define UV_HANDLE_TYPE_MAP

(

XX

)

Value:

  XX(ASYNC, async)                                                            \
  XX(CHECK, check)                                                            \
  XX(FS_EVENT, fs_event)                                                      \
  XX(FS_POLL, fs_poll)                                                        \
  XX(HANDLE, handle)                                                          \
  XX(IDLE, idle)                                                              \
  XX(NAMED_PIPE, pipe)                                                        \
  XX(POLL, poll)                                                              \
  XX(PREPARE, prepare)                                                        \
  XX(PROCESS, process)                                                        \
  XX(STREAM, stream)                                                          \
  XX(TCP, tcp)                                                                \
  XX(TIMER, timer)                                                            \
  XX(TTY, tty)                                                                \
  XX(UDP, udp)                                                                \
  XX(SIGNAL, signal)                                                          \

Definition at line 152 of file uv.h.

UV_IF_NAMESIZE

#define UV_IF_NAMESIZE   (16 + 1)

Definition at line 1668 of file uv.h.

UV_MAXHOSTNAMESIZE

#define UV_MAXHOSTNAMESIZE   256

Definition at line 1248 of file uv.h.

UV_PRIORITY_ABOVE_NORMAL

#define UV_PRIORITY_ABOVE_NORMAL   -7

Definition at line 1213 of file uv.h.

UV_PRIORITY_BELOW_NORMAL

#define UV_PRIORITY_BELOW_NORMAL   10

Definition at line 1211 of file uv.h.

UV_PRIORITY_HIGH

#define UV_PRIORITY_HIGH   -14

Definition at line 1214 of file uv.h.

UV_PRIORITY_HIGHEST

#define UV_PRIORITY_HIGHEST   -20

Definition at line 1215 of file uv.h.

UV_PRIORITY_LOW

#define UV_PRIORITY_LOW   19

Definition at line 1210 of file uv.h.

UV_PRIORITY_NORMAL

#define UV_PRIORITY_NORMAL   0

Definition at line 1212 of file uv.h.

UV_REQ_FIELDS

#define UV_REQ_FIELDS

Value:

  /* public */                                                                \
  void* data;                                                                 \
  /* read-only */                                                             \
  uv_req_type type;                                                           \
  /* private */                                                               \
  void* reserved[6];                                                          \
  UV_REQ_PRIVATE_FIELDS                                                       \

Definition at line 397 of file uv.h.

UV_REQ_TYPE_MAP

#define UV_REQ_TYPE_MAP

(

XX

)

Value:

  XX(REQ, req)                                                                \
  XX(CONNECT, connect)                                                        \
  XX(WRITE, write)                                                            \
  XX(SHUTDOWN, shutdown)                                                      \
  XX(UDP_SEND, udp_send)                                                      \
  XX(FS, fs)                                                                  \
  XX(WORK, work)                                                              \
  XX(GETADDRINFO, getaddrinfo)                                                \
  XX(GETNAMEINFO, getnameinfo)                                                \
  XX(RANDOM, random)                                                          \

Definition at line 170 of file uv.h.

UV_STREAM_FIELDS

#define UV_STREAM_FIELDS

Value:

  /* number of bytes queued for writing */                                    \
  size_t write_queue_size;                                                    \
  uv_alloc_cb alloc_cb;                                                       \
  uv_read_cb read_cb;                                                         \
  /* private */                                                               \
  UV_STREAM_PRIVATE_FIELDS

Definition at line 479 of file uv.h.

XX [1/4]

#define XX	(		_,
			name
	)		uv_ ## name ## _t name;

Definition at line 1769 of file uv.h.

XX [2/4]

#define XX	(		code,
			_
	)		UV_ ## code = UV__ ## code,

Definition at line 1769 of file uv.h.

XX [3/4]

#define XX	(		uc,
			lc
	)		UV_##uc,

Definition at line 1769 of file uv.h.

XX [4/4]

#define XX	(		uc,
			lc
	)		UV_##uc,

Definition at line 1769 of file uv.h.

Typedef Documentation

uv_after_work_cb

typedef void(* uv_after_work_cb) (uv_work_t *req, int status)

Definition at line 330 of file uv.h.

uv_alloc_cb

typedef void(* uv_alloc_cb) (uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf)

Definition at line 309 of file uv.h.

uv_async_cb

typedef void(* uv_async_cb) (uv_async_t *handle)

Definition at line 322 of file uv.h.

uv_async_t

typedef struct uv_async_s uv_async_t

Definition at line 1 of file uv.h.

uv_calloc_func

typedef void*(* uv_calloc_func) (size_t count, size_t size)

Definition at line 266 of file uv.h.

uv_check_cb

typedef void(* uv_check_cb) (uv_check_t *handle)

Definition at line 324 of file uv.h.

uv_check_t

typedef struct uv_check_s uv_check_t

Definition at line 1 of file uv.h.

uv_close_cb

typedef void(* uv_close_cb) (uv_handle_t *handle)

Definition at line 319 of file uv.h.

uv_connect_cb

typedef void(* uv_connect_cb) (uv_connect_t *req, int status)

Definition at line 316 of file uv.h.

uv_connect_t

typedef struct uv_connect_s uv_connect_t

Definition at line 1 of file uv.h.

uv_connection_cb

typedef void(* uv_connection_cb) (uv_stream_t *server, int status)

Definition at line 318 of file uv.h.

uv_cpu_info_t

typedef struct uv_cpu_info_s uv_cpu_info_t

Definition at line 1 of file uv.h.

uv_dir_t

typedef struct uv_dir_s uv_dir_t

Definition at line 1 of file uv.h.

uv_dirent_t

typedef struct uv_dirent_s uv_dirent_t

Definition at line 1 of file uv.h.

uv_env_item_t

typedef struct uv_env_item_s uv_env_item_t

Definition at line 1 of file uv.h.

uv_exit_cb

typedef void(* uv_exit_cb) (uv_process_t *, int64_t exit_status, int term_signal)

Definition at line 326 of file uv.h.

uv_free_func

typedef void(* uv_free_func) (void *ptr)

Definition at line 267 of file uv.h.

uv_fs_cb

typedef void(* uv_fs_cb) (uv_fs_t *req)

Definition at line 328 of file uv.h.

uv_fs_event_cb

typedef void(* uv_fs_event_cb) (uv_fs_event_t *handle, const char *filename, int events, int status)

Definition at line 369 of file uv.h.

uv_fs_event_t

typedef struct uv_fs_event_s uv_fs_event_t

Definition at line 1 of file uv.h.

uv_fs_poll_cb

typedef void(* uv_fs_poll_cb) (uv_fs_poll_t *handle, int status, const uv_stat_t *prev, const uv_stat_t *curr)

Definition at line 374 of file uv.h.

uv_fs_poll_t

typedef struct uv_fs_poll_s uv_fs_poll_t

Definition at line 1 of file uv.h.

uv_fs_t

typedef struct uv_fs_s uv_fs_t

Definition at line 1 of file uv.h.

uv_getaddrinfo_cb

typedef void(* uv_getaddrinfo_cb) (uv_getaddrinfo_t *req, int status, struct addrinfo *res)

Definition at line 331 of file uv.h.

uv_getaddrinfo_t

typedef struct uv_getaddrinfo_s uv_getaddrinfo_t

Definition at line 1 of file uv.h.

uv_getnameinfo_cb

typedef void(* uv_getnameinfo_cb) (uv_getnameinfo_t *req, int status, const char *hostname, const char *service)

Definition at line 334 of file uv.h.

uv_getnameinfo_t

typedef struct uv_getnameinfo_s uv_getnameinfo_t

Definition at line 1 of file uv.h.

uv_handle_t

typedef struct uv_handle_s uv_handle_t

Definition at line 1 of file uv.h.

uv_idle_cb

typedef void(* uv_idle_cb) (uv_idle_t *handle)

Definition at line 325 of file uv.h.

uv_idle_t

typedef struct uv_idle_s uv_idle_t

Definition at line 1 of file uv.h.

uv_interface_address_t

typedef struct uv_interface_address_s uv_interface_address_t

Definition at line 1 of file uv.h.

uv_loop_t

typedef struct uv_loop_s uv_loop_t

Definition at line 1 of file uv.h.

uv_malloc_func

typedef void*(* uv_malloc_func) (size_t size)

Definition at line 264 of file uv.h.

uv_passwd_t

typedef struct uv_passwd_s uv_passwd_t

Definition at line 1 of file uv.h.

uv_pipe_t

typedef struct uv_pipe_s uv_pipe_t

Definition at line 1 of file uv.h.

uv_poll_cb

typedef void(* uv_poll_cb) (uv_poll_t *handle, int status, int events)

Definition at line 320 of file uv.h.

uv_poll_t

typedef struct uv_poll_s uv_poll_t

Definition at line 1 of file uv.h.

uv_prepare_cb

typedef void(* uv_prepare_cb) (uv_prepare_t *handle)

Definition at line 323 of file uv.h.

uv_prepare_t

typedef struct uv_prepare_s uv_prepare_t

Definition at line 1 of file uv.h.

uv_process_options_t

typedef struct uv_process_options_s uv_process_options_t

uv_process_t

typedef struct uv_process_s uv_process_t

Definition at line 1 of file uv.h.

uv_random_cb

typedef void(* uv_random_cb) (uv_random_t *req, int status, void *buf, size_t buflen)

Definition at line 338 of file uv.h.

uv_random_t

typedef struct uv_random_s uv_random_t

Definition at line 1 of file uv.h.

uv_read_cb

typedef void(* uv_read_cb) (uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)

Definition at line 312 of file uv.h.

uv_realloc_func

typedef void*(* uv_realloc_func) (void *ptr, size_t size)

Definition at line 265 of file uv.h.

uv_req_t

typedef struct uv_req_s uv_req_t

Definition at line 1 of file uv.h.

uv_shutdown_cb

typedef void(* uv_shutdown_cb) (uv_shutdown_t *req, int status)

Definition at line 317 of file uv.h.

uv_shutdown_t

typedef struct uv_shutdown_s uv_shutdown_t

Definition at line 1 of file uv.h.

uv_signal_cb

typedef void(* uv_signal_cb) (uv_signal_t *handle, int signum)

Definition at line 379 of file uv.h.

uv_signal_t

typedef struct uv_signal_s uv_signal_t

Definition at line 1 of file uv.h.

uv_statfs_t

typedef struct uv_statfs_s uv_statfs_t

Definition at line 1 of file uv.h.

uv_stdio_container_t

typedef struct uv_stdio_container_s uv_stdio_container_t

uv_stream_t

typedef struct uv_stream_s uv_stream_t

Definition at line 1 of file uv.h.

uv_tcp_t

typedef struct uv_tcp_s uv_tcp_t

Definition at line 1 of file uv.h.

uv_thread_cb

typedef void(* uv_thread_cb) (void *arg)

Definition at line 1743 of file uv.h.

uv_thread_options_t

typedef struct uv_thread_options_s uv_thread_options_t

Definition at line 1745 of file uv.h.

uv_timer_cb

typedef void(* uv_timer_cb) (uv_timer_t *handle)

Definition at line 321 of file uv.h.

uv_timer_t

typedef struct uv_timer_s uv_timer_t

Definition at line 1 of file uv.h.

uv_tty_t

typedef struct uv_tty_s uv_tty_t

Definition at line 1 of file uv.h.

uv_udp_recv_cb

typedef void(* uv_udp_recv_cb) (uv_udp_t *handle, ssize_t nread, const uv_buf_t *buf, const struct sockaddr *addr, unsigned flags)

Definition at line 631 of file uv.h.

uv_udp_send_cb

typedef void(* uv_udp_send_cb) (uv_udp_send_t *req, int status)

Definition at line 630 of file uv.h.

uv_udp_send_t

typedef struct uv_udp_send_s uv_udp_send_t

Definition at line 1 of file uv.h.

uv_udp_t

typedef struct uv_udp_s uv_udp_t

Definition at line 1 of file uv.h.

uv_utsname_t

typedef struct uv_utsname_s uv_utsname_t

Definition at line 1 of file uv.h.

uv_walk_cb

typedef void(* uv_walk_cb) (uv_handle_t *handle, void *arg)

Definition at line 327 of file uv.h.

uv_work_cb

typedef void(* uv_work_cb) (uv_work_t *req)

Definition at line 329 of file uv.h.

uv_work_t

typedef struct uv_work_s uv_work_t

Definition at line 1 of file uv.h.

uv_write_cb

typedef void(* uv_write_cb) (uv_write_t *req, int status)

Definition at line 315 of file uv.h.

uv_write_t

typedef struct uv_write_s uv_write_t

Definition at line 1 of file uv.h.

Enumeration Type Documentation

uv_dirent_type_t

enum uv_dirent_type_t

Enumerator
UV_DIRENT_UNKNOWN
UV_DIRENT_FILE
UV_DIRENT_DIR
UV_DIRENT_LINK
UV_DIRENT_FIFO
UV_DIRENT_SOCKET
UV_DIRENT_CHAR
UV_DIRENT_BLOCK

Definition at line 1139 of file uv.h.

             {
  UV_DIRENT_UNKNOWN,
  UV_DIRENT_FILE,
  UV_DIRENT_DIR,
  UV_DIRENT_LINK,
  UV_DIRENT_FIFO,
  UV_DIRENT_SOCKET,
  UV_DIRENT_CHAR,
  UV_DIRENT_BLOCK
} uv_dirent_type_t;

uv_errno_t

enum uv_errno_t

Enumerator
UV_ERRNO_MAX

Definition at line 182 of file uv.h.

             {
#define XX(code, _) UV_ ## code = UV__ ## code,
  UV_ERRNO_MAP(XX)
#undef XX
  UV_ERRNO_MAX = UV__EOF - 1
} uv_errno_t;

uv_fs_event

enum uv_fs_event

Enumerator
UV_RENAME
UV_CHANGE

Definition at line 1540 of file uv.h.

                 {
  UV_RENAME = 1,
  UV_CHANGE = 2
};

uv_fs_event_flags

enum uv_fs_event_flags

Enumerator
UV_FS_EVENT_WATCH_ENTRY
UV_FS_EVENT_STAT
UV_FS_EVENT_RECURSIVE

Definition at line 1596 of file uv.h.

                       {
  /*
   * By default, if the fs event watcher is given a directory name, we will
   * watch for all events in that directory. This flags overrides this behavior
   * and makes fs_event report only changes to the directory entry itself. This
   * flag does not affect individual files watched.
   * This flag is currently not implemented yet on any backend.
   */
  UV_FS_EVENT_WATCH_ENTRY = 1,
 
  /*
   * By default uv_fs_event will try to use a kernel interface such as inotify
   * or kqueue to detect events. This may not work on remote filesystems such
   * as NFS mounts. This flag makes fs_event fall back to calling stat() on a
   * regular interval.
   * This flag is currently not implemented yet on any backend.
   */
  UV_FS_EVENT_STAT = 2,
 
  /*
   * By default, event watcher, when watching directory, is not registering
   * (is ignoring) changes in it's subdirectories.
   * This flag will override this behaviour on platforms that support it.
   */
  UV_FS_EVENT_RECURSIVE = 4
};

uv_fs_type

enum uv_fs_type

Enumerator
UV_FS_UNKNOWN
UV_FS_CUSTOM
UV_FS_OPEN
UV_FS_CLOSE
UV_FS_READ
UV_FS_WRITE
UV_FS_SENDFILE
UV_FS_STAT
UV_FS_LSTAT
UV_FS_FSTAT
UV_FS_FTRUNCATE
UV_FS_UTIME
UV_FS_FUTIME
UV_FS_ACCESS
UV_FS_CHMOD
UV_FS_FCHMOD
UV_FS_FSYNC
UV_FS_FDATASYNC
UV_FS_UNLINK
UV_FS_RMDIR
UV_FS_MKDIR
UV_FS_MKDTEMP
UV_FS_RENAME
UV_FS_SCANDIR
UV_FS_LINK
UV_FS_SYMLINK
UV_FS_READLINK
UV_FS_CHOWN
UV_FS_FCHOWN
UV_FS_REALPATH
UV_FS_COPYFILE
UV_FS_LCHOWN
UV_FS_OPENDIR
UV_FS_READDIR
UV_FS_CLOSEDIR
UV_FS_STATFS
UV_FS_MKSTEMP
UV_FS_LUTIME

Definition at line 1257 of file uv.h.

             {
  UV_FS_UNKNOWN = -1,
  UV_FS_CUSTOM,
  UV_FS_OPEN,
  UV_FS_CLOSE,
  UV_FS_READ,
  UV_FS_WRITE,
  UV_FS_SENDFILE,
  UV_FS_STAT,
  UV_FS_LSTAT,
  UV_FS_FSTAT,
  UV_FS_FTRUNCATE,
  UV_FS_UTIME,
  UV_FS_FUTIME,
  UV_FS_ACCESS,
  UV_FS_CHMOD,
  UV_FS_FCHMOD,
  UV_FS_FSYNC,
  UV_FS_FDATASYNC,
  UV_FS_UNLINK,
  UV_FS_RMDIR,
  UV_FS_MKDIR,
  UV_FS_MKDTEMP,
  UV_FS_RENAME,
  UV_FS_SCANDIR,
  UV_FS_LINK,
  UV_FS_SYMLINK,
  UV_FS_READLINK,
  UV_FS_CHOWN,
  UV_FS_FCHOWN,
  UV_FS_REALPATH,
  UV_FS_COPYFILE,
  UV_FS_LCHOWN,
  UV_FS_OPENDIR,
  UV_FS_READDIR,
  UV_FS_CLOSEDIR,
  UV_FS_STATFS,
  UV_FS_MKSTEMP,
  UV_FS_LUTIME
} uv_fs_type;

uv_handle_type

enum uv_handle_type

Enumerator
UV_UNKNOWN_HANDLE
UV_FILE
UV_HANDLE_TYPE_MAX

Definition at line 189 of file uv.h.

             {
  UV_UNKNOWN_HANDLE = 0,
#define XX(uc, lc) UV_##uc,
  UV_HANDLE_TYPE_MAP(XX)
#undef XX
  UV_FILE,
  UV_HANDLE_TYPE_MAX
} uv_handle_type;

uv_loop_option

enum uv_loop_option

Enumerator
UV_LOOP_BLOCK_SIGNAL
UV_METRICS_IDLE_TIME

Definition at line 249 of file uv.h.

             {
  UV_LOOP_BLOCK_SIGNAL = 0,
  UV_METRICS_IDLE_TIME
} uv_loop_option;

uv_membership

enum uv_membership

Enumerator
UV_LEAVE_GROUP
UV_JOIN_GROUP

Definition at line 382 of file uv.h.

             {
  UV_LEAVE_GROUP = 0,
  UV_JOIN_GROUP
} uv_membership;

uv_poll_event

enum uv_poll_event

Enumerator
UV_READABLE
UV_WRITABLE
UV_DISCONNECT
UV_PRIORITIZED

Definition at line 799 of file uv.h.

                   {
  UV_READABLE = 1,
  UV_WRITABLE = 2,
  UV_DISCONNECT = 4,
  UV_PRIORITIZED = 8
};

uv_process_flags

enum uv_process_flags

Enumerator
UV_PROCESS_SETUID
UV_PROCESS_SETGID
UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS
UV_PROCESS_DETACHED
UV_PROCESS_WINDOWS_HIDE
UV_PROCESS_WINDOWS_HIDE_CONSOLE
UV_PROCESS_WINDOWS_HIDE_GUI

Definition at line 999 of file uv.h.

                      {
  /*
   * Set the child process' user id. The user id is supplied in the `uid` field
   * of the options struct. This does not work on windows; setting this flag
   * will cause uv_spawn() to fail.
   */
  UV_PROCESS_SETUID = (1 << 0),
  /*
   * Set the child process' group id. The user id is supplied in the `gid`
   * field of the options struct. This does not work on windows; setting this
   * flag will cause uv_spawn() to fail.
   */
  UV_PROCESS_SETGID = (1 << 1),
  /*
   * Do not wrap any arguments in quotes, or perform any other escaping, when
   * converting the argument list into a command line string. This option is
   * only meaningful on Windows systems. On Unix it is silently ignored.
   */
  UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS = (1 << 2),
  /*
   * Spawn the child process in a detached state - this will make it a process
   * group leader, and will effectively enable the child to keep running after
   * the parent exits.  Note that the child process will still keep the
   * parent's event loop alive unless the parent process calls uv_unref() on
   * the child's process handle.
   */
  UV_PROCESS_DETACHED = (1 << 3),
  /*
   * Hide the subprocess window that would normally be created. This option is
   * only meaningful on Windows systems. On Unix it is silently ignored.
   */
  UV_PROCESS_WINDOWS_HIDE = (1 << 4),
  /*
   * Hide the subprocess console window that would normally be created. This
   * option is only meaningful on Windows systems. On Unix it is silently
   * ignored.
   */
  UV_PROCESS_WINDOWS_HIDE_CONSOLE = (1 << 5),
  /*
   * Hide the subprocess GUI window that would normally be created. This
   * option is only meaningful on Windows systems. On Unix it is silently
   * ignored.
   */
  UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6)
};

uv_req_type

enum uv_req_type

Enumerator
UV_UNKNOWN_REQ
UV_REQ_TYPE_MAX

Definition at line 198 of file uv.h.

             {
  UV_UNKNOWN_REQ = 0,
#define XX(uc, lc) UV_##uc,
  UV_REQ_TYPE_MAP(XX)
#undef XX
  UV_REQ_TYPE_PRIVATE
  UV_REQ_TYPE_MAX
} uv_req_type;

uv_run_mode

enum uv_run_mode

Enumerator
UV_RUN_DEFAULT
UV_RUN_ONCE
UV_RUN_NOWAIT

Definition at line 254 of file uv.h.

             {
  UV_RUN_DEFAULT = 0,
  UV_RUN_ONCE,
  UV_RUN_NOWAIT
} uv_run_mode;

uv_stdio_flags

enum uv_stdio_flags

Enumerator
UV_IGNORE
UV_CREATE_PIPE
UV_INHERIT_FD
UV_INHERIT_STREAM
UV_READABLE_PIPE
UV_WRITABLE_PIPE
UV_OVERLAPPED_PIPE

Definition at line 921 of file uv.h.

             {
  UV_IGNORE         = 0x00,
  UV_CREATE_PIPE    = 0x01,
  UV_INHERIT_FD     = 0x02,
  UV_INHERIT_STREAM = 0x04,
 
  /*
   * When UV_CREATE_PIPE is specified, UV_READABLE_PIPE and UV_WRITABLE_PIPE
   * determine the direction of flow, from the child process' perspective. Both
   * flags may be specified to create a duplex data stream.
   */
  UV_READABLE_PIPE  = 0x10,
  UV_WRITABLE_PIPE  = 0x20,
 
  /*
   * Open the child pipe handle in overlapped mode on Windows.
   * On Unix it is silently ignored.
   */
  UV_OVERLAPPED_PIPE = 0x40
} uv_stdio_flags;

uv_tcp_flags

enum uv_tcp_flags

Enumerator
UV_TCP_IPV6ONLY

Definition at line 562 of file uv.h.

                  {
  /* Used with uv_tcp_bind, when an IPv6 address is used. */
  UV_TCP_IPV6ONLY = 1
};

uv_thread_create_flags

enum uv_thread_create_flags

Enumerator
UV_THREAD_NO_FLAGS
UV_THREAD_HAS_STACK_SIZE

Definition at line 1747 of file uv.h.

             {
  UV_THREAD_NO_FLAGS = 0x00,
  UV_THREAD_HAS_STACK_SIZE = 0x01
} uv_thread_create_flags;

uv_tty_mode_t

enum uv_tty_mode_t

Enumerator
UV_TTY_MODE_NORMAL
UV_TTY_MODE_RAW
UV_TTY_MODE_IO

Definition at line 720 of file uv.h.

             {
  /* Initial/normal terminal mode */
  UV_TTY_MODE_NORMAL,
  /* Raw input mode (On Windows, ENABLE_WINDOW_INPUT is also enabled) */
  UV_TTY_MODE_RAW,
  /* Binary-safe I/O mode for IPC (Unix-only) */
  UV_TTY_MODE_IO
} uv_tty_mode_t;

uv_tty_vtermstate_t

enum uv_tty_vtermstate_t

Enumerator
UV_TTY_SUPPORTED
UV_TTY_UNSUPPORTED

Definition at line 729 of file uv.h.

             {
  /*
   * The console supports handling of virtual terminal sequences
   * (Windows10 new console, ConEmu)
   */
  UV_TTY_SUPPORTED,
  /* The console cannot process the virtual terminal sequence.  (Legacy
   * console)
   */
  UV_TTY_UNSUPPORTED
} uv_tty_vtermstate_t;

uv_udp_flags

enum uv_udp_flags

Enumerator
UV_UDP_IPV6ONLY
UV_UDP_PARTIAL
UV_UDP_REUSEADDR
UV_UDP_MMSG_CHUNK
UV_UDP_MMSG_FREE
UV_UDP_RECVMMSG

Definition at line 595 of file uv.h.

                  {
  /* Disables dual stack mode. */
  UV_UDP_IPV6ONLY = 1,
  /*
   * Indicates message was truncated because read buffer was too small. The
   * remainder was discarded by the OS. Used in uv_udp_recv_cb.
   */
  UV_UDP_PARTIAL = 2,
  /*
   * Indicates if SO_REUSEADDR will be set when binding the handle.
   * This sets the SO_REUSEPORT socket flag on the BSDs and OS X. On other
   * Unix platforms, it sets the SO_REUSEADDR flag.  What that means is that
   * multiple threads or processes can bind to the same address without error
   * (provided they all set the flag) but only the last one to bind will receive
   * any traffic, in effect "stealing" the port from the previous listener.
   */
  UV_UDP_REUSEADDR = 4,
  /*
   * Indicates that the message was received by recvmmsg, so the buffer provided
   * must not be freed by the recv_cb callback.
   */
  UV_UDP_MMSG_CHUNK = 8,
  /*
   * Indicates that the buffer provided has been fully utilized by recvmmsg and
   * that it should now be freed by the recv_cb callback. When this flag is set
   * in uv_udp_recv_cb, nread will always be 0 and addr will always be NULL.
   */
  UV_UDP_MMSG_FREE = 16,
 
  /*
   * Indicates that recvmmsg should be used, if available.
   */
  UV_UDP_RECVMMSG = 256
};

Function Documentation

uv_accept()

UV_EXTERN int uv_accept	(	uv_stream_t *	server,
		uv_stream_t *	client
	)

Definition at line 591 of file stream.c.

                                                        {
  int err;
 
  assert(server->loop == client->loop);
 
  if (server->accepted_fd == -1)
    return UV_EAGAIN;
 
  switch (client->type) {
    case UV_NAMED_PIPE:
    case UV_TCP:
      err = uv__stream_open(client,
                            server->accepted_fd,
                            UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
      if (err) {
        /* TODO handle error */
        uv__close(server->accepted_fd);
        goto done;
      }
      break;
 
    case UV_UDP:
      err = uv_udp_open((uv_udp_t*) client, server->accepted_fd);
      if (err) {
        uv__close(server->accepted_fd);
        goto done;
      }
      break;
 
    default:
      return UV_EINVAL;
  }
 
  client->flags |= UV_HANDLE_BOUND;
 
done:
  /* Process queued fds */
  if (server->queued_fds != NULL) {
    uv__stream_queued_fds_t* queued_fds;
 
    queued_fds = server->queued_fds;
 
    /* Read first */
    server->accepted_fd = queued_fds->fds[0];
 
    /* All read, free */
    assert(queued_fds->offset > 0);
    if (--queued_fds->offset == 0) {
      uv__free(queued_fds);
      server->queued_fds = NULL;
    } else {
      /* Shift rest */
      memmove(queued_fds->fds,
              queued_fds->fds + 1,
              queued_fds->offset * sizeof(*queued_fds->fds));
    }
  } else {
    server->accepted_fd = -1;
    if (err == 0)
      uv__io_start(server->loop, &server->io_watcher, POLLIN);
  }
  return err;
}

References assert(), done, err, uv__stream_queued_fds_s::fds, NULL, uv__stream_queued_fds_s::offset, uv__close(), uv__free(), uv__io_start(), uv__stream_open(), UV_HANDLE_BOUND, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_pipe_accept(), uv_tcp_accept(), uv_translate_sys_error(), and uv_udp_open().

Referenced by on_new_connection().

uv_async_init()

UV_EXTERN int uv_async_init	(	uv_loop_t *	loop,
		uv_async_t *	async,
		uv_async_cb	async_cb
	)

Definition at line 45 of file async.c.

                                                                             {
  int err;
 
  err = uv__async_start(loop);
  if (err)
    return err;
 
  uv__handle_init(loop, (uv_handle_t*)handle, UV_ASYNC);
  handle->async_cb = async_cb;
  handle->pending = 0;
 
  QUEUE_INSERT_TAIL(&loop->async_handles, &handle->queue);
  uv__handle_start(handle);
 
  return 0;
}

References err, handle, loop, QUEUE_INSERT_TAIL, req, uv__async_start(), uv__handle_init, uv__handle_start, and UV_REQ_INIT.

Referenced by main(), and uv_loop_init().

uv_async_send()

UV_EXTERN int uv_async_send

(

uv_async_t *

async

)

Definition at line 63 of file async.c.

                                      {
  /* Do a cheap read first. */
  if (ACCESS_ONCE(int, handle->pending) != 0)
    return 0;
 
  /* Tell the other thread we're busy with the handle. */
  if (cmpxchgi(&handle->pending, 0, 1) != 0)
    return 0;
 
  /* Wake up the other thread's event loop. */
  uv__async_send(handle->loop);
 
  /* Tell the other thread we're done. */
  if (cmpxchgi(&handle->pending, 1, 2) != 1)
    abort();
 
  return 0;
}

References ACCESS_ONCE, assert(), handle, loop, POST_COMPLETION_FOR_REQ, uv__async_send(), uv__atomic_exchange_set(), and UV_HANDLE_CLOSING.

Referenced by fake_download(), uv__work_cancel(), and worker().

uv_backend_fd()

UV_EXTERN int uv_backend_fd

(

const uv_loop_t *

loop

)

Definition at line 328 of file core.c.

                                         {
  return loop->backend_fd;
}

References loop.

uv_backend_timeout()

UV_EXTERN int uv_backend_timeout

(

const uv_loop_t *

loop

)

Definition at line 333 of file core.c.

                                              {
  if (loop->stop_flag != 0)
    return 0;
 
  if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
    return 0;
 
  if (!QUEUE_EMPTY(&loop->idle_handles))
    return 0;
 
  if (!QUEUE_EMPTY(&loop->pending_queue))
    return 0;
 
  if (loop->closing_handles)
    return 0;
 
  return uv__next_timeout(loop);
}

References loop, QUEUE_EMPTY, uv_loop_s::stop_flag, uv__has_active_handles, uv__has_active_reqs, and uv__next_timeout().

Referenced by uv_run().

uv_barrier_destroy()

UV_EXTERN void uv_barrier_destroy

(

uv_barrier_t *

barrier

)

Definition at line 118 of file thread.c.

                                               {
  struct _uv_barrier* b;
 
  b = barrier->b;
  uv_mutex_lock(&b->mutex);
 
  assert(b->in == 0);
  assert(b->out == 0);
 
  if (b->in != 0 || b->out != 0)
    abort();
 
  uv_mutex_unlock(&b->mutex);
  uv_mutex_destroy(&b->mutex);
  uv_cond_destroy(&b->cond);
 
  uv__free(barrier->b);
  barrier->b = NULL;
}

References assert(), uv_barrier_t::b, b, uv_barrier_t::mutex, NULL, uv_barrier_t::turnstile1, uv_barrier_t::turnstile2, uv__free(), uv_cond_destroy(), uv_mutex_destroy(), uv_mutex_lock(), uv_mutex_unlock(), and uv_sem_destroy().

Referenced by main().

uv_barrier_init()

UV_EXTERN int uv_barrier_init	(	uv_barrier_t *	barrier,
		unsigned int	count
	)

Definition at line 55 of file thread.c.

                                                               {
  struct _uv_barrier* b;
  int rc;
 
  if (barrier == NULL || count == 0)
    return UV_EINVAL;
 
  b = uv__malloc(sizeof(*b));
  if (b == NULL)
    return UV_ENOMEM;
 
  b->in = 0;
  b->out = 0;
  b->threshold = count;
 
  rc = uv_mutex_init(&b->mutex);
  if (rc != 0)
    goto error2;
 
  rc = uv_cond_init(&b->cond);
  if (rc != 0)
    goto error;
 
  barrier->b = b;
  return 0;
 
error:
  uv_mutex_destroy(&b->mutex);
error2:
  uv__free(b);
  return rc;
}

References uv_barrier_t::b, b, count, uv_barrier_t::count, err, error(), uv_barrier_t::mutex, uv_barrier_t::n, NULL, uv_barrier_t::turnstile1, uv_barrier_t::turnstile2, uv__free(), uv__malloc(), uv_cond_init(), uv_mutex_destroy(), uv_mutex_init(), uv_sem_destroy(), and uv_sem_init().

Referenced by main().

uv_barrier_wait()

UV_EXTERN int uv_barrier_wait

(

uv_barrier_t *

barrier

)

Definition at line 89 of file thread.c.

                                           {
  struct _uv_barrier* b;
  int last;
 
  if (barrier == NULL || barrier->b == NULL)
    return UV_EINVAL;
 
  b = barrier->b;
  uv_mutex_lock(&b->mutex);
 
  if (++b->in == b->threshold) {
    b->in = 0;
    b->out = b->threshold;
    uv_cond_signal(&b->cond);
  } else {
    do
      uv_cond_wait(&b->cond, &b->mutex);
    while (b->in != 0);
  }
 
  last = (--b->out == 0);
  if (!last)
    uv_cond_signal(&b->cond);  /* Not needed for last thread. */
 
  uv_mutex_unlock(&b->mutex);
  return last;
}

References uv_barrier_t::b, b, uv_barrier_t::count, uv_barrier_t::mutex, uv_barrier_t::n, NULL, uv_barrier_t::turnstile1, uv_barrier_t::turnstile2, uv_cond_signal(), uv_cond_wait(), uv_mutex_lock(), uv_mutex_unlock(), uv_sem_post(), and uv_sem_wait().

Referenced by main(), reader(), and writer().

uv_buf_init()

UV_EXTERN uv_buf_t uv_buf_init	(	char *	base,
		unsigned int	len
	)

Definition at line 157 of file uv-common.c.

                                                   {
  uv_buf_t buf;
  buf.base = base;
  buf.len = len;
  return buf;
}

References len.

Referenced by alloc_buffer(), echo_read(), main(), on_new_connection(), on_open(), on_type(), uv__build_coalesced_write_req(), uv__pipe_read_data(), uv__pipe_write_ipc(), uv__read(), uv__udp_recvmsg(), uv_process_tcp_read_req(), uv_process_tty_read_raw_req(), uv_process_udp_recv_req(), uv_tcp_queue_read(), uv_tty_queue_read_line(), uv_udp_queue_recv(), and write_data().

uv_cancel()

UV_EXTERN int uv_cancel

(

uv_req_t *

req

)

Definition at line 358 of file threadpool.c.

                             {
  struct uv__work* wreq;
  uv_loop_t* loop;
 
  switch (req->type) {
  case UV_FS:
    loop =  ((uv_fs_t*) req)->loop;
    wreq = &((uv_fs_t*) req)->work_req;
    break;
  case UV_GETADDRINFO:
    loop =  ((uv_getaddrinfo_t*) req)->loop;
    wreq = &((uv_getaddrinfo_t*) req)->work_req;
    break;
  case UV_GETNAMEINFO:
    loop = ((uv_getnameinfo_t*) req)->loop;
    wreq = &((uv_getnameinfo_t*) req)->work_req;
    break;
  case UV_RANDOM:
    loop = ((uv_random_t*) req)->loop;
    wreq = &((uv_random_t*) req)->work_req;
    break;
  case UV_WORK:
    loop =  ((uv_work_t*) req)->loop;
    wreq = &((uv_work_t*) req)->work_req;
    break;
  default:
    return UV_EINVAL;
  }
 
  return uv__work_cancel(loop, req, wreq);
}

References loop, req, and uv__work_cancel().

Referenced by signal_handler().

uv_chdir()

UV_EXTERN int uv_chdir

(

const char *

dir

)

Definition at line 747 of file core.c.

                              {
  if (chdir(dir))
    return UV__ERR(errno);
 
  return 0;
}

References chdir, L, NULL, UV__ERR, uv__free(), uv__malloc(), and uv_translate_sys_error().

uv_check_init()

UV_EXTERN int uv_check_init	(	uv_loop_t *	,
		uv_check_t *	check
	)

uv_check_start()

UV_EXTERN int uv_check_start	(	uv_check_t *	check,
		uv_check_cb	cb
	)

uv_check_stop()

UV_EXTERN int uv_check_stop

(

uv_check_t *

check

)

Referenced by uv_close().

uv_close()

UV_EXTERN void uv_close	(	uv_handle_t *	handle,
		uv_close_cb	close_cb
	)

Definition at line 108 of file core.c.

                                                         {
  assert(!uv__is_closing(handle));
 
  handle->flags |= UV_HANDLE_CLOSING;
  handle->close_cb = close_cb;
 
  switch (handle->type) {
  case UV_NAMED_PIPE:
    uv__pipe_close((uv_pipe_t*)handle);
    break;
 
  case UV_TTY:
    uv__stream_close((uv_stream_t*)handle);
    break;
 
  case UV_TCP:
    uv__tcp_close((uv_tcp_t*)handle);
    break;
 
  case UV_UDP:
    uv__udp_close((uv_udp_t*)handle);
    break;
 
  case UV_PREPARE:
    uv__prepare_close((uv_prepare_t*)handle);
    break;
 
  case UV_CHECK:
    uv__check_close((uv_check_t*)handle);
    break;
 
  case UV_IDLE:
    uv__idle_close((uv_idle_t*)handle);
    break;
 
  case UV_ASYNC:
    uv__async_close((uv_async_t*)handle);
    break;
 
  case UV_TIMER:
    uv__timer_close((uv_timer_t*)handle);
    break;
 
  case UV_PROCESS:
    uv__process_close((uv_process_t*)handle);
    break;
 
  case UV_FS_EVENT:
    uv__fs_event_close((uv_fs_event_t*)handle);
    break;
 
  case UV_POLL:
    uv__poll_close((uv_poll_t*)handle);
    break;
 
  case UV_FS_POLL:
    uv__fs_poll_close((uv_fs_poll_t*)handle);
    /* Poll handles use file system requests, and one of them may still be
     * running. The poll code will call uv__make_close_pending() for us. */
    return;
 
  case UV_SIGNAL:
    uv__signal_close((uv_signal_t*) handle);
    break;
 
  default:
    assert(0);
  }
 
  uv__make_close_pending(handle);
}

References assert(), cb, handle, loop, uv__async_close(), uv__check_close(), uv__fs_event_close(), uv__fs_poll_close(), uv__handle_closing, uv__idle_close(), uv__is_closing, uv__make_close_pending(), uv__pipe_close(), uv__poll_close(), uv__prepare_close(), uv__process_close(), uv__signal_close(), uv__stream_close(), uv__tcp_close(), uv__timer_close(), uv__udp_close(), uv_async_close(), uv_check_stop(), uv_fs_event_close(), UV_HANDLE_CLOSING, uv_idle_stop(), uv_pipe_close(), uv_poll_close(), uv_prepare_stop(), uv_process_close(), uv_signal_close(), uv_tcp_close(), uv_timer_stop(), uv_tty_close(), uv_udp_close(), and uv_want_endgame().

Referenced by after(), cleanup_handles(), close_process_handle(), destroy_curl_context(), echo_read(), eof_timer_destroy(), on_exit(), on_new_connection(), on_read(), poll_cb(), read_stdin(), uv__stream_close(), uv_fs_poll_stop(), and uv_tcp_close_reset().

uv_cond_broadcast()

UV_EXTERN void uv_cond_broadcast

(

uv_cond_t *

cond

)

Definition at line 774 of file thread.c.

                                        {
  if (pthread_cond_broadcast(cond))
    abort();
}

References cond.

uv_cond_destroy()

UV_EXTERN void uv_cond_destroy

(

uv_cond_t *

cond

)

Definition at line 735 of file thread.c.

                                      {
#if defined(__APPLE__) && defined(__MACH__)
  /* It has been reported that destroying condition variables that have been
   * signalled but not waited on can sometimes result in application crashes.
   * See https://codereview.chromium.org/1323293005.
   */
  pthread_mutex_t mutex;
  struct timespec ts;
  int err;
 
  if (pthread_mutex_init(&mutex, NULL))
    abort();
 
  if (pthread_mutex_lock(&mutex))
    abort();
 
  ts.tv_sec = 0;
  ts.tv_nsec = 1;
 
  err = pthread_cond_timedwait_relative_np(cond, &mutex, &ts);
  if (err != 0 && err != ETIMEDOUT)
    abort();
 
  if (pthread_mutex_unlock(&mutex))
    abort();
 
  if (pthread_mutex_destroy(&mutex))
    abort();
#endif /* defined(__APPLE__) && defined(__MACH__) */
 
  if (pthread_cond_destroy(cond))
    abort();
}

References cond, err, ETIMEDOUT, mutex, NULL, timespec::tv_nsec, and timespec::tv_sec.

Referenced by uv__custom_sem_destroy(), uv__threadpool_cleanup(), and uv_barrier_destroy().

uv_cond_init()

UV_EXTERN int uv_cond_init

(

uv_cond_t *

cond

)

Definition at line 704 of file thread.c.

                                  {
  pthread_condattr_t attr;
  int err;
 
  err = pthread_condattr_init(&attr);
  if (err)
    return UV__ERR(err);
 
  err = pthread_condattr_setclock(&attr, CLOCK_MONOTONIC);
  if (err)
    goto error2;
 
  err = pthread_cond_init(cond, &attr);
  if (err)
    goto error2;
 
  err = pthread_condattr_destroy(&attr);
  if (err)
    goto error;
 
  return 0;
 
error:
  pthread_cond_destroy(cond);
error2:
  pthread_condattr_destroy(&attr);
  return UV__ERR(err);
}

References cond, err, error(), and UV__ERR.

Referenced by init_threads(), uv__custom_sem_init(), and uv_barrier_init().

uv_cond_signal()

UV_EXTERN void uv_cond_signal

(

uv_cond_t *

cond

)

Definition at line 769 of file thread.c.

                                     {
  if (pthread_cond_signal(cond))
    abort();
}

References cond.

Referenced by post(), uv__custom_sem_post(), uv_barrier_wait(), and worker().

uv_cond_timedwait()

UV_EXTERN int uv_cond_timedwait	(	uv_cond_t *	cond,
		uv_mutex_t *	mutex,
		uint64_t	timeout
	)

Definition at line 785 of file thread.c.

                                                                            {
  int r;
  struct timespec ts;
#if defined(__MVS__)
  struct timeval tv;
#endif
 
#if defined(__APPLE__) && defined(__MACH__)
  ts.tv_sec = timeout / NANOSEC;
  ts.tv_nsec = timeout % NANOSEC;
  r = pthread_cond_timedwait_relative_np(cond, mutex, &ts);
#else
#if defined(__MVS__)
  if (gettimeofday(&tv, NULL))
    abort();
  timeout += tv.tv_sec * NANOSEC + tv.tv_usec * 1e3;
#else
  timeout += uv__hrtime(UV_CLOCK_PRECISE);
#endif
  ts.tv_sec = timeout / NANOSEC;
  ts.tv_nsec = timeout % NANOSEC;
  r = pthread_cond_timedwait(cond, mutex, &ts);
#endif
 
 
  if (r == 0)
    return 0;
 
  if (r == ETIMEDOUT)
    return UV_ETIMEDOUT;
 
  abort();
#ifndef __SUNPRO_C
  return UV_EINVAL;  /* Satisfy the compiler. */
#endif
}

References cond, DWORD, ETIMEDOUT, gettimeofday, mutex, NANOSEC, NULL, r, timeout, tv, timespec::tv_nsec, timespec::tv_sec, uv__hrtime(), and UV_CLOCK_PRECISE.

uv_cond_wait()

UV_EXTERN void uv_cond_wait	(	uv_cond_t *	cond,
		uv_mutex_t *	mutex
	)

Definition at line 779 of file thread.c.

                                                      {
  if (pthread_cond_wait(cond, mutex))
    abort();
}

References cond, and mutex.

Referenced by uv__custom_sem_wait(), uv_barrier_wait(), and worker().

uv_cpu_info()

UV_EXTERN int uv_cpu_info	(	uv_cpu_info_t **	cpu_infos,
		int *	count
	)

Definition at line 1044 of file aix.c.

                                                       {
  uv_cpu_info_t* cpu_info;
  perfstat_cpu_total_t ps_total;
  perfstat_cpu_t* ps_cpus;
  perfstat_id_t cpu_id;
  int result, ncpus, idx = 0;
 
  result = perfstat_cpu_total(NULL, &ps_total, sizeof(ps_total), 1);
  if (result == -1) {
    return UV_ENOSYS;
  }
 
  ncpus = result = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0);
  if (result == -1) {
    return UV_ENOSYS;
  }
 
  ps_cpus = (perfstat_cpu_t*) uv__malloc(ncpus * sizeof(perfstat_cpu_t));
  if (!ps_cpus) {
    return UV_ENOMEM;
  }
 
  /* TODO(bnoordhuis) Check uv__strscpy() return value. */
  uv__strscpy(cpu_id.name, FIRST_CPU, sizeof(cpu_id.name));
  result = perfstat_cpu(&cpu_id, ps_cpus, sizeof(perfstat_cpu_t), ncpus);
  if (result == -1) {
    uv__free(ps_cpus);
    return UV_ENOSYS;
  }
 
  *cpu_infos = (uv_cpu_info_t*) uv__malloc(ncpus * sizeof(uv_cpu_info_t));
  if (!*cpu_infos) {
    uv__free(ps_cpus);
    return UV_ENOMEM;
  }
 
  *count = ncpus;
 
  cpu_info = *cpu_infos;
  while (idx < ncpus) {
    cpu_info->speed = (int)(ps_total.processorHZ / 1000000);
    cpu_info->model = uv__strdup(ps_total.description);
    cpu_info->cpu_times.user = ps_cpus[idx].user;
    cpu_info->cpu_times.sys = ps_cpus[idx].sys;
    cpu_info->cpu_times.idle = ps_cpus[idx].idle;
    cpu_info->cpu_times.irq = ps_cpus[idx].wait;
    cpu_info->cpu_times.nice = 0;
    cpu_info++;
    idx++;
  }
 
  uv__free(ps_cpus);
  return 0;
}

References ARRAY_SIZE, assert(), data_area_ptr::assign, count, CP_IDLE, CP_INTR, CP_NICE, CP_SYS, CP_USER, CPCMODEL_LENGTH, uv_cpu_info_s::cpu_times, CPUSTATES, CSD_NUMBER_ONLINE_CPUS, CSD_OFFSET, CVT_PTR, CVTOPCTP_OFFSET, data_area_ptr::deref, DWORD, EINPROGRESS, EINTR, err, error(), benchmark::FILE, i, uv_cpu_times_s::idle, _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION::IdleTime, setup::idx, info(), int, _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION::InterruptTime, uv_cpu_times_s::irq, _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION::KernelTime, L, len, long, memcpy(), memset(), uv_cpu_info_s::model, ncpus, uv_cpu_times_s::nice, NT_SUCCESS, NULL, out, pNtQuerySystemInformation, pRtlNtStatusToDosError, RCTLACS_OFFSET, read_models(), read_speeds(), read_times(), RMCTRCT_OFFSET, uv_cpu_info_s::speed, status, strdup(), strings(), uv_cpu_times_s::sys, SystemProcessorPerformanceInformation, type, u_int64_t, ULONG, uv_cpu_times_s::user, _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION::UserTime, uv__calloc(), uv__convert_utf16_to_utf8(), uv__cpu_num(), UV__ERR, uv__free(), uv__get_cpu_speed(), uv__malloc(), uv__once_init(), uv__open_file(), uv__strdup(), uv__strscpy(), uv_free_cpu_info(), uv_translate_sys_error(), and which.

Referenced by setup_workers().

uv_cwd()

UV_EXTERN int uv_cwd	(	char *	buffer,
		size_t *	size
	)

Definition at line 708 of file core.c.

                                       {
  char scratch[1 + UV__PATH_MAX];
 
  if (buffer == NULL || size == NULL)
    return UV_EINVAL;
 
  /* Try to read directly into the user's buffer first... */
  if (getcwd(buffer, *size) != NULL)
    goto fixup;
 
  if (errno != ERANGE)
    return UV__ERR(errno);
 
  /* ...or into scratch space if the user's buffer is too small
   * so we can report how much space to provide on the next try.
   */
  if (getcwd(scratch, sizeof(scratch)) == NULL)
    return UV__ERR(errno);
 
  buffer = scratch;
 
fixup:
 
  *size = strlen(buffer);
 
  if (*size > 1 && buffer[*size - 1] == '/') {
    *size -= 1;
    buffer[*size] = '\0';
  }
 
  if (buffer == scratch) {
    *size += 1;
    return UV_ENOBUFS;
  }
 
  return 0;
}

References DWORD, ERANGE, INT_MAX, L, NULL, r, UV__ERR, uv__free(), uv__malloc(), UV__PATH_MAX, and uv_translate_sys_error().

uv_default_loop()

UV_EXTERN uv_loop_t* uv_default_loop

(

void

)

Definition at line 763 of file uv-common.c.

                                 {
  if (default_loop_ptr != NULL)
    return default_loop_ptr;
 
  if (uv_loop_init(&default_loop_struct))
    return NULL;
 
  default_loop_ptr = &default_loop_struct;
  return default_loop_ptr;
}

References default_loop_ptr, default_loop_struct, NULL, and uv_loop_init().

Referenced by idle_cb(), main(), on_open(), on_read(), on_write(), and uv__print_handles().

uv_disable_stdio_inheritance()

UV_EXTERN void uv_disable_stdio_inheritance

(

void

)

Definition at line 755 of file core.c.

                                        {
  int fd;
 
  /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
   * first 16 file descriptors. After that, bail out after the first error.
   */
  for (fd = 0; ; fd++)
    if (uv__cloexec(fd, 1) && fd > 15)
      break;
}

References fd, handle, HANDLE, INVALID_HANDLE_VALUE, NULL, si, uv__cloexec, uv__stdio_noinherit(), and uv__stdio_verify().

uv_dlclose()

UV_EXTERN void uv_dlclose

(

uv_lib_t *

lib

)

Definition at line 41 of file dl.c.

                               {
  uv__free(lib->errmsg);
  lib->errmsg = NULL;
 
  if (lib->handle) {
    /* Ignore errors. No good way to signal them without leaking memory. */
    dlclose(lib->handle);
    lib->handle = NULL;
  }
}

References uv_lib_t::errmsg, uv_lib_t::handle, NULL, and uv__free().

uv_dlerror()

UV_EXTERN const char* uv_dlerror

(

const uv_lib_t *

lib

)

Definition at line 60 of file dl.c.

                                            {
  return lib->errmsg ? lib->errmsg : "no error";
}

References uv_lib_t::errmsg.

Referenced by main().

uv_dlopen()

UV_EXTERN int uv_dlopen	(	const char *	filename,
		uv_lib_t *	lib
	)

Definition at line 33 of file dl.c.

                                                   {
  dlerror(); /* Reset error status. */
  lib->errmsg = NULL;
  lib->handle = dlopen(filename, RTLD_LAZY);
  return lib->handle ? 0 : uv__dlerror(lib);
}

References ARRAY_SIZE, uv_lib_t::errmsg, uv_lib_t::handle, NULL, and uv__dlerror().

Referenced by main().

uv_dlsym()

UV_EXTERN int uv_dlsym	(	uv_lib_t *	lib,
		const char *	name,
		void **	ptr
	)

Definition at line 53 of file dl.c.

                                                          {
  dlerror(); /* Reset error status. */
  *ptr = dlsym(lib->handle, name);
  return uv__dlerror(lib);
}

References uv_lib_t::handle, and uv__dlerror().

Referenced by main().

uv_err_name()

UV_EXTERN const char* uv_err_name

(

int

err

)

Definition at line 189 of file uv-common.c.

                                 {
  switch (err) {
    UV_ERRNO_MAP(UV_ERR_NAME_GEN)
  }
  return uv__unknown_err_code(err);
}

References err, uv__unknown_err_code(), UV_ERR_NAME_GEN, and UV_ERRNO_MAP.

Referenced by echo_read(), echo_write(), main(), on_connect(), on_new_connection(), on_read(), and on_resolved().

uv_err_name_r()

UV_EXTERN char* uv_err_name_r	(	int	err,
		char *	buf,
		size_t	buflen
	)

Definition at line 178 of file uv-common.c.

                                                       {
  switch (err) {
    UV_ERRNO_MAP(UV_ERR_NAME_GEN_R)
    default: snprintf(buf, buflen, "Unknown system error %d", err);
  }
  return buf;
}

References buflen, err, snprintf, UV_ERR_NAME_GEN_R, and UV_ERRNO_MAP.

uv_exepath()

UV_EXTERN int uv_exepath	(	char *	buffer,
		size_t *	size
	)

Definition at line 60 of file aix-common.c.

                                           {
  int res;
  char args[UV__PATH_MAX];
  size_t cached_len;
  struct procsinfo pi;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  uv_once(&process_title_mutex_once, init_process_title_mutex_once);
  uv_mutex_lock(&process_title_mutex);
  if (original_exepath != NULL) {
    cached_len = strlen(original_exepath);
    *size -= 1;
    if (*size > cached_len)
      *size = cached_len;
    memcpy(buffer, original_exepath, *size);
    buffer[*size] = '\0';
    uv_mutex_unlock(&process_title_mutex);
    return 0;
  }
  uv_mutex_unlock(&process_title_mutex);
  pi.pi_pid = getpid();
  res = getargs(&pi, sizeof(pi), args, sizeof(args));
 
  if (res < 0)
    return UV_EINVAL;
 
  return uv__search_path(args, buffer, size);
}

References args, ARRAY_SIZE, assert(), ENOMEM, err, error(), find_path(), getexe(), init_process_title_mutex_once(), int, L, memcpy(), n, NULL, original_exepath, out, path, pid, process_title_mutex, process_title_mutex_once, readlink, snprintf, status, UV__ERR, uv__free(), uv__malloc(), UV__PATH_MAX, uv__reallocf(), uv__search_path(), uv__strscpy(), uv_mutex_lock(), uv_mutex_unlock(), uv_once(), and uv_translate_sys_error().

Referenced by invoke_cgi_script(), main(), and setup_workers().

uv_fileno()

UV_EXTERN int uv_fileno	(	const uv_handle_t *	handle,
		uv_os_fd_t *	fd
	)

Definition at line 767 of file core.c.

                                                         {
  int fd_out;
 
  switch (handle->type) {
  case UV_TCP:
  case UV_NAMED_PIPE:
  case UV_TTY:
    fd_out = uv__stream_fd((uv_stream_t*) handle);
    break;
 
  case UV_UDP:
    fd_out = ((uv_udp_t *) handle)->io_watcher.fd;
    break;
 
  case UV_POLL:
    fd_out = ((uv_poll_t *) handle)->io_watcher.fd;
    break;
 
  default:
    return UV_EINVAL;
  }
 
  if (uv__is_closing(handle) || fd_out == -1)
    return UV_EBADF;
 
  *fd = fd_out;
  return 0;
}

References fd, handle, INVALID_HANDLE_VALUE, socket, uv__is_closing, uv__stream_fd, and uv_is_closing().

Referenced by on_new_connection(), and uv__getsockpeername().

uv_free_cpu_info()

UV_EXTERN void uv_free_cpu_info	(	uv_cpu_info_t *	cpu_infos,
		int	count
	)

Definition at line 846 of file uv-common.c.

                                                           {
  int i;
 
  for (i = 0; i < count; i++)
    uv__free(cpu_infos[i].model);
 
  uv__free(cpu_infos);
}

References count, i, and uv__free().

Referenced by setup_workers(), and uv_cpu_info().

uv_free_interface_addresses()

UV_EXTERN void uv_free_interface_addresses	(	uv_interface_address_t *	addresses,
		int	count
	)

Definition at line 1268 of file aix.c.

             {
  int i;
 
  for (i = 0; i < count; ++i) {
    uv__free(addresses[i].name);
  }
 
  uv__free(addresses);
}

References count, i, and uv__free().

Referenced by main(), and uv_interface_addresses().

uv_freeaddrinfo()

UV_EXTERN void uv_freeaddrinfo

(

struct addrinfo *

ai

)

Definition at line 223 of file getaddrinfo.c.

                                          {
  if (ai)
    freeaddrinfo(ai);
}

References uv__free().

Referenced by on_resolved().

uv_fs_access()

UV_EXTERN int uv_fs_access	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		int	mode,
		uv_fs_cb	cb
	)

Definition at line 1659 of file fs.c.

                              {
  INIT(ACCESS);
  PATH;
  req->flags = flags;
  POST;
}

References cb, err, flags, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_ACCESS.

uv_fs_chmod()

UV_EXTERN int uv_fs_chmod	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		int	mode,
		uv_fs_cb	cb
	)

Definition at line 1671 of file fs.c.

                             {
  INIT(CHMOD);
  PATH;
  req->mode = mode;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_CHMOD.

uv_fs_chown()

UV_EXTERN int uv_fs_chown	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_uid_t	uid,
		uv_gid_t	gid,
		uv_fs_cb	cb
	)

Definition at line 1683 of file fs.c.

                             {
  INIT(CHOWN);
  PATH;
  req->uid = uid;
  req->gid = gid;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_CHOWN.

uv_fs_close()

UV_EXTERN int uv_fs_close	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		uv_fs_cb	cb
	)

Definition at line 1697 of file fs.c.

                                                                          {
  INIT(CLOSE);
  req->file = file;
  POST;
}

References fd, file, INIT, POST, req, and UV_FS_CLOSE.

Referenced by on_read().

uv_fs_closedir()

UV_EXTERN int uv_fs_closedir	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_dir_t *	dir,
		uv_fs_cb	cb
	)

Definition at line 1933 of file fs.c.

                                {
  INIT(CLOSEDIR);
 
  if (dir == NULL)
    return UV_EINVAL;
 
  req->ptr = dir;
  POST;
}

References INIT, NULL, POST, req, SET_REQ_UV_ERROR, and UV_FS_CLOSEDIR.

uv_fs_copyfile()

UV_EXTERN int uv_fs_copyfile	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		const char *	new_path,
		int	flags,
		uv_fs_cb	cb
	)

Definition at line 2103 of file fs.c.

                                {
  INIT(COPYFILE);
 
  if (flags & ~(UV_FS_COPYFILE_EXCL |
                UV_FS_COPYFILE_FICLONE |
                UV_FS_COPYFILE_FICLONE_FORCE)) {
    return UV_EINVAL;
  }
 
  PATH2;
  req->flags = flags;
  POST;
}

References cb, err, flags, fs__capture_path(), INIT, NULL, path, PATH2, POST, req, SET_REQ_UV_ERROR, SET_REQ_WIN32_ERROR, UV_FS_COPYFILE, UV_FS_COPYFILE_EXCL, UV_FS_COPYFILE_FICLONE, and UV_FS_COPYFILE_FICLONE_FORCE.

uv_fs_event_getpath()

UV_EXTERN int uv_fs_event_getpath	(	uv_fs_event_t *	handle,
		char *	buffer,
		size_t *	size
	)

Definition at line 592 of file uv-common.c.

                                                                           {
  size_t required_len;
 
  if (!uv__is_active(handle)) {
    *size = 0;
    return UV_EINVAL;
  }
 
  required_len = strlen(handle->path);
  if (required_len >= *size) {
    *size = required_len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, handle->path, required_len);
  *size = required_len;
  buffer[required_len] = '\0';
 
  return 0;
}

References handle, memcpy(), and uv__is_active.

Referenced by run_command().

uv_fs_event_init()

UV_EXTERN int uv_fs_event_init	(	uv_loop_t *	loop,
		uv_fs_event_t *	handle
	)

Definition at line 757 of file aix.c.

                                                             {
#ifdef HAVE_SYS_AHAFS_EVPRODS_H
  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT);
  return 0;
#else
  return UV_ENOSYS;
#endif
}

References handle, INVALID_HANDLE_VALUE, loop, NULL, uv__handle_init, and UV_REQ_INIT.

Referenced by main().

uv_fs_event_start()

UV_EXTERN int uv_fs_event_start	(	uv_fs_event_t *	handle,
		uv_fs_event_cb	cb,
		const char *	path,
		unsigned int	flags
	)

Definition at line 767 of file aix.c.

                                          {
#ifdef HAVE_SYS_AHAFS_EVPRODS_H
  int  fd, rc, str_offset = 0;
  char cwd[PATH_MAX];
  char absolute_path[PATH_MAX];
  char readlink_cwd[PATH_MAX];
  struct timeval zt;
  fd_set pollfd;
 
 
  /* Figure out whether filename is absolute or not */
  if (filename[0] == '\0') {
    /* Missing a pathname */
    return UV_ENOENT;
  }
  else if (filename[0] == '/') {
    /* We have absolute pathname */
    /* TODO(bnoordhuis) Check uv__strscpy() return value. */
    uv__strscpy(absolute_path, filename, sizeof(absolute_path));
  } else {
    /* We have a relative pathname, compose the absolute pathname */
    snprintf(cwd, sizeof(cwd), "/proc/%lu/cwd", (unsigned long) getpid());
    rc = readlink(cwd, readlink_cwd, sizeof(readlink_cwd) - 1);
    if (rc < 0)
      return rc;
    /* readlink does not null terminate our string */
    readlink_cwd[rc] = '\0';
 
    if (filename[0] == '.' && filename[1] == '/')
      str_offset = 2;
 
    snprintf(absolute_path, sizeof(absolute_path), "%s%s", readlink_cwd,
             filename + str_offset);
  }
 
  if (uv__is_ahafs_mounted() < 0)  /* /aha checks failed */
    return UV_ENOSYS;
 
  /* Setup ahafs */
  rc = uv__setup_ahafs((const char *)absolute_path, &fd);
  if (rc != 0)
    return rc;
 
  /* Setup/Initialize all the libuv routines */
  uv__handle_start(handle);
  uv__io_init(&handle->event_watcher, uv__ahafs_event, fd);
  handle->path = uv__strdup(filename);
  handle->cb = cb;
  handle->dir_filename = NULL;
 
  uv__io_start(handle->loop, &handle->event_watcher, POLLIN);
 
  /* AHAFS wants someone to poll for it to start mointoring.
   *  so kick-start it so that we don't miss an event in the
   *  eventuality of an event that occurs in the current loop. */
  do {
    memset(&zt, 0, sizeof(zt));
    FD_ZERO(&pollfd);
    FD_SET(fd, &pollfd);
    rc = select(fd + 1, &pollfd, NULL, NULL, &zt);
  } while (rc == -1 && errno == EINTR);
  return 0;
#else
  return UV_ENOSYS;
#endif
}

References assert(), CAST, cb, test-lz4-speed::cwd, DWORD, EINTR, err, error(), FALSE, fd, FD_SET, FD_ZERO, find_watcher(), flags, fstat, handle, init_inotify(), INVALID_HANDLE_VALUE, len, memcpy(), memset(), uv__os390_epoll::msg_queue, NULL, O_RDONLY, path, QUEUE_INIT, QUEUE_INSERT_TAIL, r, RB_INSERT, readlink, select, snprintf, TRUE, uv__close_nocheckstdio(), UV__ERR, uv__free(), uv__fs_event(), uv__fsevents_init(), uv__handle_start, uv__handle_stop, uv__io_init(), uv__io_start(), uv__is_active, uv__load_relaxed, uv__malloc(), uv__strdup(), uv__strscpy(), uv_directory_watcher_buffer_size, uv_fatal_error(), UV_FS_EVENT_RECURSIVE, uv_split_path(), uv_translate_sys_error(), and w.

Referenced by main(), and uv__inotify_fork().

uv_fs_event_stop()

UV_EXTERN int uv_fs_event_stop

(

uv_fs_event_t *

handle

)

Definition at line 838 of file aix.c.

                                            {
#ifdef HAVE_SYS_AHAFS_EVPRODS_H
  if (!uv__is_active(handle))
    return 0;
 
  uv__io_close(handle->loop, &handle->event_watcher);
  uv__handle_stop(handle);
 
  if (uv__path_is_a_directory(handle->path) == 0) {
    uv__free(handle->dir_filename);
    handle->dir_filename = NULL;
  }
 
  uv__free(handle->path);
  handle->path = NULL;
  uv__close(handle->event_watcher.fd);
  handle->event_watcher.fd = -1;
 
  return 0;
#else
  return UV_ENOSYS;
#endif
}

References assert(), EALREADY, ENOENT, find_watcher(), handle, INVALID_HANDLE_VALUE, maybe_free_watcher_list(), memcpy(), uv__os390_epoll::msg_queue, NULL, QUEUE_REMOVE, r, uv__close(), uv__free(), uv__fsevents_close(), uv__handle_stop, uv__io_close(), uv__is_active, uv__load_relaxed, and w.

Referenced by uv__fs_event_close(), uv__inotify_fork(), and uv_fs_event_close().

uv_fs_fchmod()

UV_EXTERN int uv_fs_fchmod	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		int	mode,
		uv_fs_cb	cb
	)

Definition at line 1704 of file fs.c.

                              {
  INIT(FCHMOD);
  req->file = file;
  req->mode = mode;
  POST;
}

References fd, file, INIT, POST, req, and UV_FS_FCHMOD.

uv_fs_fchown()

UV_EXTERN int uv_fs_fchown	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		uv_uid_t	uid,
		uv_gid_t	gid,
		uv_fs_cb	cb
	)

Definition at line 1716 of file fs.c.

                              {
  INIT(FCHOWN);
  req->file = file;
  req->uid = uid;
  req->gid = gid;
  POST;
}

References file, INIT, POST, req, and UV_FS_FCHOWN.

uv_fs_fdatasync()

UV_EXTERN int uv_fs_fdatasync	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		uv_fs_cb	cb
	)

Definition at line 1744 of file fs.c.

                                                                              {
  INIT(FDATASYNC);
  req->file = file;
  POST;
}

References fd, file, INIT, POST, req, and UV_FS_FDATASYNC.

uv_fs_fstat()

UV_EXTERN int uv_fs_fstat	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		uv_fs_cb	cb
	)

Definition at line 1751 of file fs.c.

                                                                          {
  INIT(FSTAT);
  req->file = file;
  POST;
}

References fd, file, INIT, POST, req, and UV_FS_FSTAT.

uv_fs_fsync()

UV_EXTERN int uv_fs_fsync	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		uv_fs_cb	cb
	)

Definition at line 1758 of file fs.c.

                                                                          {
  INIT(FSYNC);
  req->file = file;
  POST;
}

References fd, file, INIT, POST, req, and UV_FS_FSYNC.

uv_fs_ftruncate()

UV_EXTERN int uv_fs_ftruncate	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		int64_t	offset,
		uv_fs_cb	cb
	)

Definition at line 1765 of file fs.c.

                                 {
  INIT(FTRUNCATE);
  req->file = file;
  req->off = off;
  POST;
}

References fd, file, INIT, off, POST, req, and UV_FS_FTRUNCATE.

uv_fs_futime()

UV_EXTERN int uv_fs_futime	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		double	atime,
		double	mtime,
		uv_fs_cb	cb
	)

Definition at line 1777 of file fs.c.

                              {
  INIT(FUTIME);
  req->file = file;
  req->atime = atime;
  req->mtime = mtime;
  POST;
}

References fd, file, INIT, POST, req, and UV_FS_FUTIME.

uv_fs_get_path()

UV_EXTERN const char* uv_fs_get_path

(

const uv_fs_t *

req

)

Definition at line 105 of file uv-data-getter-setters.c.

                                               {
  return req->path;
}

References req.

uv_fs_get_ptr()

UV_EXTERN void* uv_fs_get_ptr

(

const uv_fs_t *

req

)

Definition at line 101 of file uv-data-getter-setters.c.

                                        {
  return req->ptr;
}

References req.

uv_fs_get_result()

UV_EXTERN ssize_t uv_fs_get_result

(

const uv_fs_t *

req

)

Definition at line 97 of file uv-data-getter-setters.c.

                                             {
  return req->result;
}

References req.

uv_fs_get_statbuf()

UV_EXTERN uv_stat_t* uv_fs_get_statbuf

(

uv_fs_t *

req

)

Definition at line 109 of file uv-data-getter-setters.c.

                                           {
  return &req->statbuf;
}

References req.

uv_fs_get_system_error()

UV_EXTERN int uv_fs_get_system_error

(

const uv_fs_t *

req

)

Definition at line 2132 of file fs.c.

                                               {
  return -req->result;
}

References req.

uv_fs_get_type()

UV_EXTERN uv_fs_type uv_fs_get_type

(

const uv_fs_t *

req

)

Definition at line 93 of file uv-data-getter-setters.c.

                                              {
  return req->fs_type;
}

References req.

uv_fs_lchown()

UV_EXTERN int uv_fs_lchown	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_uid_t	uid,
		uv_gid_t	gid,
		uv_fs_cb	cb
	)

Definition at line 1730 of file fs.c.

                              {
  INIT(LCHOWN);
  PATH;
  req->uid = uid;
  req->gid = gid;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_LCHOWN.

uv_fs_link()

UV_EXTERN int uv_fs_link	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		const char *	new_path,
		uv_fs_cb	cb
	)

Definition at line 1811 of file fs.c.

                            {
  INIT(LINK);
  PATH2;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH2, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_LINK.

uv_fs_lstat()

UV_EXTERN int uv_fs_lstat	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 1804 of file fs.c.

                                                                              {
  INIT(LSTAT);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_LSTAT.

uv_fs_lutime()

UV_EXTERN int uv_fs_lutime	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		double	atime,
		double	mtime,
		uv_fs_cb	cb
	)

Definition at line 1790 of file fs.c.

                              {
  INIT(LUTIME);
  PATH;
  req->atime = atime;
  req->mtime = mtime;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_LUTIME.

uv_fs_mkdir()

UV_EXTERN int uv_fs_mkdir	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		int	mode,
		uv_fs_cb	cb
	)

Definition at line 1822 of file fs.c.

                             {
  INIT(MKDIR);
  PATH;
  req->mode = mode;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_MKDIR.

uv_fs_mkdtemp()

UV_EXTERN int uv_fs_mkdtemp	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	tpl,
		uv_fs_cb	cb
	)

Definition at line 1834 of file fs.c.

                               {
  INIT(MKDTEMP);
  req->path = uv__strdup(tpl);
  if (req->path == NULL)
    return UV_ENOMEM;
  POST;
}

References err, fs__capture_path(), INIT, NULL, POST, req, SET_REQ_WIN32_ERROR, TRUE, uv__strdup(), and UV_FS_MKDTEMP.

uv_fs_mkstemp()

UV_EXTERN int uv_fs_mkstemp	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	tpl,
		uv_fs_cb	cb
	)

Definition at line 1846 of file fs.c.

                               {
  INIT(MKSTEMP);
  req->path = uv__strdup(tpl);
  if (req->path == NULL)
    return UV_ENOMEM;
  POST;
}

References err, fs__capture_path(), INIT, NULL, POST, req, SET_REQ_WIN32_ERROR, TRUE, uv__strdup(), and UV_FS_MKSTEMP.

uv_fs_open()

UV_EXTERN int uv_fs_open	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		int	flags,
		int	mode,
		uv_fs_cb	cb
	)

Definition at line 1858 of file fs.c.

                            {
  INIT(OPEN);
  PATH;
  req->flags = flags;
  req->mode = mode;
  POST;
}

References cb, err, flags, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_OPEN.

Referenced by main(), and uv__fs_copyfile().

uv_fs_opendir()

UV_EXTERN int uv_fs_opendir	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 1911 of file fs.c.

                               {
  INIT(OPENDIR);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_OPENDIR.

uv_fs_poll_getpath()

UV_EXTERN int uv_fs_poll_getpath	(	uv_fs_poll_t *	handle,
		char *	buffer,
		size_t *	size
	)

Definition at line 138 of file fs-poll.c.

                                                                         {
  struct poll_ctx* ctx;
  size_t required_len;
 
  if (!uv_is_active((uv_handle_t*)handle)) {
    *size = 0;
    return UV_EINVAL;
  }
 
  ctx = handle->poll_ctx;
  assert(ctx != NULL);
 
  required_len = strlen(ctx->path);
  if (required_len >= *size) {
    *size = required_len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, ctx->path, required_len);
  *size = required_len;
  buffer[required_len] = '\0';
 
  return 0;
}

References assert(), handle, memcpy(), NULL, and uv_is_active().

uv_fs_poll_init()

UV_EXTERN int uv_fs_poll_init	(	uv_loop_t *	loop,
		uv_fs_poll_t *	handle
	)

Definition at line 59 of file fs-poll.c.

                                                           {
  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_POLL);
  handle->poll_ctx = NULL;
  return 0;
}

References handle, loop, NULL, and uv__handle_init.

uv_fs_poll_start()

UV_EXTERN int uv_fs_poll_start	(	uv_fs_poll_t *	handle,
		uv_fs_poll_cb	poll_cb,
		const char *	path,
		unsigned int	interval
	)

Definition at line 66 of file fs-poll.c.

                                            {
  struct poll_ctx* ctx;
  uv_loop_t* loop;
  size_t len;
  int err;
 
  if (uv_is_active((uv_handle_t*)handle))
    return 0;
 
  loop = handle->loop;
  len = strlen(path);
  ctx = uv__calloc(1, sizeof(*ctx) + len);
 
  if (ctx == NULL)
    return UV_ENOMEM;
 
  ctx->loop = loop;
  ctx->poll_cb = cb;
  ctx->interval = interval ? interval : 1;
  ctx->start_time = uv_now(loop);
  ctx->parent_handle = handle;
  memcpy(ctx->path, path, len + 1);
 
  err = uv_timer_init(loop, &ctx->timer_handle);
  if (err < 0)
    goto error;
 
  ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
  uv__handle_unref(&ctx->timer_handle);
 
  err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
  if (err < 0)
    goto error;
 
  if (handle->poll_ctx != NULL)
    ctx->previous = handle->poll_ctx;
  handle->poll_ctx = ctx;
  uv__handle_start(handle);
 
  return 0;
 
error:
  uv__free(ctx);
  return err;
}

References cb, err, error(), handle, poll_ctx::interval, len, loop, memcpy(), NULL, path, poll_cb(), uv__calloc(), uv__free(), uv__handle_start, uv__handle_unref, uv_fs_stat(), UV_HANDLE_INTERNAL, uv_is_active(), uv_now(), and uv_timer_init().

uv_fs_poll_stop()

UV_EXTERN int uv_fs_poll_stop

(

uv_fs_poll_t *

handle

)

Definition at line 116 of file fs-poll.c.

                                          {
  struct poll_ctx* ctx;
 
  if (!uv_is_active((uv_handle_t*)handle))
    return 0;
 
  ctx = handle->poll_ctx;
  assert(ctx != NULL);
  assert(ctx->parent_handle == handle);
 
  /* Close the timer if it's active. If it's inactive, there's a stat request
   * in progress and poll_cb will take care of the cleanup.
   */
  if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
 
  uv__handle_stop(handle);
 
  return 0;
}

References assert(), handle, NULL, timer_close_cb(), uv__handle_stop, uv_close(), and uv_is_active().

Referenced by uv__fs_poll_close().

uv_fs_read()

UV_EXTERN int uv_fs_read	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		int64_t	offset,
		uv_fs_cb	cb
	)

Definition at line 1872 of file fs.c.

                            {
  INIT(READ);
 
  if (bufs == NULL || nbufs == 0)
    return UV_EINVAL;
 
  req->file = file;
 
  req->nbufs = nbufs;
  req->bufs = req->bufsml;
  if (nbufs > ARRAY_SIZE(req->bufsml))
    req->bufs = uv__malloc(nbufs * sizeof(*bufs));
 
  if (req->bufs == NULL)
    return UV_ENOMEM;
 
  memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
 
  req->off = off;
  POST;
}

References ARRAY_SIZE, bufs, fd, file, INIT, memcpy(), NULL, off, POST, READ, req, SET_REQ_UV_ERROR, uv__malloc(), and UV_FS_READ.

Referenced by main(), on_open(), on_type(), and on_write().

uv_fs_readdir()

UV_EXTERN int uv_fs_readdir	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_dir_t *	dir,
		uv_fs_cb	cb
	)

Definition at line 1920 of file fs.c.

                               {
  INIT(READDIR);
 
  if (dir == NULL || dir->dir == NULL || dir->dirents == NULL)
    return UV_EINVAL;
 
  req->ptr = dir;
  POST;
}

References uv_dir_s::dirents, INIT, INVALID_HANDLE_VALUE, NULL, POST, req, SET_REQ_UV_ERROR, and UV_FS_READDIR.

uv_fs_readlink()

UV_EXTERN int uv_fs_readlink	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 1946 of file fs.c.

                                {
  INIT(READLINK);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_READLINK.

uv_fs_realpath()

UV_EXTERN int uv_fs_realpath	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 1956 of file fs.c.

                               {
  INIT(REALPATH);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_UV_ERROR, SET_REQ_WIN32_ERROR, and UV_FS_REALPATH.

uv_fs_rename()

UV_EXTERN int uv_fs_rename	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		const char *	new_path,
		uv_fs_cb	cb
	)

Definition at line 1966 of file fs.c.

                              {
  INIT(RENAME);
  PATH2;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH2, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_RENAME.

uv_fs_req_cleanup()

UV_EXTERN void uv_fs_req_cleanup

(

uv_fs_t *

req

)

Definition at line 2070 of file fs.c.

                                     {
  if (req == NULL)
    return;
 
  /* Only necessary for asychronous requests, i.e., requests with a callback.
   * Synchronous ones don't copy their arguments and have req->path and
   * req->new_path pointing to user-owned memory.  UV_FS_MKDTEMP and
   * UV_FS_MKSTEMP are the exception to the rule, they always allocate memory.
   */
  if (req->path != NULL &&
      (req->cb != NULL ||
        req->fs_type == UV_FS_MKDTEMP || req->fs_type == UV_FS_MKSTEMP))
    uv__free((void*) req->path);  /* Memory is shared with req->new_path. */
 
  req->path = NULL;
  req->new_path = NULL;
 
  if (req->fs_type == UV_FS_READDIR && req->ptr != NULL)
    uv__fs_readdir_cleanup(req);
 
  if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
    uv__fs_scandir_cleanup(req);
 
  if (req->bufs != req->bufsml)
    uv__free(req->bufs);
  req->bufs = NULL;
 
  if (req->fs_type != UV_FS_OPENDIR && req->ptr != &req->statbuf)
    uv__free(req->ptr);
  req->ptr = NULL;
}

References NULL, req, uv__free(), uv__fs_readdir_cleanup(), uv__fs_scandir_cleanup(), UV_FS_CLEANEDUP, UV_FS_FREE_PATHS, UV_FS_FREE_PTR, UV_FS_MKDTEMP, UV_FS_MKSTEMP, UV_FS_OPENDIR, UV_FS_READDIR, and UV_FS_SCANDIR.

Referenced by main(), poll_cb(), and uv__fs_copyfile().

uv_fs_rmdir()

UV_EXTERN int uv_fs_rmdir	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 1977 of file fs.c.

                                                                              {
  INIT(RMDIR);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_RMDIR.

uv_fs_scandir()

UV_EXTERN int uv_fs_scandir	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		int	flags,
		uv_fs_cb	cb
	)

Definition at line 1900 of file fs.c.

                               {
  INIT(SCANDIR);
  PATH;
  req->flags = flags;
  POST;
}

References cb, err, flags, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_SCANDIR.

uv_fs_scandir_next()

UV_EXTERN int uv_fs_scandir_next	(	uv_fs_t *	req,
		uv_dirent_t *	ent
	)

Definition at line 651 of file uv-common.c.

                                                       {
  uv__dirent_t** dents;
  uv__dirent_t* dent;
  unsigned int* nbufs;
 
  /* Check to see if req passed */
  if (req->result < 0)
    return req->result;
 
  /* Ptr will be null if req was canceled or no files found */
  if (!req->ptr)
    return UV_EOF;
 
  nbufs = uv__get_nbufs(req);
  assert(nbufs);
 
  dents = req->ptr;
 
  /* Free previous entity */
  if (*nbufs > 0)
    uv__fs_scandir_free(dents[*nbufs - 1]);
 
  /* End was already reached */
  if (*nbufs == (unsigned int) req->result) {
    uv__fs_scandir_free(dents);
    req->ptr = NULL;
    return UV_EOF;
  }
 
  dent = dents[(*nbufs)++];
 
  ent->name = dent->d_name;
  ent->type = uv__fs_get_dirent_type(dent);
 
  return 0;
}

References assert(), dirent::d_name, uv_dirent_s::name, NULL, req, uv_dirent_s::type, uv__fs_get_dirent_type(), uv__fs_scandir_free, and uv__get_nbufs().

uv_fs_sendfile()

UV_EXTERN int uv_fs_sendfile	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	out_fd,
		uv_file	in_fd,
		int64_t	in_offset,
		size_t	length,
		uv_fs_cb	cb
	)

Definition at line 1984 of file fs.c.

                                {
  INIT(SENDFILE);
  req->flags = in_fd; /* hack */
  req->file = out_fd;
  req->off = off;
  req->bufsml[0].len = len;
  POST;
}

References INIT, len, length, off, POST, req, and UV_FS_SENDFILE.

Referenced by uv__fs_copyfile().

uv_fs_stat()

UV_EXTERN int uv_fs_stat	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 2000 of file fs.c.

                                                                             {
  INIT(STAT);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_STAT.

Referenced by timer_cb(), and uv_fs_poll_start().

uv_fs_statfs()

UV_EXTERN int uv_fs_statfs	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 2123 of file fs.c.

                              {
  INIT(STATFS);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_STATFS.

uv_fs_symlink()

UV_EXTERN int uv_fs_symlink	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		const char *	new_path,
		int	flags,
		uv_fs_cb	cb
	)

Definition at line 2007 of file fs.c.

                               {
  INIT(SYMLINK);
  PATH2;
  req->flags = flags;
  POST;
}

References cb, err, flags, fs__capture_path(), INIT, NULL, path, PATH2, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_SYMLINK.

uv_fs_unlink()

UV_EXTERN int uv_fs_unlink	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		uv_fs_cb	cb
	)

Definition at line 2020 of file fs.c.

                                                                               {
  INIT(UNLINK);
  PATH;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_UNLINK.

Referenced by remove_sock(), and uv__fs_copyfile().

uv_fs_utime()

UV_EXTERN int uv_fs_utime	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		const char *	path,
		double	atime,
		double	mtime,
		uv_fs_cb	cb
	)

Definition at line 2027 of file fs.c.

                             {
  INIT(UTIME);
  PATH;
  req->atime = atime;
  req->mtime = mtime;
  POST;
}

References cb, err, fs__capture_path(), INIT, NULL, path, PATH, POST, req, SET_REQ_WIN32_ERROR, and UV_FS_UTIME.

uv_fs_write()

UV_EXTERN int uv_fs_write	(	uv_loop_t *	loop,
		uv_fs_t *	req,
		uv_file	file,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		int64_t	offset,
		uv_fs_cb	cb
	)

Definition at line 2041 of file fs.c.

                             {
  INIT(WRITE);
 
  if (bufs == NULL || nbufs == 0)
    return UV_EINVAL;
 
  req->file = file;
 
  req->nbufs = nbufs;
  req->bufs = req->bufsml;
  if (nbufs > ARRAY_SIZE(req->bufsml))
    req->bufs = uv__malloc(nbufs * sizeof(*bufs));
 
  if (req->bufs == NULL)
    return UV_ENOMEM;
 
  memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));
 
  req->off = off;
  POST;
}

References ARRAY_SIZE, bufs, fd, file, INIT, memcpy(), NULL, off, POST, req, SET_REQ_UV_ERROR, uv__malloc(), and UV_FS_WRITE.

Referenced by on_read().

uv_get_constrained_memory()

UV_EXTERN uint64_t uv_get_constrained_memory

(

void

)

Definition at line 387 of file aix.c.

                                         {
  return 0;  /* Memory constraints are unknown. */
}

References uv__read_cgroups_uint64().

uv_get_free_memory()

UV_EXTERN uint64_t uv_get_free_memory

(

void

)

Definition at line 367 of file aix.c.

                                  {
  perfstat_memory_total_t mem_total;
  int result = perfstat_memory_total(NULL, &mem_total, sizeof(mem_total), 1);
  if (result == -1) {
    return 0;
  }
  return mem_total.real_free * 4096;
}

References ARRAY_SIZE, data_area_ptr::assign, count, CVT_PTR, CVTRCEP_OFFSET, data_area_ptr::deref, get_ibmi_system_status(), get_mem_info(), info(), SSTS0200::main_storage_size, NULL, RCEAFC_OFFSET, status, sysinfo, UV__ERR, uv__read_proc_meminfo(), and which.

uv_get_osfhandle()

UV_EXTERN uv_os_fd_t uv_get_osfhandle

(

int

fd

)

Definition at line 1389 of file core.c.

                                    {
  return fd;
}

References fd, and uv__get_osfhandle().

uv_get_process_title()

UV_EXTERN int uv_get_process_title	(	char *	buffer,
		size_t	size
	)

Definition at line 960 of file aix.c.

                                                    {
  size_t len;
  if (buffer == NULL || size == 0)
    return UV_EINVAL;
 
  /* If uv_setup_args wasn't called, we can't continue. */
  if (process_argv == NULL)
    return UV_ENOBUFS;
 
  uv_once(&process_title_mutex_once, init_process_title_mutex_once);
  uv_mutex_lock(&process_title_mutex);
 
  len = strlen(process_argv[0]);
  if (size <= len) {
    uv_mutex_unlock(&process_title_mutex);
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, process_argv[0], len);
  buffer[len] = '\0';
 
  uv_mutex_unlock(&process_title_mutex);
 
  return 0;
}

References args_mem, assert(), init_process_title_mutex_once(), len, uv__process_title::len, memcpy(), NULL, process_argv, process_title, process_title_lock, process_title_mutex, process_title_mutex_once, uv__process_title::str, uv__get_process_title(), uv__once_init(), uv_mutex_lock(), uv_mutex_unlock(), uv_once(), and uv_translate_sys_error().

uv_get_total_memory()

UV_EXTERN uint64_t uv_get_total_memory

(

void

)

Definition at line 377 of file aix.c.

                                   {
  perfstat_memory_total_t mem_total;
  int result = perfstat_memory_total(NULL, &mem_total, sizeof(mem_total), 1);
  if (result == -1) {
    return 0;
  }
  return mem_total.real_total * 4096;
}

References ARRAY_SIZE, data_area_ptr::assign, CVT_PTR, CVTRCEP_OFFSET, data_area_ptr::deref, get_ibmi_system_status(), get_mem_info(), info(), SSTS0200::main_storage_size, NULL, RCEPOOL_OFFSET, status, sysinfo, UV__ERR, uv__read_proc_meminfo(), and which.

uv_getaddrinfo()

UV_EXTERN int uv_getaddrinfo	(	uv_loop_t *	loop,
		uv_getaddrinfo_t *	req,
		uv_getaddrinfo_cb	getaddrinfo_cb,
		const char *	node,
		const char *	service,
		const struct addrinfo *	hints
	)

Definition at line 141 of file getaddrinfo.c.

                                                 {
  char hostname_ascii[256];
  size_t hostname_len;
  size_t service_len;
  size_t hints_len;
  size_t len;
  char* buf;
  long rc;
 
  if (req == NULL || (hostname == NULL && service == NULL))
    return UV_EINVAL;
 
  /* FIXME(bnoordhuis) IDNA does not seem to work z/OS,
   * probably because it uses EBCDIC rather than ASCII.
   */
#ifdef __MVS__
  (void) &hostname_ascii;
#else
  if (hostname != NULL) {
    rc = uv__idna_toascii(hostname,
                          hostname + strlen(hostname),
                          hostname_ascii,
                          hostname_ascii + sizeof(hostname_ascii));
    if (rc < 0)
      return rc;
    hostname = hostname_ascii;
  }
#endif
 
  hostname_len = hostname ? strlen(hostname) + 1 : 0;
  service_len = service ? strlen(service) + 1 : 0;
  hints_len = hints ? sizeof(*hints) : 0;
  buf = uv__malloc(hostname_len + service_len + hints_len);
 
  if (buf == NULL)
    return UV_ENOMEM;
 
  uv__req_init(loop, req, UV_GETADDRINFO);
  req->loop = loop;
  req->cb = cb;
  req->addrinfo = NULL;
  req->hints = NULL;
  req->service = NULL;
  req->hostname = NULL;
  req->retcode = 0;
 
  /* order matters, see uv_getaddrinfo_done() */
  len = 0;
 
  if (hints) {
    req->hints = memcpy(buf + len, hints, sizeof(*hints));
    len += sizeof(*hints);
  }
 
  if (service) {
    req->service = memcpy(buf + len, service, service_len);
    len += service_len;
  }
 
  if (hostname)
    req->hostname = memcpy(buf + len, hostname, hostname_len);
 
  if (cb) {
    uv__work_submit(loop,
                    &req->work_req,
                    UV__WORK_SLOW_IO,
                    uv__getaddrinfo_work,
                    uv__getaddrinfo_done);
    return 0;
  } else {
    uv__getaddrinfo_work(&req->work_req);
    uv__getaddrinfo_done(&req->work_req, 0);
    return req->retcode;
  }
}

References ALIGNED_SIZE, cb, err, error(), len, loop, memcpy(), NULL, req, uv__free(), uv__getaddrinfo_done(), uv__getaddrinfo_work(), uv__idna_toascii(), uv__malloc(), uv__req_init, uv__req_register, UV__WORK_SLOW_IO, uv__work_submit(), UV_REQ_INIT, and uv_translate_sys_error().

Referenced by main().

uv_getnameinfo()

UV_EXTERN int uv_getnameinfo	(	uv_loop_t *	loop,
		uv_getnameinfo_t *	req,
		uv_getnameinfo_cb	getnameinfo_cb,
		const struct sockaddr *	addr,
		int	flags
	)

Definition at line 81 of file getnameinfo.c.

                              {
  if (req == NULL || addr == NULL)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET) {
    memcpy(&req->storage,
           addr,
           sizeof(struct sockaddr_in));
  } else if (addr->sa_family == AF_INET6) {
    memcpy(&req->storage,
           addr,
           sizeof(struct sockaddr_in6));
  } else {
    return UV_EINVAL;
  }
 
  uv__req_init(loop, (uv_req_t*)req, UV_GETNAMEINFO);
 
  req->getnameinfo_cb = getnameinfo_cb;
  req->flags = flags;
  req->type = UV_GETNAMEINFO;
  req->loop = loop;
  req->retcode = 0;
 
  if (getnameinfo_cb) {
    uv__work_submit(loop,
                    &req->work_req,
                    UV__WORK_SLOW_IO,
                    uv__getnameinfo_work,
                    uv__getnameinfo_done);
    return 0;
  } else {
    uv__getnameinfo_work(&req->work_req);
    uv__getnameinfo_done(&req->work_req, 0);
    return req->retcode;
  }
}

References addr, AF_INET, AF_INET6, flags, loop, memcpy(), NULL, req, uv__getnameinfo_done(), uv__getnameinfo_work(), uv__req_init, uv__req_register, UV__WORK_SLOW_IO, uv__work_submit(), and UV_REQ_INIT.

uv_getrusage()

UV_EXTERN int uv_getrusage

(

uv_rusage_t *

rusage

)

Definition at line 970 of file core.c.

                                      {
  struct rusage usage;
 
  if (getrusage(RUSAGE_SELF, &usage))
    return UV__ERR(errno);
 
  rusage->ru_utime.tv_sec = usage.ru_utime.tv_sec;
  rusage->ru_utime.tv_usec = usage.ru_utime.tv_usec;
 
  rusage->ru_stime.tv_sec = usage.ru_stime.tv_sec;
  rusage->ru_stime.tv_usec = usage.ru_stime.tv_usec;
 
#if !defined(__MVS__) && !defined(__HAIKU__)
  rusage->ru_maxrss = usage.ru_maxrss;
  rusage->ru_ixrss = usage.ru_ixrss;
  rusage->ru_idrss = usage.ru_idrss;
  rusage->ru_isrss = usage.ru_isrss;
  rusage->ru_minflt = usage.ru_minflt;
  rusage->ru_majflt = usage.ru_majflt;
  rusage->ru_nswap = usage.ru_nswap;
  rusage->ru_inblock = usage.ru_inblock;
  rusage->ru_oublock = usage.ru_oublock;
  rusage->ru_msgsnd = usage.ru_msgsnd;
  rusage->ru_msgrcv = usage.ru_msgrcv;
  rusage->ru_nsignals = usage.ru_nsignals;
  rusage->ru_nvcsw = usage.ru_nvcsw;
  rusage->ru_nivcsw = usage.ru_nivcsw;
#endif
 
  return 0;
}

References memset(), rusage::ru_idrss, rusage::ru_inblock, uv_rusage_t::ru_inblock, rusage::ru_isrss, rusage::ru_ixrss, rusage::ru_majflt, uv_rusage_t::ru_majflt, rusage::ru_maxrss, uv_rusage_t::ru_maxrss, rusage::ru_minflt, rusage::ru_msgrcv, rusage::ru_msgsnd, rusage::ru_nivcsw, rusage::ru_nsignals, rusage::ru_nswap, rusage::ru_nvcsw, rusage::ru_oublock, uv_rusage_t::ru_oublock, rusage::ru_stime, uv_rusage_t::ru_stime, rusage::ru_utime, uv_rusage_t::ru_utime, timeval::tv_sec, uv_timeval_t::tv_sec, timeval::tv_usec, uv_timeval_t::tv_usec, usage(), UV__ERR, and uv_translate_sys_error().

uv_gettimeofday()

UV_EXTERN int uv_gettimeofday

(

uv_timeval64_t *

tv

)

Definition at line 1512 of file core.c.

                                        {
  struct timeval time;
 
  if (tv == NULL)
    return UV_EINVAL;
 
  if (gettimeofday(&time, NULL) != 0)
    return UV__ERR(errno);
 
  tv->tv_sec = (int64_t) time.tv_sec;
  tv->tv_usec = (int32_t) time.tv_usec;
  return 0;
}

References gettimeofday, NULL, time, tv, and UV__ERR.

uv_guess_handle()

UV_EXTERN uv_handle_type uv_guess_handle

(

uv_file

file

)

Definition at line 315 of file tty.c.

                                             {
  struct sockaddr sa;
  struct stat s;
  socklen_t len;
  int type;
 
  if (file < 0)
    return UV_UNKNOWN_HANDLE;
 
  if (isatty(file))
    return UV_TTY;
 
  if (fstat(file, &s))
    return UV_UNKNOWN_HANDLE;
 
  if (S_ISREG(s.st_mode))
    return UV_FILE;
 
  if (S_ISCHR(s.st_mode))
    return UV_FILE;  /* XXX UV_NAMED_PIPE? */
 
  if (S_ISFIFO(s.st_mode))
    return UV_NAMED_PIPE;
 
  if (!S_ISSOCK(s.st_mode))
    return UV_UNKNOWN_HANDLE;
 
  len = sizeof(type);
  if (getsockopt(file, SOL_SOCKET, SO_TYPE, &type, &len))
    return UV_UNKNOWN_HANDLE;
 
  len = sizeof(sa);
  if (getsockname(file, &sa, &len))
    return UV_UNKNOWN_HANDLE;
 
  if (type == SOCK_DGRAM)
    if (sa.sa_family == AF_INET || sa.sa_family == AF_INET6)
      return UV_UDP;
 
  if (type == SOCK_STREAM) {
#if defined(_AIX) || defined(__DragonFly__)
    /* on AIX/DragonFly the getsockname call returns an empty sa structure
     * for sockets of type AF_UNIX.  For all other types it will
     * return a properly filled in structure.
     */
    if (len == 0)
      return UV_NAMED_PIPE;
#endif /* defined(_AIX) || defined(__DragonFly__) */
 
    if (sa.sa_family == AF_INET || sa.sa_family == AF_INET6)
      return UV_TCP;
    if (sa.sa_family == AF_UNIX)
      return UV_NAMED_PIPE;
  }
 
  return UV_UNKNOWN_HANDLE;
}

References AF_INET, AF_INET6, AF_UNIX, DWORD, fstat, handle, HANDLE, len, s, S_ISREG, SO_TYPE, SOCK_DGRAM, SOCK_STREAM, SOL_SOCKET, type, uv__get_osfhandle(), UV_FILE, and UV_UNKNOWN_HANDLE.

Referenced by main(), and uv_tty_init().

uv_handle_get_data()

UV_EXTERN void* uv_handle_get_data

(

const uv_handle_t *

handle

)

Definition at line 40 of file uv-data-getter-setters.c.

                                                    {
  return handle->data;
}

References handle.

uv_handle_get_loop()

UV_EXTERN uv_loop_t* uv_handle_get_loop

(

const uv_handle_t *

handle

)

Definition at line 44 of file uv-data-getter-setters.c.

                                                         {
  return handle->loop;
}

References handle.

uv_handle_get_type()

UV_EXTERN uv_handle_type uv_handle_get_type

(

const uv_handle_t *

handle

)

Definition at line 36 of file uv-data-getter-setters.c.

                                                             {
  return handle->type;
}

References handle.

uv_handle_set_data()

UV_EXTERN void uv_handle_set_data	(	uv_handle_t *	handle,
		void *	data
	)

Definition at line 48 of file uv-data-getter-setters.c.

                                                         {
  handle->data = data;
}

References handle.

uv_handle_size()

UV_EXTERN size_t uv_handle_size

(

uv_handle_type

type

)

Definition at line 133 of file uv-common.c.

                                           {
  switch (type) {
    UV_HANDLE_TYPE_MAP(XX)
    default:
      return -1;
  }
}

References type, UV_HANDLE_TYPE_MAP, and XX.

uv_handle_type_name()

UV_EXTERN const char* uv_handle_type_name

(

uv_handle_type

type

)

Definition at line 24 of file uv-data-getter-setters.c.

                                                     {
  switch (type) {
#define XX(uc,lc) case UV_##uc: return #lc;
  UV_HANDLE_TYPE_MAP(XX)
#undef XX
  case UV_FILE: return "file";
  case UV_HANDLE_TYPE_MAX:
  case UV_UNKNOWN_HANDLE: return NULL;
  }
  return NULL;
}

References NULL, type, UV_FILE, UV_HANDLE_TYPE_MAP, UV_HANDLE_TYPE_MAX, UV_UNKNOWN_HANDLE, and XX.

uv_has_ref()

UV_EXTERN int uv_has_ref

(

const uv_handle_t *

handle

)

Definition at line 557 of file uv-common.c.

                                          {
  return uv__has_ref(handle);
}

References handle, and uv__has_ref.

uv_hrtime()

UV_EXTERN uint64_t uv_hrtime

(

void

)

Definition at line 103 of file core.c.

                         {
  return uv__hrtime(UV_CLOCK_PRECISE);
}

References uv__hrtime(), UV__NANOSEC, uv__once_init(), and UV_CLOCK_PRECISE.

Referenced by uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), and uv_metrics_idle_time().

uv_idle_init()

UV_EXTERN int uv_idle_init	(	uv_loop_t *	,
		uv_idle_t *	idle
	)

Referenced by main().

uv_idle_start()

UV_EXTERN int uv_idle_start	(	uv_idle_t *	idle,
		uv_idle_cb	cb
	)

Referenced by main(), and on_type().

uv_idle_stop()

UV_EXTERN int uv_idle_stop

(

uv_idle_t *

idle

)

Referenced by crunch_away(), uv_close(), and wait_for_a_while().

uv_if_indextoiid()

UV_EXTERN int uv_if_indextoiid	(	unsigned int	ifindex,
		char *	buffer,
		size_t *	size
	)

Definition at line 253 of file getaddrinfo.c.

                                                                       {
  return uv_if_indextoname(ifindex, buffer, size);
}

References NULL, r, snprintf, uv_if_indextoname(), and uv_translate_sys_error().

uv_if_indextoname()

UV_EXTERN int uv_if_indextoname	(	unsigned int	ifindex,
		char *	buffer,
		size_t *	size
	)

Definition at line 229 of file getaddrinfo.c.

                                                                        {
  char ifname_buf[UV_IF_NAMESIZE];
  size_t len;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  if (if_indextoname(ifindex, ifname_buf) == NULL)
    return UV__ERR(errno);
 
  len = strnlen(ifname_buf, sizeof(ifname_buf));
 
  if (*size <= len) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, ifname_buf, len);
  buffer[len] = '\0';
  *size = len;
 
  return 0;
}

References ARRAY_SIZE, DWORD, len, memcpy(), NDIS_IF_MAX_STRING_SIZE, NULL, r, strnlen(), UV__ERR, UV_IF_NAMESIZE, and uv_translate_sys_error().

Referenced by uv_if_indextoiid().

uv_inet_ntop()

UV_EXTERN int uv_inet_ntop	(	int	af,
		const void *	src,
		char *	dst,
		size_t	size
	)

Definition at line 40 of file inet.c.

                                                                  {
  switch (af) {
  case AF_INET:
    return (inet_ntop4(src, dst, size));
  case AF_INET6:
    return (inet_ntop6(src, dst, size));
  default:
    return UV_EAFNOSUPPORT;
  }
  /* NOTREACHED */
}

References AF_INET, AF_INET6, dst, inet_ntop4(), inet_ntop6(), and src.

Referenced by uv_ip4_name(), and uv_ip6_name().

uv_inet_pton()

UV_EXTERN int uv_inet_pton	(	int	af,
		const char *	src,
		void *	dst
	)

Definition at line 150 of file inet.c.

                                                     {
  if (src == NULL || dst == NULL)
    return UV_EINVAL;
 
  switch (af) {
  case AF_INET:
    return (inet_pton4(src, dst));
  case AF_INET6: {
    int len;
    char tmp[UV__INET6_ADDRSTRLEN], *s, *p;
    s = (char*) src;
    p = strchr(src, '%');
    if (p != NULL) {
      s = tmp;
      len = p - src;
      if (len > UV__INET6_ADDRSTRLEN-1)
        return UV_EINVAL;
      memcpy(s, src, len);
      s[len] = '\0';
    }
    return inet_pton6(s, dst);
  }
  default:
    return UV_EAFNOSUPPORT;
  }
  /* NOTREACHED */
}

References AF_INET, AF_INET6, dst, inet_pton4(), inet_pton6(), len, memcpy(), NULL, p, s, src, autogen_x86imm::tmp, and UV__INET6_ADDRSTRLEN.

Referenced by uv__udp_set_membership4(), uv__udp_set_source_membership4(), uv_ip4_addr(), and uv_ip6_addr().

uv_interface_addresses()

UV_EXTERN int uv_interface_addresses	(	uv_interface_address_t **	addresses,
		int *	count
	)

Definition at line 1100 of file aix.c.

                                                                           {
  uv_interface_address_t* address;
  int sockfd, sock6fd, inet6, i, r, size = 1;
  struct ifconf ifc;
  struct ifreq *ifr, *p, flg;
  struct in6_ifreq if6;
  struct sockaddr_dl* sa_addr;
 
  ifc.ifc_req = NULL;
  sock6fd = -1;
  r = 0;
  *count = 0;
  *addresses = NULL;
 
  if (0 > (sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP))) {
    r = UV__ERR(errno);
    goto cleanup;
  }
 
  if (0 > (sock6fd = socket(AF_INET6, SOCK_DGRAM, IPPROTO_IP))) {
    r = UV__ERR(errno);
    goto cleanup;
  }
 
  if (ioctl(sockfd, SIOCGSIZIFCONF, &size) == -1) {
    r = UV__ERR(errno);
    goto cleanup;
  }
 
  ifc.ifc_req = (struct ifreq*)uv__malloc(size);
  if (ifc.ifc_req == NULL) {
    r = UV_ENOMEM;
    goto cleanup;
  }
  ifc.ifc_len = size;
  if (ioctl(sockfd, SIOCGIFCONF, &ifc) == -1) {
    r = UV__ERR(errno);
    goto cleanup;
  }
 
#define ADDR_SIZE(p) MAX((p).sa_len, sizeof(p))
 
  /* Count all up and running ipv4/ipv6 addresses */
  ifr = ifc.ifc_req;
  while ((char*)ifr < (char*)ifc.ifc_req + ifc.ifc_len) {
    p = ifr;
    ifr = (struct ifreq*)
      ((char*)ifr + sizeof(ifr->ifr_name) + ADDR_SIZE(ifr->ifr_addr));
 
    if (!(p->ifr_addr.sa_family == AF_INET6 ||
          p->ifr_addr.sa_family == AF_INET))
      continue;
 
    memcpy(flg.ifr_name, p->ifr_name, sizeof(flg.ifr_name));
    if (ioctl(sockfd, SIOCGIFFLAGS, &flg) == -1) {
      r = UV__ERR(errno);
      goto cleanup;
    }
 
    if (!(flg.ifr_flags & IFF_UP && flg.ifr_flags & IFF_RUNNING))
      continue;
 
    (*count)++;
  }
 
  if (*count == 0)
    goto cleanup;
 
  /* Alloc the return interface structs */
  *addresses = uv__calloc(*count, sizeof(**addresses));
  if (!(*addresses)) {
    r = UV_ENOMEM;
    goto cleanup;
  }
  address = *addresses;
 
  ifr = ifc.ifc_req;
  while ((char*)ifr < (char*)ifc.ifc_req + ifc.ifc_len) {
    p = ifr;
    ifr = (struct ifreq*)
      ((char*)ifr + sizeof(ifr->ifr_name) + ADDR_SIZE(ifr->ifr_addr));
 
    if (!(p->ifr_addr.sa_family == AF_INET6 ||
          p->ifr_addr.sa_family == AF_INET))
      continue;
 
    inet6 = (p->ifr_addr.sa_family == AF_INET6);
 
    memcpy(flg.ifr_name, p->ifr_name, sizeof(flg.ifr_name));
    if (ioctl(sockfd, SIOCGIFFLAGS, &flg) == -1)
      goto syserror;
 
    if (!(flg.ifr_flags & IFF_UP && flg.ifr_flags & IFF_RUNNING))
      continue;
 
    /* All conditions above must match count loop */
 
    address->name = uv__strdup(p->ifr_name);
 
    if (inet6)
      address->address.address6 = *((struct sockaddr_in6*) &p->ifr_addr);
    else
      address->address.address4 = *((struct sockaddr_in*) &p->ifr_addr);
 
    if (inet6) {
      memset(&if6, 0, sizeof(if6));
      r = uv__strscpy(if6.ifr_name, p->ifr_name, sizeof(if6.ifr_name));
      if (r == UV_E2BIG)
        goto cleanup;
      r = 0;
      memcpy(&if6.ifr_Addr, &p->ifr_addr, sizeof(if6.ifr_Addr));
      if (ioctl(sock6fd, SIOCGIFNETMASK6, &if6) == -1)
        goto syserror;
      address->netmask.netmask6 = *((struct sockaddr_in6*) &if6.ifr_Addr);
      /* Explicitly set family as the ioctl call appears to return it as 0. */
      address->netmask.netmask6.sin6_family = AF_INET6;
    } else {
      if (ioctl(sockfd, SIOCGIFNETMASK, p) == -1)
        goto syserror;
      address->netmask.netmask4 = *((struct sockaddr_in*) &p->ifr_addr);
      /* Explicitly set family as the ioctl call appears to return it as 0. */
      address->netmask.netmask4.sin_family = AF_INET;
    }
 
    address->is_internal = flg.ifr_flags & IFF_LOOPBACK ? 1 : 0;
 
    address++;
  }
 
  /* Fill in physical addresses. */
  ifr = ifc.ifc_req;
  while ((char*)ifr < (char*)ifc.ifc_req + ifc.ifc_len) {
    p = ifr;
    ifr = (struct ifreq*)
      ((char*)ifr + sizeof(ifr->ifr_name) + ADDR_SIZE(ifr->ifr_addr));
 
    if (p->ifr_addr.sa_family != AF_LINK)
      continue;
 
    address = *addresses;
    for (i = 0; i < *count; i++) {
      if (strcmp(address->name, p->ifr_name) == 0) {
        sa_addr = (struct sockaddr_dl*) &p->ifr_addr;
        memcpy(address->phys_addr, LLADDR(sa_addr), sizeof(address->phys_addr));
      }
      address++;
    }
  }
 
#undef ADDR_SIZE
  goto cleanup;
 
syserror:
  uv_free_interface_addresses(*addresses, *count);
  *addresses = NULL;
  *count = 0;
  r = UV_ENOSYS;
 
cleanup:
  if (sockfd != -1)
    uv__close(sockfd);
  if (sock6fd != -1)
    uv__close(sock6fd);
  uv__free(ifc.ifc_req);
  return r;
}

References ADDR_SIZE, uv_interface_address_s::address, uv_interface_address_s::address4, uv_interface_address_s::address6, address_prefix_match(), AF_INET, AF_INET6, AF_UNSPEC, assert(), cleanup(), count, FALSE, flags, freeifaddrs(), get_ibmi_physical_address(), getifaddrs(), i, ifaddrs::ifa_addr, ifaddrs::ifa_flags, ifaddrs::ifa_name, ifaddrs::ifa_netmask, ifaddrs::ifa_next, INT_MAX, ioctl, uv_interface_address_s::is_internal, is_windows_version_or_greater(), memcpy(), memset(), uv_interface_address_s::name, uv_interface_address_s::netmask, uv_interface_address_s::netmask4, uv_interface_address_s::netmask6, NULL, p, uv_interface_address_s::phys_addr, prefix, r, in_addr::s_addr, sockaddr_in6::sin6_addr, sockaddr_in::sin_addr, SOCK_DGRAM, socket, sockfd, ULONG, uv__calloc(), uv__close(), UV__ERR, UV__EXCLUDE_IFADDR, UV__EXCLUDE_IFPHYS, uv__free(), uv__ifaddr_exclude(), uv__interface_addresses_v6(), uv__malloc(), uv__set_phys_addr(), uv__strdup(), uv__strscpy(), uv_free_interface_addresses(), and uv_translate_sys_error().

Referenced by main().

uv_ip4_addr()

UV_EXTERN int uv_ip4_addr	(	const char *	ip,
		int	port,
		struct sockaddr_in *	addr
	)

Definition at line 221 of file uv-common.c.

                                                                    {
  memset(addr, 0, sizeof(*addr));
  addr->sin_family = AF_INET;
  addr->sin_port = htons(port);
#ifdef SIN6_LEN
  addr->sin_len = sizeof(*addr);
#endif
  return uv_inet_pton(AF_INET, ip, &(addr->sin_addr.s_addr));
}

References addr, AF_INET, htons, ip, memset(), and uv_inet_pton().

Referenced by main(), uv_udp_set_membership(), uv_udp_set_multicast_interface(), uv_udp_set_source_membership(), and uv_winsock_init().

uv_ip4_name()

UV_EXTERN int uv_ip4_name	(	const struct sockaddr_in *	src,
		char *	dst,
		size_t	size
	)

Definition at line 267 of file uv-common.c.

                                                                       {
  return uv_inet_ntop(AF_INET, &src->sin_addr, dst, size);
}

References AF_INET, dst, src, and uv_inet_ntop().

Referenced by main(), on_read(), and on_resolved().

uv_ip6_addr()

UV_EXTERN int uv_ip6_addr	(	const char *	ip,
		int	port,
		struct sockaddr_in6 *	addr
	)

Definition at line 232 of file uv-common.c.

                                                                     {
  char address_part[40];
  size_t address_part_size;
  const char* zone_index;
 
  memset(addr, 0, sizeof(*addr));
  addr->sin6_family = AF_INET6;
  addr->sin6_port = htons(port);
#ifdef SIN6_LEN
  addr->sin6_len = sizeof(*addr);
#endif
 
  zone_index = strchr(ip, '%');
  if (zone_index != NULL) {
    address_part_size = zone_index - ip;
    if (address_part_size >= sizeof(address_part))
      address_part_size = sizeof(address_part) - 1;
 
    memcpy(address_part, ip, address_part_size);
    address_part[address_part_size] = '\0';
    ip = address_part;
 
    zone_index++; /* skip '%' */
    /* NOTE: unknown interface (id=0) is silently ignored */
#ifdef _WIN32
    addr->sin6_scope_id = atoi(zone_index);
#else
    addr->sin6_scope_id = if_nametoindex(zone_index);
#endif
  }
 
  return uv_inet_pton(AF_INET6, ip, &addr->sin6_addr);
}

References addr, AF_INET6, htons, ip, memcpy(), memset(), NULL, and uv_inet_pton().

Referenced by uv__udp_set_membership6(), uv__udp_set_source_membership6(), uv_udp_set_membership(), uv_udp_set_multicast_interface(), uv_udp_set_source_membership(), and uv_winsock_init().

uv_ip6_name()

UV_EXTERN int uv_ip6_name	(	const struct sockaddr_in6 *	src,
		char *	dst,
		size_t	size
	)

Definition at line 272 of file uv-common.c.

                                                                        {
  return uv_inet_ntop(AF_INET6, &src->sin6_addr, dst, size);
}

References AF_INET6, dst, src, and uv_inet_ntop().

Referenced by main().

uv_is_active()

UV_EXTERN int uv_is_active

(

const uv_handle_t *

handle

)

Definition at line 430 of file core.c.

                                            {
  return uv__is_active(handle);
}

References handle, uv__is_active, UV_HANDLE_ACTIVE, and UV_HANDLE_CLOSING.

Referenced by poll_cb(), uv_fs_poll_getpath(), uv_fs_poll_start(), and uv_fs_poll_stop().

uv_is_closing()

UV_EXTERN int uv_is_closing

(

const uv_handle_t *

handle

)

Definition at line 323 of file core.c.

                                             {
  return uv__is_closing(handle);
}

References handle, uv__is_closing, UV_HANDLE_CLOSED, and UV_HANDLE_CLOSING.

Referenced by uv_fileno().

uv_is_readable()

UV_EXTERN int uv_is_readable

(

const uv_stream_t *

handle

)

Definition at line 1606 of file stream.c.

                                              {
  return !!(stream->flags & UV_HANDLE_READABLE);
}

References handle, and UV_HANDLE_READABLE.

uv_is_writable()

UV_EXTERN int uv_is_writable

(

const uv_stream_t *

handle

)

Definition at line 1611 of file stream.c.

                                              {
  return !!(stream->flags & UV_HANDLE_WRITABLE);
}

References handle, and UV_HANDLE_WRITABLE.

uv_key_create()

UV_EXTERN int uv_key_create

(

uv_key_t *

key

)

Definition at line 823 of file thread.c.

                                 {
  return UV__ERR(pthread_key_create(key, NULL));
}

References key, NULL, and UV__ERR.

Referenced by uv__init_current_thread_key().

uv_key_delete()

UV_EXTERN void uv_key_delete

(

uv_key_t *

key

)

Definition at line 828 of file thread.c.

                                  {
  if (pthread_key_delete(*key))
    abort();
}

References FALSE, and key.

uv_key_get()

UV_EXTERN void* uv_key_get

(

uv_key_t *

key

)

Definition at line 834 of file thread.c.

                                {
  return pthread_getspecific(*key);
}

References key, NULL, and value.

Referenced by uv_thread_self().

uv_key_set()

UV_EXTERN void uv_key_set	(	uv_key_t *	key,
		void *	value
	)

Definition at line 839 of file thread.c.

                                            {
  if (pthread_setspecific(*key, value))
    abort();
}

References FALSE, key, and value.

Referenced by uv__thread_start().

uv_kill()

UV_EXTERN int uv_kill	(	int	pid,
		int	signum
	)

Definition at line 582 of file process.c.

                                 {
  if (kill(pid, signum))
    return UV__ERR(errno);
  else
    return 0;
}

References err, FALSE, HANDLE, kill, NULL, pid, signum, UV__ERR, uv__kill(), and uv_translate_sys_error().

Referenced by uv_process_kill().

uv_library_shutdown()

UV_EXTERN void uv_library_shutdown

(

void

)

Definition at line 859 of file uv-common.c.

                               {
  static int was_shutdown;
 
  if (uv__load_relaxed(&was_shutdown))
    return;
 
  uv__process_title_cleanup();
  uv__signal_cleanup();
  uv__threadpool_cleanup();
  uv__store_relaxed(&was_shutdown, 1);
}

References uv__load_relaxed, uv__process_title_cleanup(), uv__signal_cleanup(), uv__store_relaxed, and uv__threadpool_cleanup().

uv_listen()

UV_EXTERN int uv_listen	(	uv_stream_t *	stream,
		int	backlog,
		uv_connection_cb	cb
	)

Definition at line 656 of file stream.c.

                                                                     {
  int err;
 
  switch (stream->type) {
  case UV_TCP:
    err = uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
    break;
 
  case UV_NAMED_PIPE:
    err = uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
    break;
 
  default:
    err = UV_EINVAL;
  }
 
  if (err == 0)
    uv__handle_start(stream);
 
  return err;
}

References assert(), cb, err, uv__handle_start, uv_pipe_listen(), uv_tcp_listen(), and uv_translate_sys_error().

Referenced by main().

uv_loadavg()

UV_EXTERN void uv_loadavg

(

double

avg[3]

)

Definition at line 392 of file aix.c.

                               {
  perfstat_cpu_total_t ps_total;
  int result = perfstat_cpu_total(NULL, &ps_total, sizeof(ps_total), 1);
  if (result == -1) {
    avg[0] = 0.; avg[1] = 0.; avg[2] = 0.;
    return;
  }
  avg[0] = ps_total.loadavg[0] / (double)(1 << SBITS);
  avg[1] = ps_total.loadavg[1] / (double)(1 << SBITS);
  avg[2] = ps_total.loadavg[2] / (double)(1 << SBITS);
}

References ARRAY_SIZE, get_ibmi_system_status(), info(), test-lz4-speed::loadavg, NULL, SSTS0200::percent_processing_unit_used, sysinfo, uv__slurp(), and which.

uv_loop_alive()

UV_EXTERN int uv_loop_alive

(

const uv_loop_t *

loop

)

Definition at line 360 of file core.c.

                                         {
    return uv__loop_alive(loop);
}

References loop, and uv__loop_alive().

uv_loop_close()

UV_EXTERN int uv_loop_close

(

uv_loop_t *

loop

)

Definition at line 791 of file uv-common.c.

                                   {
  QUEUE* q;
  uv_handle_t* h;
#ifndef NDEBUG
  void* saved_data;
#endif
 
  if (uv__has_active_reqs(loop))
    return UV_EBUSY;
 
  QUEUE_FOREACH(q, &loop->handle_queue) {
    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
    if (!(h->flags & UV_HANDLE_INTERNAL))
      return UV_EBUSY;
  }
 
  uv__loop_close(loop);
 
#ifndef NDEBUG
  saved_data = loop->data;
  memset(loop, -1, sizeof(*loop));
  loop->data = saved_data;
#endif
  if (loop == default_loop_ptr)
    default_loop_ptr = NULL;
 
  return 0;
}

References uv_loop_s::data, default_loop_ptr, h, uv_loop_s::handle_queue, loop, memset(), NULL, QUEUE_DATA, QUEUE_FOREACH, uv__has_active_reqs, uv__loop_close(), and UV_HANDLE_INTERNAL.

Referenced by main(), and uv_loop_delete().

uv_loop_configure()

UV_EXTERN int uv_loop_configure	(	uv_loop_t *	loop,
		uv_loop_option	option,
			...
	)

Definition at line 746 of file uv-common.c.

                                                                   {
  va_list ap;
  int err;
 
  va_start(ap, option);
  /* Any platform-agnostic options should be handled here. */
  err = uv__loop_configure(loop, option, ap);
  va_end(ap);
 
  return err;
}

References err, loop, and uv__loop_configure().

uv_loop_delete()

UV_EXTERN void uv_loop_delete

(

uv_loop_t *

loop

)

Definition at line 821 of file uv-common.c.

                                     {
  uv_loop_t* default_loop;
  int err;
 
  default_loop = default_loop_ptr;
 
  err = uv_loop_close(loop);
  (void) err;    /* Squelch compiler warnings. */
  assert(err == 0);
  if (loop != default_loop)
    uv__free(loop);
}

References assert(), default_loop_ptr, err, loop, uv__free(), and uv_loop_close().

uv_loop_fork()

UV_EXTERN int uv_loop_fork

(

uv_loop_t *

loop

)

Definition at line 132 of file loop.c.

                                  {
  int err;
  unsigned int i;
  uv__io_t* w;
 
  err = uv__io_fork(loop);
  if (err)
    return err;
 
  err = uv__async_fork(loop);
  if (err)
    return err;
 
  err = uv__signal_loop_fork(loop);
  if (err)
    return err;
 
  /* Rearm all the watchers that aren't re-queued by the above. */
  for (i = 0; i < loop->nwatchers; i++) {
    w = loop->watchers[i];
    if (w == NULL)
      continue;
 
    if (w->pevents != 0 && QUEUE_EMPTY(&w->watcher_queue)) {
      w->events = 0; /* Force re-registration in uv__io_poll. */
      QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
    }
  }
 
  return 0;
}

References err, i, loop, NULL, QUEUE_EMPTY, QUEUE_INSERT_TAIL, uv__async_fork(), uv__io_fork(), uv__signal_loop_fork(), and w.

uv_loop_get_data()

UV_EXTERN void* uv_loop_get_data

(

const uv_loop_t *

loop

)

Definition at line 113 of file uv-data-getter-setters.c.

                                              {
  return loop->data;
}

References uv_loop_s::data, and loop.

uv_loop_init()

UV_EXTERN int uv_loop_init

(

uv_loop_t *

loop

)

Definition at line 30 of file loop.c.

                                  {
  uv__loop_internal_fields_t* lfields;
  void* saved_data;
  int err;
 
 
  saved_data = loop->data;
  memset(loop, 0, sizeof(*loop));
  loop->data = saved_data;
 
  lfields = (uv__loop_internal_fields_t*) uv__calloc(1, sizeof(*lfields));
  if (lfields == NULL)
    return UV_ENOMEM;
  loop->internal_fields = lfields;
 
  err = uv_mutex_init(&lfields->loop_metrics.lock);
  if (err)
    goto fail_metrics_mutex_init;
 
  heap_init((struct heap*) &loop->timer_heap);
  QUEUE_INIT(&loop->wq);
  QUEUE_INIT(&loop->idle_handles);
  QUEUE_INIT(&loop->async_handles);
  QUEUE_INIT(&loop->check_handles);
  QUEUE_INIT(&loop->prepare_handles);
  QUEUE_INIT(&loop->handle_queue);
 
  loop->active_handles = 0;
  loop->active_reqs.count = 0;
  loop->nfds = 0;
  loop->watchers = NULL;
  loop->nwatchers = 0;
  QUEUE_INIT(&loop->pending_queue);
  QUEUE_INIT(&loop->watcher_queue);
 
  loop->closing_handles = NULL;
  uv__update_time(loop);
  loop->async_io_watcher.fd = -1;
  loop->async_wfd = -1;
  loop->signal_pipefd[0] = -1;
  loop->signal_pipefd[1] = -1;
  loop->backend_fd = -1;
  loop->emfile_fd = -1;
 
  loop->timer_counter = 0;
  loop->stop_flag = 0;
 
  err = uv__platform_loop_init(loop);
  if (err)
    goto fail_platform_init;
 
  uv__signal_global_once_init();
  err = uv_signal_init(loop, &loop->child_watcher);
  if (err)
    goto fail_signal_init;
 
  uv__handle_unref(&loop->child_watcher);
  loop->child_watcher.flags |= UV_HANDLE_INTERNAL;
  QUEUE_INIT(&loop->process_handles);
 
  err = uv_rwlock_init(&loop->cloexec_lock);
  if (err)
    goto fail_rwlock_init;
 
  err = uv_mutex_init(&loop->wq_mutex);
  if (err)
    goto fail_mutex_init;
 
  err = uv_async_init(loop, &loop->wq_async, uv__work_done);
  if (err)
    goto fail_async_init;
 
  uv__handle_unref(&loop->wq_async);
  loop->wq_async.flags |= UV_HANDLE_INTERNAL;
 
  return 0;
 
fail_async_init:
  uv_mutex_destroy(&loop->wq_mutex);
 
fail_mutex_init:
  uv_rwlock_destroy(&loop->cloexec_lock);
 
fail_rwlock_init:
  uv__signal_loop_cleanup(loop);
 
fail_signal_init:
  uv__platform_loop_delete(loop);
 
fail_platform_init:
  uv_mutex_destroy(&lfields->loop_metrics.lock);
 
fail_metrics_mutex_init:
  uv__free(lfields);
  loop->internal_fields = NULL;
 
  uv__free(loop->watchers);
  loop->nwatchers = 0;
  return err;
}

References uv_loop_s::active_handles, uv_loop_s::active_reqs, uv_loop_s::count, uv_loop_s::data, err, uv_loop_s::handle_queue, uv_loop_s::internal_fields, INVALID_HANDLE_VALUE, uv__loop_metrics_s::lock, loop, uv__loop_internal_fields_s::loop_metrics, memset(), NULL, QUEUE_INIT, uv_loop_s::stop_flag, timer_heap(), uv__calloc(), uv__free(), uv__handle_unref, uv__loops_add(), uv__malloc(), uv__once_init(), uv__platform_loop_delete(), uv__platform_loop_init(), uv__signal_global_once_init(), uv__signal_loop_cleanup(), uv__work_done(), uv_async_init(), UV_HANDLE_INTERNAL, uv_mutex_destroy(), uv_mutex_init(), uv_rwlock_destroy(), uv_rwlock_init(), uv_signal_init(), uv_translate_sys_error(), and uv_update_time().

Referenced by create_loop(), main(), uv_default_loop(), and uv_loop_new().

uv_loop_new()

UV_EXTERN uv_loop_t* uv_loop_new

(

void

)

Definition at line 775 of file uv-common.c.

                             {
  uv_loop_t* loop;
 
  loop = uv__malloc(sizeof(*loop));
  if (loop == NULL)
    return NULL;
 
  if (uv_loop_init(loop)) {
    uv__free(loop);
    return NULL;
  }
 
  return loop;
}

References loop, NULL, uv__free(), uv__malloc(), and uv_loop_init().

uv_loop_set_data()

UV_EXTERN void uv_loop_set_data	(	uv_loop_t *	loop,
		void *	data
	)

Definition at line 117 of file uv-data-getter-setters.c.

                                                   {
  loop->data = data;
}

References uv_loop_s::data, and loop.

uv_loop_size()

UV_EXTERN size_t uv_loop_size

(

void

)

Definition at line 152 of file uv-common.c.

                          {
  return sizeof(uv_loop_t);
}

uv_metrics_idle_time()

UV_EXTERN uint64_t uv_metrics_idle_time

(

uv_loop_t *

loop

)

Definition at line 914 of file uv-common.c.

                                               {
  uv__loop_metrics_t* loop_metrics;
  uint64_t entry_time;
  uint64_t idle_time;
 
  loop_metrics = uv__get_loop_metrics(loop);
  uv_mutex_lock(&loop_metrics->lock);
  idle_time = loop_metrics->provider_idle_time;
  entry_time = loop_metrics->provider_entry_time;
  uv_mutex_unlock(&loop_metrics->lock);
 
  if (entry_time > 0)
    idle_time += uv_hrtime() - entry_time;
  return idle_time;
}

References uv__loop_metrics_s::lock, loop, uv__loop_metrics_s::provider_entry_time, uv__loop_metrics_s::provider_idle_time, uv__get_loop_metrics, uv_hrtime(), uv_mutex_lock(), and uv_mutex_unlock().

uv_mutex_destroy()

UV_EXTERN void uv_mutex_destroy

(

uv_mutex_t *

handle

)

Definition at line 324 of file thread.c.

                                         {
  if (pthread_mutex_destroy(mutex))
    abort();
}

References mutex.

Referenced by child_fork(), uv__custom_sem_destroy(), uv__custom_sem_init(), uv__loop_close(), uv__threadpool_cleanup(), uv_barrier_destroy(), uv_barrier_init(), and uv_loop_init().

uv_mutex_init()

UV_EXTERN int uv_mutex_init

(

uv_mutex_t *

handle

)

Definition at line 282 of file thread.c.

                                     {
#if defined(NDEBUG) || !defined(PTHREAD_MUTEX_ERRORCHECK)
  return UV__ERR(pthread_mutex_init(mutex, NULL));
#else
  pthread_mutexattr_t attr;
  int err;
 
  if (pthread_mutexattr_init(&attr))
    abort();
 
  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK))
    abort();
 
  err = pthread_mutex_init(mutex, &attr);
 
  if (pthread_mutexattr_destroy(&attr))
    abort();
 
  return UV__ERR(err);
#endif
}

References err, mutex, NULL, and UV__ERR.

Referenced by epoll_init(), init_process_title_mutex_once(), init_threads(), uv__custom_sem_init(), uv__fd_hash_init(), uv__loops_init(), uv_barrier_init(), uv_console_init(), uv_loop_init(), and uv_mutex_init_recursive().

uv_mutex_init_recursive()

UV_EXTERN int uv_mutex_init_recursive

(

uv_mutex_t *

handle

)

Definition at line 305 of file thread.c.

                                               {
  pthread_mutexattr_t attr;
  int err;
 
  if (pthread_mutexattr_init(&attr))
    abort();
 
  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE))
    abort();
 
  err = pthread_mutex_init(mutex, &attr);
 
  if (pthread_mutexattr_destroy(&attr))
    abort();
 
  return UV__ERR(err);
}

References err, mutex, UV__ERR, and uv_mutex_init().

uv_mutex_lock()

UV_EXTERN void uv_mutex_lock

(

uv_mutex_t *

handle

)

Definition at line 330 of file thread.c.

                                      {
  if (pthread_mutex_lock(mutex))
    abort();
}

References mutex.

Referenced by before_fork(), epoll_create1(), epoll_ctl(), epoll_file_close(), epoll_queue_close(), post(), uv__custom_sem_post(), uv__custom_sem_wait(), uv__fd_hash_add(), uv__fd_hash_get(), uv__fd_hash_remove(), uv__loop_close(), uv__loops_add(), uv__loops_remove(), uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), uv__tty_console_signal_resize(), uv__wake_all_loops(), uv__work_cancel(), uv__work_done(), uv_barrier_destroy(), uv_barrier_wait(), uv_exepath(), uv_get_process_title(), uv_metrics_idle_time(), uv_set_process_title(), uv_setup_args(), and worker().

uv_mutex_trylock()

UV_EXTERN int uv_mutex_trylock

(

uv_mutex_t *

handle

)

Definition at line 336 of file thread.c.

                                        {
  int err;
 
  err = pthread_mutex_trylock(mutex);
  if (err) {
    if (err != EBUSY && err != EAGAIN)
      abort();
    return UV_EBUSY;
  }
 
  return 0;
}

References EAGAIN, EBUSY, err, and mutex.

Referenced by uv__custom_sem_trywait().

uv_mutex_unlock()

UV_EXTERN void uv_mutex_unlock

(

uv_mutex_t *

handle

)

Definition at line 350 of file thread.c.

                                        {
  if (pthread_mutex_unlock(mutex))
    abort();
}

References mutex.

Referenced by after_fork(), child_fork(), epoll_create1(), epoll_ctl(), epoll_file_close(), epoll_queue_close(), post(), uv__custom_sem_post(), uv__custom_sem_trywait(), uv__custom_sem_wait(), uv__fd_hash_add(), uv__fd_hash_get(), uv__fd_hash_remove(), uv__loop_close(), uv__loops_add(), uv__loops_remove(), uv__metrics_set_provider_entry_time(), uv__metrics_update_idle_time(), uv__tty_console_signal_resize(), uv__wake_all_loops(), uv__work_cancel(), uv__work_done(), uv_barrier_destroy(), uv_barrier_wait(), uv_exepath(), uv_get_process_title(), uv_metrics_idle_time(), uv_set_process_title(), uv_setup_args(), and worker().

uv_now()

UV_EXTERN uint64_t uv_now

(

const uv_loop_t *

loop

)

Definition at line 567 of file uv-common.c.

                                       {
  return loop->time;
}

References loop.

Referenced by poll_cb(), timer_cb(), and uv_fs_poll_start().

uv_once()

UV_EXTERN void uv_once	(	uv_once_t *	guard,
		void(*)(void)	callback
	)

Definition at line 419 of file thread.c.

                                                       {
  if (pthread_once(guard, callback))
    abort();
}

References uv__once_inner().

Referenced by epoll_create1(), epoll_file_close(), uv__fs_mkstemp(), uv__get_overlapped_dummy(), uv__hrtime(), uv__once_init(), uv__random_devurandom(), uv__random_getentropy(), uv__random_getrandom_init(), uv__signal_global_once_init(), uv__thread_start(), uv__udp_sendmsg(), uv__work_submit(), uv_exepath(), uv_get_process_title(), uv_sem_init(), uv_set_process_title(), uv_setup_args(), uv_spawn(), uv_thread_self(), and uv_udp_using_recvmmsg().

uv_open_osfhandle()

UV_EXTERN int uv_open_osfhandle

(

uv_os_fd_t

os_fd

)

Definition at line 1393 of file core.c.

                                        {
  return os_fd;
}

uv_os_environ()

UV_EXTERN int uv_os_environ	(	uv_env_item_t **	envitems,
		int *	count
	)

Definition at line 1255 of file core.c.

                                                        {
  int i, j, cnt;
  uv_env_item_t* envitem;
 
  *envitems = NULL;
  *count = 0;
 
  for (i = 0; environ[i] != NULL; i++);
 
  *envitems = uv__calloc(i, sizeof(**envitems));
 
  if (*envitems == NULL)
    return UV_ENOMEM;
 
  for (j = 0, cnt = 0; j < i; j++) {
    char* buf;
    char* ptr;
 
    if (environ[j] == NULL)
      break;
 
    buf = uv__strdup(environ[j]);
    if (buf == NULL)
      goto fail;
 
    ptr = strchr(buf, '=');
    if (ptr == NULL) {
      uv__free(buf);
      continue;
    }
 
    *ptr = '\0';
 
    envitem = &(*envitems)[cnt];
    envitem->name = buf;
    envitem->value = ptr + 1;
 
    cnt++;
  }
 
  *count = cnt;
  return 0;
 
fail:
  for (i = 0; i < cnt; i++) {
    envitem = &(*envitems)[cnt];
    uv__free(envitem->name);
  }
  uv__free(*envitems);
 
  *envitems = NULL;
  *count = 0;
  return UV_ENOMEM;
}

References buf, count, env, environ, fail, i, L, uv_env_item_s::name, NULL, uv__calloc(), uv__convert_utf16_to_utf8(), uv__free(), uv__strdup(), and uv_env_item_s::value.

uv_os_free_environ()

UV_EXTERN void uv_os_free_environ	(	uv_env_item_t *	envitems,
		int	count
	)

Definition at line 835 of file uv-common.c.

                                                            {
  int i;
 
  for (i = 0; i < count; i++) {
    uv__free(envitems[i].name);
  }
 
  uv__free(envitems);
}

References count, i, and uv__free().

uv_os_free_passwd()

UV_EXTERN void uv_os_free_passwd

(

uv_passwd_t *

pwd

)

Definition at line 1228 of file core.c.

                                         {
  if (pwd == NULL)
    return;
 
  /*
    The memory for name, shell, and homedir are allocated in a single
    uv__malloc() call. The base of the pointer is stored in pwd->username, so
    that is the field that needs to be freed.
  */
  uv__free(pwd->username);
  pwd->username = NULL;
  pwd->shell = NULL;
  pwd->homedir = NULL;
}

References uv_passwd_s::homedir, NULL, uv_passwd_s::shell, uv_passwd_s::username, and uv__free().

Referenced by uv_os_homedir().

uv_os_get_passwd()

UV_EXTERN int uv_os_get_passwd

(

uv_passwd_t *

pwd

)

Definition at line 1244 of file core.c.

                                       {
  return uv__getpwuid_r(pwd);
}

References uv__getpwuid_r().

uv_os_getenv()

UV_EXTERN int uv_os_getenv	(	const char *	name,
		char *	buffer,
		size_t *	size
	)

Definition at line 1311 of file core.c.

                                                               {
  char* var;
  size_t len;
 
  if (name == NULL || buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  var = getenv(name);
 
  if (var == NULL)
    return UV_ENOENT;
 
  len = strlen(var);
 
  if (len >= *size) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, var, len + 1);
  *size = len;
 
  return 0;
}

References ARRAY_SIZE, DWORD, fail, getenv(), len, memcpy(), NULL, r, uv__convert_utf8_to_utf16(), uv__free(), uv__malloc(), and uv_translate_sys_error().

Referenced by uv_os_homedir().

uv_os_gethostname()

UV_EXTERN int uv_os_gethostname	(	char *	buffer,
		size_t *	size
	)

Definition at line 1359 of file core.c.

                                                  {
  /*
    On some platforms, if the input buffer is not large enough, gethostname()
    succeeds, but truncates the result. libuv can detect this and return ENOBUFS
    instead by creating a large enough buffer and comparing the hostname length
    to the size input.
  */
  char buf[UV_MAXHOSTNAMESIZE];
  size_t len;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
  if (gethostname(buf, sizeof(buf)) != 0)
    return UV__ERR(errno);
 
  buf[sizeof(buf) - 1] = '\0'; /* Null terminate, just to be safe. */
  len = strlen(buf);
 
  if (len >= *size) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, buf, len + 1);
  *size = len;
  return 0;
}

References buf, len, memcpy(), NULL, UV__ERR, uv__once_init(), UV_MAXHOSTNAMESIZE, and uv_translate_sys_error().

uv_os_getpid()

UV_EXTERN uv_pid_t uv_os_getpid

(

void

)

Definition at line 1397 of file core.c.

                            {
  return getpid();
}

uv_os_getppid()

UV_EXTERN uv_pid_t uv_os_getppid

(

void

)

Definition at line 1402 of file core.c.

                             {
  return getppid();
}

References DWORD, handle, and HANDLE.

Referenced by uv_pipe_open().

uv_os_getpriority()

UV_EXTERN int uv_os_getpriority	(	uv_pid_t	pid,
		int *	priority
	)

Definition at line 1407 of file core.c.

                                                   {
  int r;
 
  if (priority == NULL)
    return UV_EINVAL;
 
  errno = 0;
  r = getpriority(PRIO_PROCESS, (int) pid);
 
  if (r == -1 && errno != 0)
    return UV__ERR(errno);
 
  *priority = r;
  return 0;
}

References getpriority, handle, HANDLE, NULL, pid, r, UV__ERR, uv__get_handle(), UV_PRIORITY_ABOVE_NORMAL, UV_PRIORITY_BELOW_NORMAL, UV_PRIORITY_HIGH, UV_PRIORITY_HIGHEST, UV_PRIORITY_LOW, UV_PRIORITY_NORMAL, and uv_translate_sys_error().

uv_os_homedir()

UV_EXTERN int uv_os_homedir	(	char *	buffer,
		size_t *	size
	)

Definition at line 1059 of file core.c.

                                              {
  uv_passwd_t pwd;
  size_t len;
  int r;
 
  /* Check if the HOME environment variable is set first. The task of
     performing input validation on buffer and size is taken care of by
     uv_os_getenv(). */
  r = uv_os_getenv("HOME", buffer, size);
 
  if (r != UV_ENOENT)
    return r;
 
  /* HOME is not set, so call uv__getpwuid_r() */
  r = uv__getpwuid_r(&pwd);
 
  if (r != 0) {
    return r;
  }
 
  len = strlen(pwd.homedir);
 
  if (len >= *size) {
    *size = len + 1;
    uv_os_free_passwd(&pwd);
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, pwd.homedir, len + 1);
  *size = len;
  uv_os_free_passwd(&pwd);
 
  return 0;
}

References uv_passwd_s::homedir, len, memcpy(), r, uv__getpwuid_r(), uv_os_free_passwd(), and uv_os_getenv().

uv_os_setenv()

UV_EXTERN int uv_os_setenv	(	const char *	name,
		const char *	value
	)

Definition at line 1337 of file core.c.

                                                      {
  if (name == NULL || value == NULL)
    return UV_EINVAL;
 
  if (setenv(name, value, 1) != 0)
    return UV__ERR(errno);
 
  return 0;
}

References NULL, r, uv__convert_utf8_to_utf16(), UV__ERR, uv__free(), uv_translate_sys_error(), and value.

uv_os_setpriority()

UV_EXTERN int uv_os_setpriority	(	uv_pid_t	pid,
		int	priority
	)

Definition at line 1424 of file core.c.

                                                  {
  if (priority < UV_PRIORITY_HIGHEST || priority > UV_PRIORITY_LOW)
    return UV_EINVAL;
 
  if (setpriority(PRIO_PROCESS, (int) pid, priority) != 0)
    return UV__ERR(errno);
 
  return 0;
}

References handle, HANDLE, pid, r, setpriority, UV__ERR, uv__get_handle(), UV_PRIORITY_ABOVE_NORMAL, UV_PRIORITY_BELOW_NORMAL, UV_PRIORITY_HIGH, UV_PRIORITY_LOW, UV_PRIORITY_NORMAL, and uv_translate_sys_error().

uv_os_tmpdir()

UV_EXTERN int uv_os_tmpdir	(	char *	buffer,
		size_t *	size
	)

Definition at line 1095 of file core.c.

                                             {
  const char* buf;
  size_t len;
 
  if (buffer == NULL || size == NULL || *size == 0)
    return UV_EINVAL;
 
#define CHECK_ENV_VAR(name)                                                   \
  do {                                                                        \
    buf = getenv(name);                                                       \
    if (buf != NULL)                                                          \
      goto return_buffer;                                                     \
  }                                                                           \
  while (0)
 
  /* Check the TMPDIR, TMP, TEMP, and TEMPDIR environment variables in order */
  CHECK_ENV_VAR("TMPDIR");
  CHECK_ENV_VAR("TMP");
  CHECK_ENV_VAR("TEMP");
  CHECK_ENV_VAR("TEMPDIR");
 
#undef CHECK_ENV_VAR
 
  /* No temp environment variables defined */
  #if defined(__ANDROID__)
    buf = "/data/local/tmp";
  #else
    buf = "/tmp";
  #endif
 
return_buffer:
  len = strlen(buf);
 
  if (len >= *size) {
    *size = len + 1;
    return UV_ENOBUFS;
  }
 
  /* The returned directory should not have a trailing slash. */
  if (len > 1 && buf[len - 1] == '/') {
    len--;
  }
 
  memcpy(buffer, buf, len + 1);
  buffer[len] = '\0';
  *size = len;
 
  return 0;
}

References buf, CHECK_ENV_VAR, DWORD, L, len, memcpy(), NULL, path, uv__free(), uv__malloc(), and uv_translate_sys_error().

uv_os_uname()

UV_EXTERN int uv_os_uname

(

uv_utsname_t *

buffer

)

Definition at line 1435 of file core.c.

                                      {
  struct utsname buf;
  int r;
 
  if (buffer == NULL)
    return UV_EINVAL;
 
  if (uname(&buf) == -1) {
    r = UV__ERR(errno);
    goto error;
  }
 
  r = uv__strscpy(buffer->sysname, buf.sysname, sizeof(buffer->sysname));
  if (r == UV_E2BIG)
    goto error;
 
#ifdef _AIX
  r = snprintf(buffer->release,
               sizeof(buffer->release),
               "%s.%s",
               buf.version,
               buf.release);
  if (r >= sizeof(buffer->release)) {
    r = UV_E2BIG;
    goto error;
  }
#else
  r = uv__strscpy(buffer->release, buf.release, sizeof(buffer->release));
  if (r == UV_E2BIG)
    goto error;
#endif
 
  r = uv__strscpy(buffer->version, buf.version, sizeof(buffer->version));
  if (r == UV_E2BIG)
    goto error;
 
#if defined(_AIX) || defined(__PASE__)
  r = uv__strscpy(buffer->machine, "ppc64", sizeof(buffer->machine));
#else
  r = uv__strscpy(buffer->machine, buf.machine, sizeof(buffer->machine));
#endif
 
  if (r == UV_E2BIG)
    goto error;
 
  return 0;
 
error:
  buffer->sysname[0] = '\0';
  buffer->release[0] = '\0';
  buffer->version[0] = '\0';
  buffer->machine[0] = '\0';
  return r;
}

References assert(), DWORD, error(), L, NULL, pRtlGetVersion, PVOID, r, snprintf, uname, UV__ERR, uv__once_init(), uv__strscpy(), and uv_translate_sys_error().

uv_os_unsetenv()

UV_EXTERN int uv_os_unsetenv

(

const char *

name

)

Definition at line 1348 of file core.c.

                                     {
  if (name == NULL)
    return UV_EINVAL;
 
  if (unsetenv(name) != 0)
    return UV__ERR(errno);
 
  return 0;
}

References NULL, r, uv__convert_utf8_to_utf16(), UV__ERR, uv__free(), and uv_translate_sys_error().

uv_pipe_bind()

UV_EXTERN int uv_pipe_bind	(	uv_pipe_t *	handle,
		const char *	name
	)

Definition at line 43 of file pipe.c.

                                                      {
  struct sockaddr_un saddr;
  const char* pipe_fname;
  int sockfd;
  int err;
 
  pipe_fname = NULL;
 
  /* Already bound? */
  if (uv__stream_fd(handle) >= 0)
    return UV_EINVAL;
 
  /* Make a copy of the file name, it outlives this function's scope. */
  pipe_fname = uv__strdup(name);
  if (pipe_fname == NULL)
    return UV_ENOMEM;
 
  /* We've got a copy, don't touch the original any more. */
  name = NULL;
 
  err = uv__socket(AF_UNIX, SOCK_STREAM, 0);
  if (err < 0)
    goto err_socket;
  sockfd = err;
 
  memset(&saddr, 0, sizeof saddr);
  uv__strscpy(saddr.sun_path, pipe_fname, sizeof(saddr.sun_path));
  saddr.sun_family = AF_UNIX;
 
  if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr)) {
    err = UV__ERR(errno);
    /* Convert ENOENT to EACCES for compatibility with Windows. */
    if (err == UV_ENOENT)
      err = UV_EACCES;
 
    uv__close(sockfd);
    goto err_socket;
  }
 
  /* Success. */
  handle->flags |= UV_HANDLE_BOUND;
  handle->pipe_fname = pipe_fname; /* Is a strdup'ed copy. */
  handle->io_watcher.fd = sockfd;
  return 0;
 
err_socket:
  uv__free((void*)pipe_fname);
  return err;
}

References AF_UNIX, bind, default_pending_pipe_instances, err, error(), handle, i, INVALID_HANDLE_VALUE, loop, memset(), NULL, pipe_alloc_accept(), req, SOCK_STREAM, sockfd, sockaddr_un::sun_path, TRUE, uv__close(), UV__ERR, uv__free(), uv__malloc(), uv__socket(), uv__strdup(), uv__stream_fd, uv__strscpy(), uv_fatal_error(), UV_HANDLE_BOUND, UV_HANDLE_PIPESERVER, UV_REQ_INIT, and uv_translate_sys_error().

Referenced by main().

uv_pipe_chmod()

UV_EXTERN int uv_pipe_chmod	(	uv_pipe_t *	handle,
		int	flags
	)

Definition at line 326 of file pipe.c.

                                               {
  unsigned desired_mode;
  struct stat pipe_stat;
  char* name_buffer;
  size_t name_len;
  int r;
 
  if (handle == NULL || uv__stream_fd(handle) == -1)
    return UV_EBADF;
 
  if (mode != UV_READABLE &&
      mode != UV_WRITABLE &&
      mode != (UV_WRITABLE | UV_READABLE))
    return UV_EINVAL;
 
  /* Unfortunately fchmod does not work on all platforms, we will use chmod. */
  name_len = 0;
  r = uv_pipe_getsockname(handle, NULL, &name_len);
  if (r != UV_ENOBUFS)
    return r;
 
  name_buffer = uv__malloc(name_len);
  if (name_buffer == NULL)
    return UV_ENOMEM;
 
  r = uv_pipe_getsockname(handle, name_buffer, &name_len);
  if (r != 0) {
    uv__free(name_buffer);
    return r;
  }
 
  /* stat must be used as fstat has a bug on Darwin */
  if (stat(name_buffer, &pipe_stat) == -1) {
    uv__free(name_buffer);
    return -errno;
  }
 
  desired_mode = 0;
  if (mode & UV_READABLE)
    desired_mode |= S_IRUSR | S_IRGRP | S_IROTH;
  if (mode & UV_WRITABLE)
    desired_mode |= S_IWUSR | S_IWGRP | S_IWOTH;
 
  /* Exit early if pipe already has desired mode. */
  if ((pipe_stat.st_mode & desired_mode) == desired_mode) {
    uv__free(name_buffer);
    return 0;
  }
 
  pipe_stat.st_mode |= desired_mode;
 
  r = chmod(name_buffer, pipe_stat.st_mode);
  uv__free(name_buffer);
 
  return r != -1 ? 0 : UV__ERR(errno);
}

References chmod, done, error(), handle, INVALID_HANDLE_VALUE, memset(), NULL, r, stat, UV__ERR, uv__free(), uv__malloc(), uv__stream_fd, uv_pipe_getsockname(), UV_READABLE, uv_translate_sys_error(), and UV_WRITABLE.

uv_pipe_connect()

UV_EXTERN void uv_pipe_connect	(	uv_connect_t *	req,
		uv_pipe_t *	handle,
		const char *	name,
		uv_connect_cb	cb
	)

Definition at line 173 of file pipe.c.

                                      {
  struct sockaddr_un saddr;
  int new_sock;
  int err;
  int r;
 
  new_sock = (uv__stream_fd(handle) == -1);
 
  if (new_sock) {
    err = uv__socket(AF_UNIX, SOCK_STREAM, 0);
    if (err < 0)
      goto out;
    handle->io_watcher.fd = err;
  }
 
  memset(&saddr, 0, sizeof saddr);
  uv__strscpy(saddr.sun_path, name, sizeof(saddr.sun_path));
  saddr.sun_family = AF_UNIX;
 
  do {
    r = connect(uv__stream_fd(handle),
                (struct sockaddr*)&saddr, sizeof saddr);
  }
  while (r == -1 && errno == EINTR);
 
  if (r == -1 && errno != EINPROGRESS) {
    err = UV__ERR(errno);
#if defined(__CYGWIN__) || defined(__MSYS__)
    /* EBADF is supposed to mean that the socket fd is bad, but
       Cygwin reports EBADF instead of ENOTSOCK when the file is
       not a socket.  We do not expect to see a bad fd here
       (e.g. due to new_sock), so translate the error.  */
    if (err == UV_EBADF)
      err = UV_ENOTSOCK;
#endif
    goto out;
  }
 
  err = 0;
  if (new_sock) {
    err = uv__stream_open((uv_stream_t*)handle,
                          uv__stream_fd(handle),
                          UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
  }
 
  if (err == 0)
    uv__io_start(handle->loop, &handle->io_watcher, POLLOUT);
 
out:
  handle->delayed_error = err;
  handle->connect_req = req;
 
  uv__req_init(handle->loop, req, UV_CONNECT);
  req->handle = (uv_stream_t*)handle;
  req->cb = cb;
  QUEUE_INIT(&req->queue);
 
  /* Force callback to run on next tick in case of error. */
  if (err)
    uv__io_feed(handle->loop, &handle->io_watcher);
 
}

References AF_UNIX, assert(), cb, DWORD, EINPROGRESS, EINTR, err, error(), handle, HANDLE, INVALID_HANDLE_VALUE, loop, memset(), NULL, open_named_pipe(), out, pipe_connect_thread_proc(), QUEUE_INIT, r, REGISTER_HANDLE_REQ, req, SET_REQ_ERROR, SET_REQ_SUCCESS, SOCK_STREAM, sockaddr_un::sun_path, UV__ERR, uv__free(), uv__io_feed(), uv__io_start(), uv__malloc(), uv__req_init, uv__socket(), uv__stream_fd, uv__stream_open(), uv__strscpy(), uv_fatal_error(), UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_insert_pending_req(), UV_REQ_INIT, and uv_set_pipe_handle().

uv_pipe_getpeername()

UV_EXTERN int uv_pipe_getpeername	(	const uv_pipe_t *	handle,
		char *	buffer,
		size_t *	size
	)

Definition at line 289 of file pipe.c.

                                                                             {
  return uv__pipe_getsockpeername(handle, getpeername, buffer, size);
}

References handle, INVALID_HANDLE_VALUE, uv__pipe_getname(), uv__pipe_getsockpeername(), and UV_HANDLE_BOUND.

uv_pipe_getsockname()

UV_EXTERN int uv_pipe_getsockname	(	const uv_pipe_t *	handle,
		char *	buffer,
		size_t *	size
	)

Definition at line 284 of file pipe.c.

                                                                             {
  return uv__pipe_getsockpeername(handle, getsockname, buffer, size);
}

References handle, INVALID_HANDLE_VALUE, uv__pipe_getname(), uv__pipe_getsockpeername(), UV_HANDLE_BOUND, and UV_HANDLE_CONNECTION.

Referenced by uv_pipe_chmod().

uv_pipe_init()

UV_EXTERN int uv_pipe_init	(	uv_loop_t *	loop,
		uv_pipe_t *	handle,
		int	ipc
	)

Definition at line 33 of file pipe.c.

                                                              {
  uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE);
  handle->shutdown_req = NULL;
  handle->connect_req = NULL;
  handle->pipe_fname = NULL;
  handle->ipc = ipc;
  return 0;
}

References handle, INVALID_HANDLE_VALUE, loop, NULL, QUEUE_INIT, uv__stream_init(), and uv_stream_init().

Referenced by main(), on_new_connection(), and setup_workers().

uv_pipe_open()

UV_EXTERN int uv_pipe_open	(	uv_pipe_t *	handle,
		uv_file	file
	)

Definition at line 137 of file pipe.c.

                                                {
  int flags;
  int mode;
  int err;
  flags = 0;
 
  if (uv__fd_exists(handle->loop, fd))
    return UV_EEXIST;
 
  do
    mode = fcntl(fd, F_GETFL);
  while (mode == -1 && errno == EINTR);
 
  if (mode == -1)
    return UV__ERR(errno); /* according to docs, must be EBADF */
 
  err = uv__nonblock(fd, 1);
  if (err)
    return err;
 
#if defined(__APPLE__)
  err = uv__stream_try_select((uv_stream_t*) handle, &fd);
  if (err)
    return err;
#endif /* defined(__APPLE__) */
 
  mode &= O_ACCMODE;
  if (mode != O_WRONLY)
    flags |= UV_HANDLE_READABLE;
  if (mode != O_RDONLY)
    flags |= UV_HANDLE_WRITABLE;
 
  return uv__stream_open((uv_stream_t*)handle, fd, flags);
}

References access, assert(), DWORD, EINTR, err, F_GETFL, FALSE, fcntl, fd, FileAccessInformation, flags, handle, HANDLE, INVALID_HANDLE_VALUE, O_ACCMODE, O_RDONLY, O_WRONLY, pipe, pNtQueryInformationFile, STATUS_SUCCESS, UV__ERR, uv__fd_exists(), uv__get_osfhandle(), uv__nonblock, uv__once_init(), uv__stream_open(), UV_HANDLE_NON_OVERLAPPED_PIPE, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_os_getppid(), uv_pipe_connection_init(), uv_set_pipe_handle(), and uv_translate_sys_error().

Referenced by main().

uv_pipe_pending_count()

UV_EXTERN int uv_pipe_pending_count

(

uv_pipe_t *

handle

)

Definition at line 298 of file pipe.c.

                                             {
  uv__stream_queued_fds_t* queued_fds;
 
  if (!handle->ipc)
    return 0;
 
  if (handle->accepted_fd == -1)
    return 0;
 
  if (handle->queued_fds == NULL)
    return 1;
 
  queued_fds = handle->queued_fds;
  return queued_fds->offset + 1;
}

References handle, NULL, and uv__stream_queued_fds_s::offset.

Referenced by on_new_connection().

uv_pipe_pending_instances()

UV_EXTERN void uv_pipe_pending_instances	(	uv_pipe_t *	handle,
		int	count
	)

Definition at line 294 of file pipe.c.

                                                             {
}

References count, handle, UV_HANDLE_BOUND, and UV_HANDLE_PIPESERVER.

uv_pipe_pending_type()

UV_EXTERN uv_handle_type uv_pipe_pending_type

(

uv_pipe_t *

handle

)

Definition at line 315 of file pipe.c.

                                                       {
  if (!handle->ipc)
    return UV_UNKNOWN_HANDLE;
 
  if (handle->accepted_fd == -1)
    return UV_UNKNOWN_HANDLE;
  else
    return uv__handle_type(handle->accepted_fd);
}

References handle, uv__handle_type(), and UV_UNKNOWN_HANDLE.

Referenced by on_new_connection().

uv_poll_init()

UV_EXTERN int uv_poll_init	(	uv_loop_t *	loop,
		uv_poll_t *	handle,
		int	fd
	)

Definition at line 68 of file poll.c.

                                                             {
  int err;
 
  if (uv__fd_exists(loop, fd))
    return UV_EEXIST;
 
  err = uv__io_check_fd(loop, fd);
  if (err)
    return err;
 
  /* If ioctl(FIONBIO) reports ENOTTY, try fcntl(F_GETFL) + fcntl(F_SETFL).
   * Workaround for e.g. kqueue fds not supporting ioctls.
   */
  err = uv__nonblock(fd, 1);
  if (err == UV_ENOTTY)
    if (uv__nonblock == uv__nonblock_ioctl)
      err = uv__nonblock_fcntl(fd, 1);
 
  if (err)
    return err;
 
  uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
  uv__io_init(&handle->io_watcher, uv__poll_io, fd);
  handle->poll_cb = NULL;
  return 0;
}

References err, fd, handle, loop, NULL, uv__fd_exists(), uv__get_osfhandle(), uv__handle_init, uv__io_check_fd(), uv__io_init(), uv__nonblock, uv__nonblock_fcntl(), uv__nonblock_ioctl(), uv__poll_io(), and uv_poll_init_socket().

Referenced by uv_poll_init_socket().

uv_poll_init_socket()

UV_EXTERN int uv_poll_init_socket	(	uv_loop_t *	loop,
		uv_poll_t *	handle,
		uv_os_sock_t	socket
	)

Definition at line 96 of file poll.c.

                         {
  return uv_poll_init(loop, handle, socket);
}

References assert(), bytes, DWORD, FIONBIO, handle, len, loop, NULL, SIO_BASE_HANDLE, socket, SOL_SOCKET, uv__fast_poll_get_peer_socket(), uv__handle_init, UV_HANDLE_POLL_SLOW, uv_poll_init(), UV_REQ_INIT, and uv_translate_sys_error().

Referenced by create_curl_context(), and uv_poll_init().

uv_poll_start()

UV_EXTERN int uv_poll_start	(	uv_poll_t *	handle,
		int	events,
		uv_poll_cb	cb
	)

Definition at line 118 of file poll.c.

                                                                      {
  int events;
 
  assert((pevents & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT |
                      UV_PRIORITIZED)) == 0);
  assert(!uv__is_closing(handle));
 
  uv__poll_stop(handle);
 
  if (pevents == 0)
    return 0;
 
  events = 0;
  if (pevents & UV_READABLE)
    events |= POLLIN;
  if (pevents & UV_PRIORITIZED)
    events |= UV__POLLPRI;
  if (pevents & UV_WRITABLE)
    events |= POLLOUT;
  if (pevents & UV_DISCONNECT)
    events |= UV__POLLRDHUP;
 
  uv__io_start(handle->loop, &handle->io_watcher, events);
  uv__handle_start(handle);
  handle->poll_cb = poll_cb;
 
  return 0;
}

References assert(), cb, handle, poll_cb(), uv__handle_start, uv__io_start(), uv__is_closing, uv__poll_set(), uv__poll_stop(), UV__POLLPRI, UV__POLLRDHUP, UV_DISCONNECT, UV_PRIORITIZED, UV_READABLE, and UV_WRITABLE.

Referenced by handle_socket().

uv_poll_stop()

UV_EXTERN int uv_poll_stop

(

uv_poll_t *

handle

)

Definition at line 111 of file poll.c.

                                    {
  assert(!uv__is_closing(handle));
  uv__poll_stop(handle);
  return 0;
}

References assert(), handle, uv__is_closing, uv__poll_set(), and uv__poll_stop().

Referenced by handle_socket().

uv_prepare_init()

UV_EXTERN int uv_prepare_init	(	uv_loop_t *	,
		uv_prepare_t *	prepare
	)

Referenced by main().

uv_prepare_start()

UV_EXTERN int uv_prepare_start	(	uv_prepare_t *	prepare,
		uv_prepare_cb	cb
	)

Referenced by main().

uv_prepare_stop()

UV_EXTERN int uv_prepare_stop

(

uv_prepare_t *

prepare

)

Referenced by uv_close().

uv_print_active_handles()

UV_EXTERN void uv_print_active_handles	(	uv_loop_t *	loop,
		FILE *	stream
	)

Definition at line 542 of file uv-common.c.

                                                            {
  uv__print_handles(loop, 1, stream);
}

References loop, and uv__print_handles().

uv_print_all_handles()

UV_EXTERN void uv_print_all_handles	(	uv_loop_t *	loop,
		FILE *	stream
	)

Definition at line 537 of file uv-common.c.

                                                         {
  uv__print_handles(loop, 0, stream);
}

References loop, and uv__print_handles().

uv_process_get_pid()

UV_EXTERN uv_pid_t uv_process_get_pid

(

const uv_process_t *

proc

)

Definition at line 89 of file uv-data-getter-setters.c.

                                                      {
  return proc->pid;
}

References proc.

uv_process_kill()

UV_EXTERN int uv_process_kill	(	uv_process_t *	process,
		int	signum
	)

Definition at line 577 of file process.c.

                                                       {
  return uv_kill(process->pid, signum);
}

References err, INVALID_HANDLE_VALUE, process(), signum, uv__kill(), and uv_kill().

uv_queue_work()

UV_EXTERN int uv_queue_work	(	uv_loop_t *	loop,
		uv_work_t *	req,
		uv_work_cb	work_cb,
		uv_after_work_cb	after_work_cb
	)

Definition at line 338 of file threadpool.c.

                                                  {
  if (work_cb == NULL)
    return UV_EINVAL;
 
  uv__req_init(loop, req, UV_WORK);
  req->loop = loop;
  req->work_cb = work_cb;
  req->after_work_cb = after_work_cb;
  uv__work_submit(loop,
                  &req->work_req,
                  UV__WORK_CPU,
                  uv__queue_work,
                  uv__queue_done);
  return 0;
}

References loop, NULL, req, uv__queue_done(), uv__queue_work(), uv__req_init, UV__WORK_CPU, and uv__work_submit().

Referenced by main().

uv_random()

UV_EXTERN int uv_random	(	uv_loop_t *	loop,
		uv_random_t *	req,
		void *	buf,
		size_t	buflen,
		unsigned	flags,
		uv_random_cb	cb
	)

Definition at line 94 of file random.c.

                               {
  if (buflen > 0x7FFFFFFFu)
    return UV_E2BIG;
 
  if (flags != 0)
    return UV_EINVAL;
 
  if (cb == NULL)
    return uv__random(buf, buflen);
 
  uv__req_init(loop, req, UV_RANDOM);
  req->loop = loop;
  req->status = 0;
  req->cb = cb;
  req->buf = buf;
  req->buflen = buflen;
 
  uv__work_submit(loop,
                  &req->work_req,
                  UV__WORK_CPU,
                  uv__random_work,
                  uv__random_done);
 
  return 0;
}

References buflen, cb, flags, loop, NULL, req, uv__random(), uv__random_done(), uv__random_work(), uv__req_init, UV__WORK_CPU, and uv__work_submit().

uv_read_start()

UV_EXTERN int uv_read_start	(	uv_stream_t *	stream,
		uv_alloc_cb	alloc_cb,
		uv_read_cb	read_cb
	)

Definition at line 1555 of file stream.c.

                                      {
  assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
      stream->type == UV_TTY);
 
  if (stream->flags & UV_HANDLE_CLOSING)
    return UV_EINVAL;
 
  if (!(stream->flags & UV_HANDLE_READABLE))
    return UV_ENOTCONN;
 
  /* The UV_HANDLE_READING flag is irrelevant of the state of the tcp - it just
   * expresses the desired state of the user.
   */
  stream->flags |= UV_HANDLE_READING;
 
  /* TODO: try to do the read inline? */
  /* TODO: keep track of tcp state. If we've gotten a EOF then we should
   * not start the IO watcher.
   */
  assert(uv__stream_fd(stream) >= 0);
  assert(alloc_cb);
 
  stream->read_cb = read_cb;
  stream->alloc_cb = alloc_cb;
 
  uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
  uv__handle_start(stream);
  uv__stream_osx_interrupt_select(stream);
 
  return 0;
}

References assert(), err, handle, uv__handle_start, uv__io_start(), uv__stream_fd, uv__stream_osx_interrupt_select(), UV_HANDLE_CLOSING, UV_HANDLE_READABLE, UV_HANDLE_READING, uv_pipe_read_start(), uv_tcp_read_start(), uv_translate_sys_error(), and uv_tty_read_start().

Referenced by main(), on_connect(), and on_new_connection().

uv_read_stop()

UV_EXTERN int uv_read_stop

(

uv_stream_t *

stream

)

Definition at line 1590 of file stream.c.

                                      {
  if (!(stream->flags & UV_HANDLE_READING))
    return 0;
 
  stream->flags &= ~UV_HANDLE_READING;
  uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
  if (!uv__io_active(&stream->io_watcher, POLLOUT))
    uv__handle_stop(stream);
  uv__stream_osx_interrupt_select(stream);
 
  stream->read_cb = NULL;
  stream->alloc_cb = NULL;
  return 0;
}

References DECREASE_ACTIVE_COUNT, err, handle, NULL, uv__handle_stop, uv__io_active(), uv__io_stop(), uv__pipe_read_stop(), uv__stream_osx_interrupt_select(), UV_HANDLE_READING, uv_translate_sys_error(), and uv_tty_read_stop().

Referenced by eof_timer_cb(), uv__stream_close(), uv_pipe_read_eof(), and uv_pipe_read_error().

uv_recv_buffer_size()

UV_EXTERN int uv_recv_buffer_size	(	uv_handle_t *	handle,
		int *	value
	)

Definition at line 584 of file uv-common.c.

                                                         {
  return uv__socket_sockopt(handle, SO_RCVBUF, value);
}

References handle, SO_RCVBUF, uv__socket_sockopt(), and value.

uv_ref()

UV_EXTERN void uv_ref

(

uv_handle_t *

handle

)

Definition at line 547 of file uv-common.c.

                                 {
  uv__handle_ref(handle);
}

References handle, and uv__handle_ref.

uv_replace_allocator()

UV_EXTERN int uv_replace_allocator	(	uv_malloc_func	malloc_func,
		uv_realloc_func	realloc_func,
		uv_calloc_func	calloc_func,
		uv_free_func	free_func
	)

Definition at line 114 of file uv-common.c.

                                                 {
  if (malloc_func == NULL || realloc_func == NULL ||
      calloc_func == NULL || free_func == NULL) {
    return UV_EINVAL;
  }
 
  uv__allocator.local_malloc = malloc_func;
  uv__allocator.local_realloc = realloc_func;
  uv__allocator.local_calloc = calloc_func;
  uv__allocator.local_free = free_func;
 
  return 0;
}

References uv__allocator_t::local_calloc, uv__allocator_t::local_free, uv__allocator_t::local_malloc, uv__allocator_t::local_realloc, NULL, and uv__allocator.

uv_req_get_data()

UV_EXTERN void* uv_req_get_data

(

const uv_req_t *

req

)

Definition at line 69 of file uv-data-getter-setters.c.

                                           {
  return req->data;
}

References req.

uv_req_get_type()

UV_EXTERN uv_req_type uv_req_get_type

(

const uv_req_t *

req

)

Definition at line 65 of file uv-data-getter-setters.c.

                                                 {
  return req->type;
}

References req.

uv_req_set_data()

UV_EXTERN void uv_req_set_data	(	uv_req_t *	req,
		void *	data
	)

Definition at line 73 of file uv-data-getter-setters.c.

                                                {
  req->data = data;
}

References req.

uv_req_size()

UV_EXTERN size_t uv_req_size

(

uv_req_type

type

)

Definition at line 141 of file uv-common.c.

                                     {
  switch(type) {
    UV_REQ_TYPE_MAP(XX)
    default:
      return -1;
  }
}

References type, UV_REQ_TYPE_MAP, and XX.

uv_req_type_name()

UV_EXTERN const char* uv_req_type_name

(

uv_req_type

type

)

Definition at line 52 of file uv-data-getter-setters.c.

                                               {
  switch (type) {
#define XX(uc,lc) case UV_##uc: return #lc;
  UV_REQ_TYPE_MAP(XX)
#undef XX
  case UV_REQ_TYPE_MAX:
  case UV_UNKNOWN_REQ:
  default: /* UV_REQ_TYPE_PRIVATE */
    break;
  }
  return NULL;
}

References NULL, type, UV_REQ_TYPE_MAP, UV_REQ_TYPE_MAX, UV_UNKNOWN_REQ, and XX.

uv_resident_set_memory()

UV_EXTERN int uv_resident_set_memory

(

size_t *

rss

)

Definition at line 993 of file aix.c.

                                        {
  char pp[64];
  psinfo_t psinfo;
  int err;
  int fd;
 
  snprintf(pp, sizeof(pp), "/proc/%lu/psinfo", (unsigned long) getpid());
 
  fd = open(pp, O_RDONLY);
  if (fd == -1)
    return UV__ERR(errno);
 
  /* FIXME(bnoordhuis) Handle EINTR. */
  err = UV_EINVAL;
  if (read(fd, &psinfo, sizeof(psinfo)) == sizeof(psinfo)) {
    *rss = (size_t)psinfo.pr_rssize * 1024;
    err = 0;
  }
  uv__close(fd);
 
  return err;
}

References ARRAY_SIZE, ASCBRSME, assert(), count, EINTR, err, error(), fd, find_thread(), HANDLE, i, info(), n, NULL, O_RDONLY, pid, PSA_PTR, PSAAOLD, rax, RAXFMCT, read(), s, snprintf, status, uv__close(), UV__ERR, uv__open_cloexec(), uv_translate_sys_error(), and val.

uv_run()

UV_EXTERN int uv_run	(	uv_loop_t *	loop,
		uv_run_mode	mode
	)

Definition at line 365 of file core.c.

                                              {
  int timeout;
  int r;
  int ran_pending;
 
  r = uv__loop_alive(loop);
  if (!r)
    uv__update_time(loop);
 
  while (r != 0 && loop->stop_flag == 0) {
    uv__update_time(loop);
    uv__run_timers(loop);
    ran_pending = uv__run_pending(loop);
    uv__run_idle(loop);
    uv__run_prepare(loop);
 
    timeout = 0;
    if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
      timeout = uv_backend_timeout(loop);
 
    uv__io_poll(loop, timeout);
 
    /* Run one final update on the provider_idle_time in case uv__io_poll
     * returned because the timeout expired, but no events were received. This
     * call will be ignored if the provider_entry_time was either never set (if
     * the timeout == 0) or was already updated b/c an event was received.
     */
    uv__metrics_update_idle_time(loop);
 
    uv__run_check(loop);
    uv__run_closing_handles(loop);
 
    if (mode == UV_RUN_ONCE) {
      /* UV_RUN_ONCE implies forward progress: at least one callback must have
       * been invoked when it returns. uv__io_poll() can return without doing
       * I/O (meaning: no callbacks) when its timeout expires - which means we
       * have pending timers that satisfy the forward progress constraint.
       *
       * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from
       * the check.
       */
      uv__update_time(loop);
      uv__run_timers(loop);
    }
 
    r = uv__loop_alive(loop);
    if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
      break;
  }
 
  /* The if statement lets gcc compile it to a conditional store. Avoids
   * dirtying a cache line.
   */
  if (loop->stop_flag != 0)
    loop->stop_flag = 0;
 
  return r;
}

References DWORD, loop, pGetQueuedCompletionStatusEx, r, uv_loop_s::stop_flag, timeout, uv__io_poll(), uv__loop_alive(), uv__metrics_update_idle_time(), uv__poll(), uv__poll_wine(), uv__run_check(), uv__run_closing_handles(), uv__run_idle(), uv__run_pending(), uv__run_prepare(), uv__run_timers(), uv_backend_timeout(), uv_check_invoke(), uv_idle_invoke(), uv_prepare_invoke(), uv_process_endgames(), uv_process_reqs(), UV_RUN_DEFAULT, UV_RUN_NOWAIT, UV_RUN_ONCE, and uv_update_time().

Referenced by main(), thread1_worker(), and thread2_worker().

uv_rwlock_destroy()

UV_EXTERN void uv_rwlock_destroy

(

uv_rwlock_t *

rwlock

)

Definition at line 361 of file thread.c.

                                            {
  if (pthread_rwlock_destroy(rwlock))
    abort();
}

References uv_rwlock_t::num_readers_lock_, uv_rwlock_t::state_, and uv_rwlock_t::write_semaphore_.

Referenced by main(), uv__loop_close(), and uv_loop_init().

uv_rwlock_init()

UV_EXTERN int uv_rwlock_init

(

uv_rwlock_t *

rwlock

)

Definition at line 356 of file thread.c.

                                        {
  return UV__ERR(pthread_rwlock_init(rwlock, NULL));
}

References handle, HANDLE, NULL, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, uv_rwlock_t::state_, UV__ERR, uv_translate_sys_error(), and uv_rwlock_t::write_semaphore_.

Referenced by main(), and uv_loop_init().

uv_rwlock_rdlock()

UV_EXTERN void uv_rwlock_rdlock

(

uv_rwlock_t *

rwlock

)

Definition at line 367 of file thread.c.

                                           {
  if (pthread_rwlock_rdlock(rwlock))
    abort();
}

References DWORD, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by reader(), uv__fs_mkstemp(), and uv__fs_open().

uv_rwlock_rdunlock()

UV_EXTERN void uv_rwlock_rdunlock

(

uv_rwlock_t *

rwlock

)

Definition at line 387 of file thread.c.

                                             {
  if (pthread_rwlock_unlock(rwlock))
    abort();
}

References NULL, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by reader(), uv__fs_mkstemp(), and uv__fs_open().

uv_rwlock_tryrdlock()

UV_EXTERN int uv_rwlock_tryrdlock

(

uv_rwlock_t *

rwlock

)

Definition at line 373 of file thread.c.

                                             {
  int err;
 
  err = pthread_rwlock_tryrdlock(rwlock);
  if (err) {
    if (err != EBUSY && err != EAGAIN)
      abort();
    return UV_EBUSY;
  }
 
  return 0;
}

References DWORD, EAGAIN, EBUSY, err, uv_rwlock_t::num_readers_, uv_rwlock_t::num_readers_lock_, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

uv_rwlock_trywrlock()

UV_EXTERN int uv_rwlock_trywrlock

(

uv_rwlock_t *

rwlock

)

Definition at line 399 of file thread.c.

                                             {
  int err;
 
  err = pthread_rwlock_trywrlock(rwlock);
  if (err) {
    if (err != EBUSY && err != EAGAIN)
      abort();
    return UV_EBUSY;
  }
 
  return 0;
}

References DWORD, EAGAIN, EBUSY, err, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

uv_rwlock_wrlock()

UV_EXTERN void uv_rwlock_wrlock

(

uv_rwlock_t *

rwlock

)

Definition at line 393 of file thread.c.

                                           {
  if (pthread_rwlock_wrlock(rwlock))
    abort();
}

References DWORD, r, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by uv_spawn(), and writer().

uv_rwlock_wrunlock()

UV_EXTERN void uv_rwlock_wrunlock

(

uv_rwlock_t *

rwlock

)

Definition at line 413 of file thread.c.

                                             {
  if (pthread_rwlock_unlock(rwlock))
    abort();
}

References NULL, uv_rwlock_t::state_, uv_fatal_error(), and uv_rwlock_t::write_semaphore_.

Referenced by uv_spawn(), and writer().

uv_sem_destroy()

UV_EXTERN void uv_sem_destroy

(

uv_sem_t *

sem

)

Definition at line 662 of file thread.c.

                                   {
  if (platform_needs_custom_semaphore)
    uv__custom_sem_destroy(sem);
  else
    uv__sem_destroy(sem);
}

References platform_needs_custom_semaphore, uv__custom_sem_destroy(), and uv__sem_destroy().

Referenced by init_threads(), uv__stream_close(), uv_barrier_destroy(), and uv_barrier_init().

uv_sem_init()

UV_EXTERN int uv_sem_init	(	uv_sem_t *	sem,
		unsigned int	value
	)

Definition at line 650 of file thread.c.

                                                   {
#if defined(__GLIBC__) && !defined(__UCLIBC__)
  uv_once(&glibc_version_check_once, glibc_version_check);
#endif
 
  if (platform_needs_custom_semaphore)
    return uv__custom_sem_init(sem, value);
  else
    return uv__sem_init(sem, value);
}

References INT_MAX, NULL, platform_needs_custom_semaphore, uv__custom_sem_init(), uv__sem_init(), uv_once(), uv_translate_sys_error(), and value.

Referenced by init_threads(), uv_barrier_init(), and uv_console_init().

uv_sem_post()

UV_EXTERN void uv_sem_post

(

uv_sem_t *

sem

)

Definition at line 670 of file thread.c.

                                {
  if (platform_needs_custom_semaphore)
    uv__custom_sem_post(sem);
  else
    uv__sem_post(sem);
}

References NULL, platform_needs_custom_semaphore, uv__custom_sem_post(), and uv__sem_post().

Referenced by uv__cancel_read_console(), uv__stream_close(), uv_barrier_wait(), uv_tty_get_vterm_state(), uv_tty_get_winsize(), uv_tty_init(), uv_tty_line_read_thread(), uv_tty_set_mode(), uv_tty_set_vterm_state(), uv_tty_write_bufs(), and worker().

uv_sem_trywait()

UV_EXTERN int uv_sem_trywait

(

uv_sem_t *

sem

)

Definition at line 686 of file thread.c.

                                  {
  if (platform_needs_custom_semaphore)
    return uv__custom_sem_trywait(sem);
  else
    return uv__sem_trywait(sem);
}

References DWORD, platform_needs_custom_semaphore, r, uv__custom_sem_trywait(), and uv__sem_trywait().

uv_sem_wait()

UV_EXTERN void uv_sem_wait

(

uv_sem_t *

sem

)

Definition at line 678 of file thread.c.

                                {
  if (platform_needs_custom_semaphore)
    uv__custom_sem_wait(sem);
  else
    uv__sem_wait(sem);
}

References platform_needs_custom_semaphore, uv__custom_sem_wait(), and uv__sem_wait().

Referenced by init_threads(), uv__cancel_read_console(), uv_barrier_wait(), uv_tty_get_vterm_state(), uv_tty_get_winsize(), uv_tty_init(), uv_tty_set_mode(), uv_tty_set_vterm_state(), and uv_tty_write_bufs().

uv_send_buffer_size()

UV_EXTERN int uv_send_buffer_size	(	uv_handle_t *	handle,
		int *	value
	)

Definition at line 588 of file uv-common.c.

                                                         {
  return uv__socket_sockopt(handle, SO_SNDBUF, value);
}

References handle, SO_SNDBUF, uv__socket_sockopt(), and value.

uv_set_process_title()

UV_EXTERN int uv_set_process_title

(

const char *

title

)

Definition at line 925 of file aix.c.

                                            {
  char* new_title;
 
  /* If uv_setup_args wasn't called or failed, we can't continue. */
  if (process_argv == NULL || args_mem == NULL)
    return UV_ENOBUFS;
 
  /* We cannot free this pointer when libuv shuts down,
   * the process may still be using it.
   */
  new_title = uv__strdup(title);
  if (new_title == NULL)
    return UV_ENOMEM;
 
  uv_once(&process_title_mutex_once, init_process_title_mutex_once);
  uv_mutex_lock(&process_title_mutex);
 
  /* If this is the first time this is set,
   * don't free and set argv[1] to NULL.
   */
  if (process_title_ptr != NULL)
    uv__free(process_title_ptr);
 
  process_title_ptr = new_title;
 
  process_argv[0] = process_title_ptr;
  if (process_argc > 1)
     process_argv[1] = NULL;
 
  uv_mutex_unlock(&process_title_mutex);
 
  return 0;
}

References args_mem, uv__process_title::cap, done, err, init_process_title_mutex_once(), L, len, uv__process_title::len, length, MAX_TITLE_LENGTH, memcpy(), memset(), NULL, process_argc, process_argv, process_title, process_title_lock, process_title_mutex, process_title_mutex_once, process_title_ptr, setproctitle(), uv__process_title::str, uv__free(), uv__malloc(), uv__once_init(), uv__strdup(), uv_fatal_error(), uv_mutex_lock(), uv_mutex_unlock(), uv_once(), and uv_translate_sys_error().

uv_setup_args()

UV_EXTERN char** uv_setup_args	(	int	argc,
		char **	argv
	)

Definition at line 872 of file aix.c.

                                            {
  char exepath[UV__PATH_MAX];
  char** new_argv;
  size_t size;
  char* s;
  int i;
 
  if (argc <= 0)
    return argv;
 
  /* Save the original pointer to argv.
   * AIX uses argv to read the process name.
   * (Not the memory pointed to by argv[0..n] as on Linux.)
   */
  process_argv = argv;
  process_argc = argc;
 
  /* Use argv[0] to determine value for uv_exepath(). */
  size = sizeof(exepath);
  if (uv__search_path(argv[0], exepath, &size) == 0) {
    uv_once(&process_title_mutex_once, init_process_title_mutex_once);
    uv_mutex_lock(&process_title_mutex); 
    original_exepath = uv__strdup(exepath);
    uv_mutex_unlock(&process_title_mutex);
  }
 
  /* Calculate how much memory we need for the argv strings. */
  size = 0;
  for (i = 0; i < argc; i++)
    size += strlen(argv[i]) + 1;
 
  /* Add space for the argv pointers. */
  size += (argc + 1) * sizeof(char*);
 
  new_argv = uv__malloc(size);
  if (new_argv == NULL)
    return argv;
  args_mem = new_argv;
 
  /* Copy over the strings and set up the pointer table. */
  s = (char*) &new_argv[argc + 1];
  for (i = 0; i < argc; i++) {
    size = strlen(argv[i]) + 1;
    memcpy(s, argv[i], size);
    new_argv[i] = s;
    s += size;
  }
  new_argv[i] = NULL;
 
  return new_argv;
}

References args_mem, argv, uv__process_title::cap, i, init_process_title_mutex_once(), uv__process_title::len, loop, memcpy(), NULL, original_exepath, process_argc, process_argv, process_title, process_title_mutex, process_title_mutex_once, s, uv__process_title::str, uv__malloc(), UV__PATH_MAX, uv__search_path(), uv__strdup(), uv_mutex_lock(), uv_mutex_unlock(), and uv_once().

uv_shutdown()

UV_PRIVATE_REQ_TYPES UV_EXTERN int uv_shutdown	(	uv_shutdown_t *	req,
		uv_stream_t *	handle,
		uv_shutdown_cb	cb
	)

Definition at line 1259 of file stream.c.

                                                                            {
  assert(stream->type == UV_TCP ||
         stream->type == UV_TTY ||
         stream->type == UV_NAMED_PIPE);
 
  if (!(stream->flags & UV_HANDLE_WRITABLE) ||
      stream->flags & UV_HANDLE_SHUT ||
      stream->flags & UV_HANDLE_SHUTTING ||
      uv__is_closing(stream)) {
    return UV_ENOTCONN;
  }
 
  assert(uv__stream_fd(stream) >= 0);
 
  /* Initialize request */
  uv__req_init(stream->loop, req, UV_SHUTDOWN);
  req->handle = stream;
  req->cb = cb;
  stream->shutdown_req = req;
  stream->flags |= UV_HANDLE_SHUTTING;
 
  uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
  uv__stream_osx_interrupt_select(stream);
 
  return 0;
}

References assert(), cb, handle, loop, REGISTER_HANDLE_REQ, req, uv__io_start(), uv__is_closing, uv__req_init, uv__stream_fd, uv__stream_osx_interrupt_select(), UV_HANDLE_SHUT, UV_HANDLE_SHUTTING, UV_HANDLE_WRITABLE, UV_REQ_INIT, and uv_want_endgame().

uv_signal_init()

UV_EXTERN int uv_signal_init	(	uv_loop_t *	loop,
		uv_signal_t *	handle
	)

Definition at line 319 of file signal.c.

                                                         {
  int err;
 
  err = uv__signal_loop_once_init(loop);
  if (err)
    return err;
 
  uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
  handle->signum = 0;
  handle->caught_signals = 0;
  handle->dispatched_signals = 0;
 
  return 0;
}

References err, handle, loop, NULL, uv__handle_init, uv__signal_loop_once_init(), and UV_REQ_INIT.

Referenced by main(), thread1_worker(), thread2_worker(), and uv_loop_init().

uv_signal_start()

UV_EXTERN int uv_signal_start	(	uv_signal_t *	handle,
		uv_signal_cb	signal_cb,
		int	signum
	)

Definition at line 340 of file signal.c.

                                                                             {
  return uv__signal_start(handle, signal_cb, signum, 0);
}

References handle, signum, and uv__signal_start().

Referenced by main(), thread1_worker(), thread2_worker(), and uv_spawn().

uv_signal_start_oneshot()

UV_EXTERN int uv_signal_start_oneshot	(	uv_signal_t *	handle,
		uv_signal_cb	signal_cb,
		int	signum
	)

Definition at line 345 of file signal.c.

                                        {
  return uv__signal_start(handle, signal_cb, signum, 1);
}

References handle, signum, and uv__signal_start().

uv_signal_stop()

UV_EXTERN int uv_signal_stop

(

uv_signal_t *

handle

)

Definition at line 513 of file signal.c.

                                        {
  assert(!uv__is_closing(handle));
  uv__signal_stop(handle);
  return 0;
}

References assert(), handle, RB_REMOVE, uv__handle_stop, uv__is_closing, uv__signal_lock, uv__signal_stop(), and uv__signal_tree.

Referenced by signal_handler(), uv__process_close(), uv__signal_start(), uv_process_signal_req(), and uv_signal_close().

uv_sleep()

UV_EXTERN void uv_sleep

(

unsigned int

msec

)

Definition at line 1526 of file core.c.

                                 {
  struct timespec timeout;
  int rc;
 
  timeout.tv_sec = msec / 1000;
  timeout.tv_nsec = (msec % 1000) * 1000 * 1000;
 
  do
    rc = nanosleep(&timeout, &timeout);
  while (rc == -1 && errno == EINTR);
 
  assert(rc == 0);
}

References assert(), EINTR, nanosleep, and timeout.

uv_spawn()

UV_EXTERN int uv_spawn	(	uv_loop_t *	loop,
		uv_process_t *	handle,
		const uv_process_options_t *	options
	)

Definition at line 408 of file process.c.

                                                  {
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
  /* fork is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED. */
  return UV_ENOSYS;
#else
  int signal_pipe[2] = { -1, -1 };
  int pipes_storage[8][2];
  int (*pipes)[2];
  int stdio_count;
  ssize_t r;
  pid_t pid;
  int err;
  int exec_errorno;
  int i;
  int status;
 
  assert(options->file != NULL);
  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
                              UV_PROCESS_SETGID |
                              UV_PROCESS_SETUID |
                              UV_PROCESS_WINDOWS_HIDE |
                              UV_PROCESS_WINDOWS_HIDE_CONSOLE |
                              UV_PROCESS_WINDOWS_HIDE_GUI |
                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
 
  uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
  QUEUE_INIT(&process->queue);
 
  stdio_count = options->stdio_count;
  if (stdio_count < 3)
    stdio_count = 3;
 
  err = UV_ENOMEM;
  pipes = pipes_storage;
  if (stdio_count > (int) ARRAY_SIZE(pipes_storage))
    pipes = uv__malloc(stdio_count * sizeof(*pipes));
 
  if (pipes == NULL)
    goto error;
 
  for (i = 0; i < stdio_count; i++) {
    pipes[i][0] = -1;
    pipes[i][1] = -1;
  }
 
  for (i = 0; i < options->stdio_count; i++) {
    err = uv__process_init_stdio(options->stdio + i, pipes[i]);
    if (err)
      goto error;
  }
 
  /* This pipe is used by the parent to wait until
   * the child has called `execve()`. We need this
   * to avoid the following race condition:
   *
   *    if ((pid = fork()) > 0) {
   *      kill(pid, SIGTERM);
   *    }
   *    else if (pid == 0) {
   *      execve("/bin/cat", argp, envp);
   *    }
   *
   * The parent sends a signal immediately after forking.
   * Since the child may not have called `execve()` yet,
   * there is no telling what process receives the signal,
   * our fork or /bin/cat.
   *
   * To avoid ambiguity, we create a pipe with both ends
   * marked close-on-exec. Then, after the call to `fork()`,
   * the parent polls the read end until it EOFs or errors with EPIPE.
   */
  err = uv__make_pipe(signal_pipe, 0);
  if (err)
    goto error;
 
  uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD);
 
  /* Acquire write lock to prevent opening new fds in worker threads */
  uv_rwlock_wrlock(&loop->cloexec_lock);
  pid = fork();
 
  if (pid == -1) {
    err = UV__ERR(errno);
    uv_rwlock_wrunlock(&loop->cloexec_lock);
    uv__close(signal_pipe[0]);
    uv__close(signal_pipe[1]);
    goto error;
  }
 
  if (pid == 0) {
    uv__process_child_init(options, stdio_count, pipes, signal_pipe[1]);
    abort();
  }
 
  /* Release lock in parent process */
  uv_rwlock_wrunlock(&loop->cloexec_lock);
  uv__close(signal_pipe[1]);
 
  process->status = 0;
  exec_errorno = 0;
  do
    r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno));
  while (r == -1 && errno == EINTR);
 
  if (r == 0)
    ; /* okay, EOF */
  else if (r == sizeof(exec_errorno)) {
    do
      err = waitpid(pid, &status, 0); /* okay, read errorno */
    while (err == -1 && errno == EINTR);
    assert(err == pid);
  } else if (r == -1 && errno == EPIPE) {
    do
      err = waitpid(pid, &status, 0); /* okay, got EPIPE */
    while (err == -1 && errno == EINTR);
    assert(err == pid);
  } else
    abort();
 
  uv__close_nocheckstdio(signal_pipe[0]);
 
  for (i = 0; i < options->stdio_count; i++) {
    err = uv__process_open_stream(options->stdio + i, pipes[i]);
    if (err == 0)
      continue;
 
    while (i--)
      uv__process_close_stream(options->stdio + i);
 
    goto error;
  }
 
  /* Only activate this handle if exec() happened successfully */
  if (exec_errorno == 0) {
    QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue);
    uv__handle_start(process);
  }
 
  process->pid = pid;
  process->exit_cb = options->exit_cb;
 
  if (pipes != pipes_storage)
    uv__free(pipes);
 
  return exec_errorno;
 
error:
  if (pipes != NULL) {
    for (i = 0; i < stdio_count; i++) {
      if (i < options->stdio_count)
        if (options->stdio[i].flags & (UV_INHERIT_FD | UV_INHERIT_STREAM))
          continue;
      if (pipes[i][0] != -1)
        uv__close_nocheckstdio(pipes[i][0]);
      if (pipes[i][1] != -1)
        uv__close_nocheckstdio(pipes[i][1]);
    }
 
    if (pipes != pipes_storage)
      uv__free(pipes);
  }
 
  return err;
#endif
}

References ARRAY_SIZE, assert(), test-lz4-speed::cwd, uv_stdio_container_s::data, done, DWORD, EINTR, env, EPIPE, err, error(), exit_wait_callback(), find_path(), uv_stdio_container_s::flags, i, info(), int, L, loop, make_program_args(), make_program_env(), NULL, options, path, pid, process(), QUEUE_INIT, QUEUE_INSERT_TAIL, r, read(), search_path(), status, uv_stdio_container_s::stream, uv__chld(), uv__close(), uv__close_nocheckstdio(), UV__ERR, uv__free(), uv__handle_init, uv__handle_start, uv__init_global_job_handle(), uv__make_pipe(), uv__malloc(), uv__process_child_init(), uv__process_close_stream(), uv__process_init_stdio(), uv__process_open_stream(), uv__stdio_create(), uv__stdio_destroy(), uv__stdio_handle(), uv__stdio_size(), UV_CREATE_PIPE, uv_fatal_error(), uv_global_job_handle_, uv_global_job_handle_init_guard_, UV_INHERIT_FD, UV_INHERIT_STREAM, uv_once(), UV_PROCESS_DETACHED, uv_process_init(), UV_PROCESS_SETGID, UV_PROCESS_SETUID, UV_PROCESS_WINDOWS_HIDE, UV_PROCESS_WINDOWS_HIDE_CONSOLE, UV_PROCESS_WINDOWS_HIDE_GUI, UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS, uv_rwlock_wrlock(), uv_rwlock_wrunlock(), uv_signal_start(), uv_translate_sys_error(), and uv_utf8_to_utf16_alloc().

Referenced by invoke_cgi_script(), main(), and setup_workers().

uv_stop()

UV_EXTERN void uv_stop

(

uv_loop_t *

loop

)

Definition at line 562 of file uv-common.c.

                              {
  loop->stop_flag = 1;
}

References loop, and uv_loop_s::stop_flag.

Referenced by idle_cb().

uv_stream_get_write_queue_size()

UV_EXTERN size_t uv_stream_get_write_queue_size

(

const uv_stream_t *

stream

)

Definition at line 77 of file uv-data-getter-setters.c.

                                                                 {
  return stream->write_queue_size;
}

uv_stream_set_blocking()

UV_EXTERN int uv_stream_set_blocking	(	uv_stream_t *	handle,
		int	blocking
	)

Definition at line 1688 of file stream.c.

                                                              {
  /* Don't need to check the file descriptor, uv__nonblock()
   * will fail with EBADF if it's not valid.
   */
  return uv__nonblock(uv__stream_fd(handle), !blocking);
}

References handle, uv__nonblock, uv__stream_fd, and UV_HANDLE_BLOCKING_WRITES.

uv_strerror()

UV_EXTERN const char* uv_strerror

(

int

err

)

Definition at line 212 of file uv-common.c.

                                 {
  switch (err) {
    UV_ERRNO_MAP(UV_STRERROR_GEN)
  }
  return uv__unknown_err_code(err);
}

References err, uv__unknown_err_code(), UV_ERRNO_MAP, and UV_STRERROR_GEN.

Referenced by echo_write(), invoke_cgi_script(), main(), on_new_connection(), on_open(), on_read(), on_send(), on_type(), and on_write().

uv_strerror_r()

UV_EXTERN char* uv_strerror_r	(	int	err,
		char *	buf,
		size_t	buflen
	)

Definition at line 201 of file uv-common.c.

                                                       {
  switch (err) {
    UV_ERRNO_MAP(UV_STRERROR_GEN_R)
    default: snprintf(buf, buflen, "Unknown system error %d", err);
  }
  return buf;
}

References buflen, err, snprintf, UV_ERRNO_MAP, and UV_STRERROR_GEN_R.

uv_tcp_bind()

UV_EXTERN int uv_tcp_bind	(	uv_tcp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	flags
	)

Definition at line 277 of file uv-common.c.

                                    {
  unsigned int addrlen;
 
  if (handle->type != UV_TCP)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  return uv__tcp_bind(handle, addr, addrlen, flags);
}

References addr, addrlen, AF_INET, AF_INET6, flags, handle, and uv__tcp_bind().

Referenced by main().

uv_tcp_close_reset()

UV_EXTERN int uv_tcp_close_reset	(	uv_tcp_t *	handle,
		uv_close_cb	close_cb
	)

Definition at line 311 of file tcp.c.

                                                               {
  int fd;
  struct linger l = { 1, 0 };
 
  /* Disallow setting SO_LINGER to zero due to some platform inconsistencies */
  if (handle->flags & UV_HANDLE_SHUTTING)
    return UV_EINVAL;
 
  fd = uv__stream_fd(handle);
  if (0 != setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l)))
    return UV__ERR(errno);
 
  uv_close((uv_handle_t*) handle, close_cb);
  return 0;
}

References fd, handle, SO_LINGER, SOL_SOCKET, UV__ERR, uv__stream_fd, uv_close(), UV_HANDLE_SHUTTING, and uv_translate_sys_error().

uv_tcp_connect()

UV_EXTERN int uv_tcp_connect	(	uv_connect_t *	req,
		uv_tcp_t *	handle,
		const struct sockaddr *	addr,
		uv_connect_cb	cb
	)

Definition at line 345 of file uv-common.c.

                                     {
  unsigned int addrlen;
 
  if (handle->type != UV_TCP)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  return uv__tcp_connect(req, handle, addr, addrlen, cb);
}

References addr, addrlen, AF_INET, AF_INET6, cb, handle, req, and uv__tcp_connect().

Referenced by on_resolved().

uv_tcp_getpeername()

UV_EXTERN int uv_tcp_getpeername	(	const uv_tcp_t *	handle,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 297 of file tcp.c.

                                     {
 
  if (handle->delayed_error)
    return handle->delayed_error;
 
  return uv__getsockpeername((const uv_handle_t*) handle,
                             getpeername,
                             name,
                             namelen);
}

References handle, and uv__getsockpeername().

Referenced by uv_tcp_open().

uv_tcp_getsockname()

UV_EXTERN int uv_tcp_getsockname	(	const uv_tcp_t *	handle,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 283 of file tcp.c.

                                     {
 
  if (handle->delayed_error)
    return handle->delayed_error;
 
  return uv__getsockpeername((const uv_handle_t*) handle,
                             getsockname,
                             name,
                             namelen);
}

References handle, and uv__getsockpeername().

Referenced by uv_tcp_open().

uv_tcp_init()

UV_EXTERN int uv_tcp_init	(	uv_loop_t *	loop,
		uv_tcp_t *	handle
	)

Definition at line 143 of file tcp.c.

                                                {
  return uv_tcp_init_ex(loop, tcp, AF_UNSPEC);
}

References AF_UNSPEC, handle, loop, and uv_tcp_init_ex().

Referenced by main(), on_new_connection(), and on_resolved().

uv_tcp_init_ex()

UV_EXTERN int uv_tcp_init_ex	(	uv_loop_t *	loop,
		uv_tcp_t *	handle,
		unsigned int	flags
	)

Definition at line 114 of file tcp.c.

                                                                       {
  int domain;
 
  /* Use the lower 8 bits for the domain */
  domain = flags & 0xFF;
  if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
    return UV_EINVAL;
 
  if (flags & ~0xFF)
    return UV_EINVAL;
 
  uv__stream_init(loop, (uv_stream_t*)tcp, UV_TCP);
 
  /* If anything fails beyond this point we need to remove the handle from
   * the handle queue, since it was added by uv__handle_init in uv_stream_init.
   */
 
  if (domain != AF_UNSPEC) {
    int err = maybe_new_socket(tcp, domain, 0);
    if (err) {
      QUEUE_REMOVE(&tcp->handle_queue);
      return err;
    }
  }
 
  return 0;
}

References AF_INET, AF_INET6, AF_UNSPEC, domain, DWORD, err, flags, handle, loop, maybe_new_socket(), NULL, QUEUE_REMOVE, SOCK_STREAM, socket, uv__stream_init(), uv_stream_init(), uv_tcp_set_socket(), and uv_translate_sys_error().

Referenced by uv_tcp_init().

uv_tcp_keepalive()

UV_EXTERN int uv_tcp_keepalive	(	uv_tcp_t *	handle,
		int	enable,
		unsigned int	delay
	)

Definition at line 428 of file tcp.c.

                                                                   {
  int err;
 
  if (uv__stream_fd(handle) != -1) {
    err =uv__tcp_keepalive(uv__stream_fd(handle), on, delay);
    if (err)
      return err;
  }
 
  if (on)
    handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
  else
    handle->flags &= ~UV_HANDLE_TCP_KEEPALIVE;
 
  /* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge
   *      uv_tcp_t with an int that's almost never used...
   */
 
  return 0;
}

References err, handle, uv__stream_fd, uv__tcp_keepalive(), and UV_HANDLE_TCP_KEEPALIVE.

uv_tcp_nodelay()

UV_EXTERN int uv_tcp_nodelay	(	uv_tcp_t *	handle,
		int	enable
	)

Definition at line 410 of file tcp.c.

                                             {
  int err;
 
  if (uv__stream_fd(handle) != -1) {
    err = uv__tcp_nodelay(uv__stream_fd(handle), on);
    if (err)
      return err;
  }
 
  if (on)
    handle->flags |= UV_HANDLE_TCP_NODELAY;
  else
    handle->flags &= ~UV_HANDLE_TCP_NODELAY;
 
  return 0;
}

References err, handle, uv__stream_fd, uv__tcp_nodelay(), and UV_HANDLE_TCP_NODELAY.

uv_tcp_open()

UV_EXTERN int uv_tcp_open	(	uv_tcp_t *	handle,
		uv_os_sock_t	sock
	)

Definition at line 267 of file tcp.c.

                                                     {
  int err;
 
  if (uv__fd_exists(handle->loop, sock))
    return UV_EEXIST;
 
  err = uv__nonblock(sock, 1);
  if (err)
    return err;
 
  return uv__stream_open((uv_stream_t*)handle,
                         sock,
                         UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
}

References err, handle, int, SOL_SOCKET, uv__fd_exists(), uv__nonblock, uv__stream_open(), uv_connection_init(), UV_HANDLE_BOUND, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, uv_tcp_getpeername(), uv_tcp_getsockname(), uv_tcp_set_socket(), and uv_translate_sys_error().

uv_tcp_simultaneous_accepts()

UV_EXTERN int uv_tcp_simultaneous_accepts	(	uv_tcp_t *	handle,
		int	enable
	)

Definition at line 450 of file tcp.c.

                                                              {
  if (enable)
    handle->flags &= ~UV_HANDLE_TCP_SINGLE_ACCEPT;
  else
    handle->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
  return 0;
}

References handle, UV_HANDLE_CONNECTION, UV_HANDLE_LISTENING, UV_HANDLE_TCP_ACCEPT_STATE_CHANGING, and UV_HANDLE_TCP_SINGLE_ACCEPT.

uv_thread_create()

UV_EXTERN int uv_thread_create	(	uv_thread_t *	tid,
		uv_thread_cb	entry,
		void *	arg
	)

Definition at line 210 of file thread.c.

                                                                            {
  uv_thread_options_t params;
  params.flags = UV_THREAD_NO_FLAGS;
  return uv_thread_create_ex(tid, &params, entry, arg);
}

References uv_thread_options_s::flags, uv_thread_create_ex(), and UV_THREAD_NO_FLAGS.

Referenced by init_threads(), and main().

uv_thread_create_ex()

UV_EXTERN int uv_thread_create_ex	(	uv_thread_t *	tid,
		const uv_thread_options_t *	params,
		uv_thread_cb	entry,
		void *	arg
	)

Definition at line 216 of file thread.c.

                                   {
  int err;
  pthread_attr_t* attr;
  pthread_attr_t attr_storage;
  size_t pagesize;
  size_t stack_size;
 
  /* Used to squelch a -Wcast-function-type warning. */
  union {
    void (*in)(void*);
    void* (*out)(void*);
  } f;
 
  stack_size =
      params->flags & UV_THREAD_HAS_STACK_SIZE ? params->stack_size : 0;
 
  attr = NULL;
  if (stack_size == 0) {
    stack_size = thread_stack_size();
  } else {
    pagesize = (size_t)getpagesize();
    /* Round up to the nearest page boundary. */
    stack_size = (stack_size + pagesize - 1) &~ (pagesize - 1);
#ifdef PTHREAD_STACK_MIN
    if (stack_size < PTHREAD_STACK_MIN)
      stack_size = PTHREAD_STACK_MIN;
#endif
  }
 
  if (stack_size > 0) {
    attr = &attr_storage;
 
    if (pthread_attr_init(attr))
      abort();
 
    if (pthread_attr_setstacksize(attr, stack_size))
      abort();
  }
 
  f.in = entry;
  err = pthread_create(tid, attr, f.out, arg);
 
  if (attr != NULL)
    pthread_attr_destroy(attr);
 
  return UV__ERR(err);
}

References arg(), EACCES, EAGAIN, EINVAL, thread_ctx::entry, err, f, uv_thread_options_s::flags, HANDLE, in, NULL, uv_thread_options_s::stack_size, sysinfo, thread_stack_size(), UV__ERR, uv__free(), uv__malloc(), uv__thread_start(), and UV_THREAD_HAS_STACK_SIZE.

Referenced by uv_thread_create().

uv_thread_equal()

UV_EXTERN int uv_thread_equal	(	const uv_thread_t *	t1,
		const uv_thread_t *	t2
	)

Definition at line 277 of file thread.c.

                                                                  {
  return pthread_equal(*t1, *t2);
}

References benchmark::t1.

uv_thread_join()

UV_EXTERN int uv_thread_join

(

uv_thread_t *

tid

)

Definition at line 272 of file thread.c.

                                     {
  return UV__ERR(pthread_join(*tid, NULL));
}

References NULL, UV__ERR, and uv_translate_sys_error().

Referenced by main(), uv__stream_close(), and uv__threadpool_cleanup().

uv_thread_self()

UV_EXTERN uv_thread_t uv_thread_self

(

void

)

Definition at line 268 of file thread.c.

                                 {
  return pthread_self();
}

References uv__current_thread_init_guard, uv__current_thread_key, uv__init_current_thread_key(), uv_key_get(), and uv_once().

uv_timer_again()

UV_EXTERN int uv_timer_again

(

uv_timer_t *

handle

)

Definition at line 110 of file timer.c.

                                       {
  if (handle->timer_cb == NULL)
    return UV_EINVAL;
 
  if (handle->repeat) {
    uv_timer_stop(handle);
    uv_timer_start(handle, handle->timer_cb, handle->repeat, handle->repeat);
  }
 
  return 0;
}

References handle, NULL, uv_timer_start(), and uv_timer_stop().

Referenced by uv__run_timers().

uv_timer_get_due_in()

UV_EXTERN uint64_t uv_timer_get_due_in

(

const uv_timer_t *

handle

)

Definition at line 133 of file timer.c.

                                                       {
  if (handle->loop->time >= handle->timeout)
    return 0;
 
  return handle->timeout - handle->loop->time;
}

References handle.

uv_timer_get_repeat()

UV_EXTERN uint64_t uv_timer_get_repeat

(

const uv_timer_t *

handle

)

Definition at line 128 of file timer.c.

                                                       {
  return handle->repeat;
}

References handle.

uv_timer_init()

UV_EXTERN int uv_timer_init	(	uv_loop_t *	loop,
		uv_timer_t *	handle
	)

Definition at line 58 of file timer.c.

                                                       {
  uv__handle_init(loop, (uv_handle_t*)handle, UV_TIMER);
  handle->timer_cb = NULL;
  handle->repeat = 0;
  return 0;
}

References handle, loop, NULL, and uv__handle_init.

Referenced by eof_timer_init(), main(), and uv_fs_poll_start().

uv_timer_set_repeat()

UV_EXTERN void uv_timer_set_repeat	(	uv_timer_t *	handle,
		uint64_t	repeat
	)

Definition at line 123 of file timer.c.

                                                              {
  handle->repeat = repeat;
}

References handle, and repeat().

uv_timer_start()

UV_EXTERN int uv_timer_start	(	uv_timer_t *	handle,
		uv_timer_cb	cb,
		uint64_t	timeout,
		uint64_t	repeat
	)

Definition at line 66 of file timer.c.

                                    {
  uint64_t clamped_timeout;
 
  if (uv__is_closing(handle) || cb == NULL)
    return UV_EINVAL;
 
  if (uv__is_active(handle))
    uv_timer_stop(handle);
 
  clamped_timeout = handle->loop->time + timeout;
  if (clamped_timeout < timeout)
    clamped_timeout = (uint64_t) -1;
 
  handle->timer_cb = cb;
  handle->timeout = clamped_timeout;
  handle->repeat = repeat;
  /* start_id is the second index to be compared in timer_less_than() */
  handle->start_id = handle->loop->timer_counter++;
 
  heap_insert(timer_heap(handle->loop),
              (struct heap_node*) &handle->heap_node,
              timer_less_than);
  uv__handle_start(handle);
 
  return 0;
}

References cb, handle, NULL, repeat(), timeout, timer_heap(), timer_less_than(), uv__handle_start, uv__is_active, uv__is_closing, and uv_timer_stop().

Referenced by eof_timer_start(), main(), poll_cb(), start_timeout(), and uv_timer_again().

uv_timer_stop()

UV_EXTERN int uv_timer_stop

(

uv_timer_t *

handle

)

Definition at line 97 of file timer.c.

                                      {
  if (!uv__is_active(handle))
    return 0;
 
  heap_remove(timer_heap(handle->loop),
              (struct heap_node*) &handle->heap_node,
              timer_less_than);
  uv__handle_stop(handle);
 
  return 0;
}

References handle, timer_heap(), timer_less_than(), uv__handle_stop, and uv__is_active.

Referenced by curl_perform(), eof_timer_stop(), update(), uv__run_timers(), uv__timer_close(), uv_close(), uv_timer_again(), and uv_timer_start().

uv_translate_sys_error()

UV_EXTERN int uv_translate_sys_error

(

int

sys_errno

)

Definition at line 1249 of file core.c.

                                          {
  /* If < 0 then it's already a libuv error. */
  return sys_errno <= 0 ? sys_errno : -sys_errno;
}

Referenced by SOCKOPT_SETTER(), uv__convert_utf16_to_utf8(), uv__convert_utf8_to_utf16(), uv__fast_poll_process_poll_req(), uv__get_handle(), uv__getaddrinfo_done(), uv__getaddrinfo_translate_error(), uv__getnameinfo_work(), uv__getpwuid_r(), uv__kill(), uv__pipe_getname(), uv__slow_poll_process_poll_req(), uv__tcp_bind(), uv__tcp_connect(), uv__tcp_try_write(), uv__tty_try_write(), uv__udp_connect(), uv__udp_disconnect(), uv__udp_init_ex(), uv__udp_recv_start(), uv__udp_send(), uv__udp_set_membership4(), uv__udp_set_membership6(), uv__udp_set_source_membership4(), uv__udp_set_source_membership6(), uv__udp_try_send(), uv_accept(), uv_chdir(), uv_cpu_info(), uv_cwd(), uv_exepath(), uv_fs_event_start(), uv_get_process_title(), uv_getaddrinfo(), uv_getrusage(), uv_if_indextoiid(), uv_if_indextoname(), uv_interface_addresses(), uv_kill(), uv_listen(), uv_os_getenv(), uv_os_gethostname(), uv_os_getpriority(), uv_os_setenv(), uv_os_setpriority(), uv_os_tmpdir(), uv_os_uname(), uv_os_unsetenv(), uv_pipe_bind(), uv_pipe_chmod(), uv_pipe_endgame(), uv_pipe_open(), uv_pipe_read_error(), uv_poll_close(), uv_poll_init_socket(), uv_process_fs_event_req(), uv_process_pipe_connect_req(), uv_process_pipe_write_req(), uv_process_proc_exit(), uv_process_tcp_accept_req(), uv_process_tcp_connect_req(), uv_process_tcp_read_req(), uv_process_tcp_write_req(), uv_process_tty_read_line_req(), uv_process_tty_read_raw_req(), uv_process_tty_write_req(), uv_process_udp_recv_req(), uv_process_udp_send_req(), uv_read_start(), uv_read_stop(), uv_resident_set_memory(), uv_rwlock_init(), uv_sem_init(), uv_set_process_title(), uv_spawn(), uv_tcp_close_reset(), uv_tcp_endgame(), uv_tcp_init_ex(), uv_tcp_open(), uv_thread_join(), uv_tty_get_winsize(), uv_tty_init(), uv_tty_set_mode(), uv_udp_open(), uv_udp_set_broadcast(), uv_udp_set_multicast_interface(), uv_uptime(), uv_write(), and uv_write2().

uv_try_write()

UV_EXTERN int uv_try_write	(	uv_stream_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 1507 of file stream.c.

                                     {
  int r;
  int has_pollout;
  size_t written;
  size_t req_size;
  uv_write_t req;
 
  /* Connecting or already writing some data */
  if (stream->connect_req != NULL || stream->write_queue_size != 0)
    return UV_EAGAIN;
 
  has_pollout = uv__io_active(&stream->io_watcher, POLLOUT);
 
  r = uv_write(&req, stream, bufs, nbufs, uv_try_write_cb);
  if (r != 0)
    return r;
 
  /* Remove not written bytes from write queue size */
  written = uv__count_bufs(bufs, nbufs);
  if (req.bufs != NULL)
    req_size = uv__write_req_size(&req);
  else
    req_size = 0;
  written -= req_size;
  stream->write_queue_size -= req_size;
 
  /* Unqueue request, regardless of immediateness */
  QUEUE_REMOVE(&req.queue);
  uv__req_unregister(stream->loop, &req);
  if (req.bufs != req.bufsml)
    uv__free(req.bufs);
  req.bufs = NULL;
 
  /* Do not poll for writable, if we wasn't before calling this */
  if (!has_pollout) {
    uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT);
    uv__stream_osx_interrupt_select(stream);
  }
 
  if (written == 0 && req_size != 0)
    return req.error < 0 ? req.error : UV_EAGAIN;
  else
    return written;
}

References assert(), bufs, NULL, QUEUE_REMOVE, r, req, uv__count_bufs(), uv__free(), uv__io_active(), uv__io_stop(), uv__req_unregister, uv__stream_osx_interrupt_select(), uv__tcp_try_write(), uv__tty_try_write(), uv__write_req_size(), UV_HANDLE_CLOSING, UV_HANDLE_WRITABLE, uv_try_write_cb(), and uv_write().

uv_tty_get_vterm_state()

UV_EXTERN int uv_tty_get_vterm_state

(

uv_tty_vtermstate_t *

state

)

Definition at line 400 of file tty.c.

                                                       {
  return UV_ENOTSUP;
}

References uv__vterm_state, uv_sem_post(), uv_sem_wait(), and uv_tty_output_lock.

uv_tty_get_winsize()

UV_EXTERN int uv_tty_get_winsize	(	uv_tty_t *	tty,
		int *	width,
		int *	height
	)

Definition at line 297 of file tty.c.

                                                               {
  struct winsize ws;
  int err;
 
  do
    err = ioctl(uv__stream_fd(tty), TIOCGWINSZ, &ws);
  while (err == -1 && errno == EINTR);
 
  if (err == -1)
    return UV__ERR(errno);
 
  *width = ws.ws_col;
  *height = ws.ws_row;
 
  return 0;
}

References EINTR, err, height, info(), ioctl, TIOCGWINSZ, tty, UV__ERR, uv__stream_fd, uv_sem_post(), uv_sem_wait(), uv_translate_sys_error(), uv_tty_output_lock, uv_tty_update_virtual_window(), uv_tty_virtual_height, uv_tty_virtual_width, width, winsize::ws_col, and winsize::ws_row.

Referenced by main().

uv_tty_init()

UV_EXTERN int uv_tty_init	(	uv_loop_t *	loop,
		uv_tty_t *	tty,
		uv_file	fd,
		int	readable
	)

Definition at line 123 of file tty.c.

                                                                    {
  uv_handle_type type;
  int flags;
  int newfd;
  int r;
  int saved_flags;
  int mode;
  char path[256];
  (void)unused; /* deprecated parameter is no longer needed */
 
  /* File descriptors that refer to files cannot be monitored with epoll.
   * That restriction also applies to character devices like /dev/random
   * (but obviously not /dev/tty.)
   */
  type = uv_guess_handle(fd);
  if (type == UV_FILE || type == UV_UNKNOWN_HANDLE)
    return UV_EINVAL;
 
  flags = 0;
  newfd = -1;
 
  /* Save the fd flags in case we need to restore them due to an error. */
  do
    saved_flags = fcntl(fd, F_GETFL);
  while (saved_flags == -1 && errno == EINTR);
 
  if (saved_flags == -1)
    return UV__ERR(errno);
  mode = saved_flags & O_ACCMODE;
 
  /* Reopen the file descriptor when it refers to a tty. This lets us put the
   * tty in non-blocking mode without affecting other processes that share it
   * with us.
   *
   * Example: `node | cat` - if we put our fd 0 in non-blocking mode, it also
   * affects fd 1 of `cat` because both file descriptors refer to the same
   * struct file in the kernel. When we reopen our fd 0, it points to a
   * different struct file, hence changing its properties doesn't affect
   * other processes.
   */
  if (type == UV_TTY) {
    /* Reopening a pty in master mode won't work either because the reopened
     * pty will be in slave mode (*BSD) or reopening will allocate a new
     * master/slave pair (Linux). Therefore check if the fd points to a
     * slave device.
     */
    if (uv__tty_is_slave(fd) && ttyname_r(fd, path, sizeof(path)) == 0)
      r = uv__open_cloexec(path, mode | O_NOCTTY);
    else
      r = -1;
 
    if (r < 0) {
      /* fallback to using blocking writes */
      if (mode != O_RDONLY)
        flags |= UV_HANDLE_BLOCKING_WRITES;
      goto skip;
    }
 
    newfd = r;
 
    r = uv__dup2_cloexec(newfd, fd);
    if (r < 0 && r != UV_EINVAL) {
      /* EINVAL means newfd == fd which could conceivably happen if another
       * thread called close(fd) between our calls to isatty() and open().
       * That's a rather unlikely event but let's handle it anyway.
       */
      uv__close(newfd);
      return r;
    }
 
    fd = newfd;
  }
 
skip:
  uv__stream_init(loop, (uv_stream_t*) tty, UV_TTY);
 
  /* If anything fails beyond this point we need to remove the handle from
   * the handle queue, since it was added by uv__handle_init in uv_stream_init.
   */
 
  if (!(flags & UV_HANDLE_BLOCKING_WRITES))
    uv__nonblock(fd, 1);
 
#if defined(__APPLE__)
  r = uv__stream_try_select((uv_stream_t*) tty, &fd);
  if (r) {
    int rc = r;
    if (newfd != -1)
      uv__close(newfd);
    QUEUE_REMOVE(&tty->handle_queue);
    do
      r = fcntl(fd, F_SETFL, saved_flags);
    while (r == -1 && errno == EINTR);
    return rc;
  }
#endif
 
  if (mode != O_WRONLY)
    flags |= UV_HANDLE_READABLE;
  if (mode != O_RDONLY)
    flags |= UV_HANDLE_WRITABLE;
 
  uv__stream_open((uv_stream_t*) tty, fd, flags);
  tty->mode = UV_TTY_MODE_NORMAL;
 
  return 0;
}

References ANSI_NORMAL, DWORD, EINTR, F_GETFL, F_SETFL, FALSE, fcntl, fd, flags, handle, HANDLE, INVALID_HANDLE_VALUE, loop, memset(), NULL, O_ACCMODE, O_NOCTTY, O_RDONLY, O_WRONLY, path, QUEUE_REMOVE, r, skip(), tty, type, uv__close(), uv__determine_vterm_state(), uv__dup2_cloexec(), UV__ERR, uv__get_osfhandle(), uv__need_check_vterm_state, uv__nonblock, uv__once_init(), uv__open_cloexec(), uv__stream_init(), uv__stream_open(), uv__tty_is_slave(), uv_connection_init(), UV_FILE, uv_guess_handle(), UV_HANDLE_BLOCKING_WRITES, UV_HANDLE_BOUND, UV_HANDLE_READABLE, UV_HANDLE_TTY_READABLE, UV_HANDLE_WRITABLE, uv_null_buf_, uv_sem_post(), uv_sem_wait(), uv_stream_init(), uv_translate_sys_error(), uv_tty_capture_initial_style(), UV_TTY_MODE_NORMAL, uv_tty_output_lock, uv_tty_update_virtual_window(), and UV_UNKNOWN_HANDLE.

Referenced by main().

uv_tty_reset_mode()

UV_EXTERN int uv_tty_reset_mode

(

void

)

Definition at line 378 of file tty.c.

                            {
  int saved_errno;
  int err;
 
  saved_errno = errno;
  if (!uv_spinlock_trylock(&termios_spinlock))
    return UV_EBUSY;  /* In uv_tty_set_mode(). */
 
  err = 0;
  if (orig_termios_fd != -1)
    if (tcsetattr(orig_termios_fd, TCSANOW, &orig_termios))
      err = UV__ERR(errno);
 
  uv_spinlock_unlock(&termios_spinlock);
  errno = saved_errno;
 
  return err;
}

References err, orig_termios, orig_termios_fd, TCSANOW, termios_spinlock, and UV__ERR.

Referenced by main(), and update().

uv_tty_set_mode()

UV_EXTERN int uv_tty_set_mode	(	uv_tty_t *	tty,
		uv_tty_mode_t	mode
	)

Definition at line 250 of file tty.c.

                                                       {
  struct termios tmp;
  int fd;
 
  if (tty->mode == (int) mode)
    return 0;
 
  fd = uv__stream_fd(tty);
  if (tty->mode == UV_TTY_MODE_NORMAL && mode != UV_TTY_MODE_NORMAL) {
    if (tcgetattr(fd, &tty->orig_termios))
      return UV__ERR(errno);
 
    /* This is used for uv_tty_reset_mode() */
    uv_spinlock_lock(&termios_spinlock);
    if (orig_termios_fd == -1) {
      orig_termios = tty->orig_termios;
      orig_termios_fd = fd;
    }
    uv_spinlock_unlock(&termios_spinlock);
  }
 
  tmp = tty->orig_termios;
  switch (mode) {
    case UV_TTY_MODE_NORMAL:
      break;
    case UV_TTY_MODE_RAW:
      tmp.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
      tmp.c_oflag |= (ONLCR);
      tmp.c_cflag |= (CS8);
      tmp.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
      tmp.c_cc[VMIN] = 1;
      tmp.c_cc[VTIME] = 0;
      break;
    case UV_TTY_MODE_IO:
      uv__tty_make_raw(&tmp);
      break;
  }
 
  /* Apply changes after draining */
  if (tcsetattr(fd, TCSADRAIN, &tmp))
    return UV__ERR(errno);
 
  tty->mode = mode;
  return 0;
}

References BRKINT, CS8, DWORD, ECHO, err, fd, flags, ICANON, ICRNL, IEXTEN, INPCK, ISIG, ISTRIP, IXON, NULL, ONLCR, orig_termios, orig_termios_fd, TCSADRAIN, termios_spinlock, autogen_x86imm::tmp, tty, UV__ERR, uv__stream_fd, uv__tty_make_raw(), UV_HANDLE_READING, UV_HANDLE_TTY_RAW, UV_HANDLE_TTY_READABLE, uv_sem_post(), uv_sem_wait(), uv_translate_sys_error(), UV_TTY_MODE_IO, UV_TTY_MODE_NORMAL, UV_TTY_MODE_RAW, uv_tty_output_lock, uv_tty_read_start(), uv_tty_read_stop(), VMIN, and VTIME.

Referenced by main().

uv_tty_set_vterm_state()

UV_EXTERN void uv_tty_set_vterm_state

(

uv_tty_vtermstate_t

state

)

Definition at line 397 of file tty.c.

                                                       {
}

References FALSE, uv__need_check_vterm_state, uv__vterm_state, uv_sem_post(), uv_sem_wait(), and uv_tty_output_lock.

uv_udp_bind()

UV_EXTERN int uv_udp_bind	(	uv_udp_t *	handle,
		const struct sockaddr *	addr,
		unsigned int	flags
	)

Definition at line 326 of file uv-common.c.

                                    {
  unsigned int addrlen;
 
  if (handle->type != UV_UDP)
    return UV_EINVAL;
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  return uv__udp_bind(handle, addr, addrlen, flags);
}

References addr, addrlen, AF_INET, AF_INET6, flags, handle, and uv__udp_bind().

Referenced by main().

uv_udp_connect()

UV_EXTERN int uv_udp_connect	(	uv_udp_t *	handle,
		const struct sockaddr *	addr
	)

Definition at line 365 of file uv-common.c.

                                                                  {
  unsigned int addrlen;
 
  if (handle->type != UV_UDP)
    return UV_EINVAL;
 
  /* Disconnect the handle */
  if (addr == NULL) {
    if (!(handle->flags & UV_HANDLE_UDP_CONNECTED))
      return UV_ENOTCONN;
 
    return uv__udp_disconnect(handle);
  }
 
  if (addr->sa_family == AF_INET)
    addrlen = sizeof(struct sockaddr_in);
  else if (addr->sa_family == AF_INET6)
    addrlen = sizeof(struct sockaddr_in6);
  else
    return UV_EINVAL;
 
  if (handle->flags & UV_HANDLE_UDP_CONNECTED)
    return UV_EISCONN;
 
  return uv__udp_connect(handle, addr, addrlen);
}

References addr, addrlen, AF_INET, AF_INET6, handle, NULL, uv__udp_connect(), uv__udp_disconnect(), and UV_HANDLE_UDP_CONNECTED.

uv_udp_get_send_queue_count()

UV_EXTERN size_t uv_udp_get_send_queue_count

(

const uv_udp_t *

handle

)

Definition at line 85 of file uv-data-getter-setters.c.

                                                           {
  return handle->send_queue_count;
}

References handle.

uv_udp_get_send_queue_size()

UV_EXTERN size_t uv_udp_get_send_queue_size

(

const uv_udp_t *

handle

)

Definition at line 81 of file uv-data-getter-setters.c.

                                                          {
  return handle->send_queue_size;
}

References handle.

uv_udp_getpeername()

UV_EXTERN int uv_udp_getpeername	(	const uv_udp_t *	handle,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 1276 of file udp.c.

                                     {
 
  return uv__getsockpeername((const uv_handle_t*) handle,
                             getpeername,
                             name,
                             namelen);
}

References handle, and uv__getsockpeername().

Referenced by uv__udp_is_connected().

uv_udp_getsockname()

UV_EXTERN int uv_udp_getsockname	(	const uv_udp_t *	handle,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 1286 of file udp.c.

                                     {
 
  return uv__getsockpeername((const uv_handle_t*) handle,
                             getsockname,
                             name,
                             namelen);
}

References handle, and uv__getsockpeername().

Referenced by uv__udp_is_bound().

uv_udp_init()

UV_EXTERN int uv_udp_init	(	uv_loop_t *	loop,
		uv_udp_t *	handle
	)

Definition at line 321 of file uv-common.c.

                                                   {
  return uv_udp_init_ex(loop, handle, AF_UNSPEC);
}

References AF_UNSPEC, handle, loop, and uv_udp_init_ex().

Referenced by main().

uv_udp_init_ex()

UV_EXTERN int uv_udp_init_ex	(	uv_loop_t *	,
		uv_udp_t *	handle,
		unsigned int	flags
	)

uv_udp_open()

UV_EXTERN int uv_udp_open	(	uv_udp_t *	handle,
		uv_os_sock_t	sock
	)

Definition at line 991 of file udp.c.

                                                     {
  int err;
 
  /* Check for already active socket. */
  if (handle->io_watcher.fd != -1)
    return UV_EBUSY;
 
  if (uv__fd_exists(handle->loop, sock))
    return UV_EEXIST;
 
  err = uv__nonblock(sock, 1);
  if (err)
    return err;
 
  err = uv__set_reuse(sock);
  if (err)
    return err;
 
  handle->io_watcher.fd = sock;
  if (uv__udp_is_connected(handle))
    handle->flags |= UV_HANDLE_UDP_CONNECTED;
 
  return 0;
}

References err, handle, int, SOL_SOCKET, uv__fd_exists(), uv__nonblock, uv__set_reuse(), uv__udp_is_bound(), uv__udp_is_connected(), UV_HANDLE_BOUND, UV_HANDLE_UDP_CONNECTED, uv_translate_sys_error(), and uv_udp_set_socket().

Referenced by uv_accept().

uv_udp_recv_start()

UV_EXTERN int uv_udp_recv_start	(	uv_udp_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_udp_recv_cb	recv_cb
	)

Definition at line 468 of file uv-common.c.

                                              {
  if (handle->type != UV_UDP || alloc_cb == NULL || recv_cb == NULL)
    return UV_EINVAL;
  else
    return uv__udp_recv_start(handle, alloc_cb, recv_cb);
}

References handle, NULL, and uv__udp_recv_start().

Referenced by main().

uv_udp_recv_stop()

UV_EXTERN int uv_udp_recv_stop

(

uv_udp_t *

handle

)

Definition at line 478 of file uv-common.c.

                                       {
  if (handle->type != UV_UDP)
    return UV_EINVAL;
  else
    return uv__udp_recv_stop(handle);
}

References handle, and uv__udp_recv_stop().

Referenced by on_read(), uv_process_udp_recv_req(), and uv_udp_close().

uv_udp_send()

UV_EXTERN int uv_udp_send	(	uv_udp_send_t *	req,
		uv_udp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		const struct sockaddr *	addr,
		uv_udp_send_cb	send_cb
	)

Definition at line 438 of file uv-common.c.

                                        {
  int addrlen;
 
  addrlen = uv__udp_check_before_send(handle, addr);
  if (addrlen < 0)
    return addrlen;
 
  return uv__udp_send(req, handle, bufs, nbufs, addr, addrlen, send_cb);
}

References addr, addrlen, bufs, handle, req, uv__udp_check_before_send(), and uv__udp_send().

Referenced by main().

uv_udp_set_broadcast()

UV_EXTERN int uv_udp_set_broadcast	(	uv_udp_t *	handle,
		int	on
	)

Definition at line 1128 of file udp.c.

                                                   {
  if (setsockopt(handle->io_watcher.fd,
                 SOL_SOCKET,
                 SO_BROADCAST,
                 &on,
                 sizeof(on))) {
    return UV__ERR(errno);
  }
 
  return 0;
}

References handle, SO_BROADCAST, SOL_SOCKET, UV__ERR, uv_translate_sys_error(), and value.

Referenced by main().

uv_udp_set_membership()

UV_EXTERN int uv_udp_set_membership	(	uv_udp_t *	handle,
		const char *	multicast_addr,
		const char *	interface_addr,
		uv_membership	membership
	)

Definition at line 1017 of file udp.c.

                                                    {
  int err;
  struct sockaddr_in addr4;
  struct sockaddr_in6 addr6;
 
  if (uv_ip4_addr(multicast_addr, 0, &addr4) == 0) {
    err = uv__udp_maybe_deferred_bind(handle, AF_INET, UV_UDP_REUSEADDR);
    if (err)
      return err;
    return uv__udp_set_membership4(handle, &addr4, interface_addr, membership);
  } else if (uv_ip6_addr(multicast_addr, 0, &addr6) == 0) {
    err = uv__udp_maybe_deferred_bind(handle, AF_INET6, UV_UDP_REUSEADDR);
    if (err)
      return err;
    return uv__udp_set_membership6(handle, &addr6, interface_addr, membership);
  } else {
    return UV_EINVAL;
  }
}

References AF_INET, AF_INET6, err, handle, uv__udp_maybe_deferred_bind(), uv__udp_set_membership4(), uv__udp_set_membership6(), uv_ip4_addr(), uv_ip6_addr(), and UV_UDP_REUSEADDR.

uv_udp_set_multicast_interface()

UV_EXTERN int uv_udp_set_multicast_interface	(	uv_udp_t *	handle,
		const char *	interface_addr
	)

Definition at line 1227 of file udp.c.

                                                                                 {
  struct sockaddr_storage addr_st;
  struct sockaddr_in* addr4;
  struct sockaddr_in6* addr6;
 
  addr4 = (struct sockaddr_in*) &addr_st;
  addr6 = (struct sockaddr_in6*) &addr_st;
 
  if (!interface_addr) {
    memset(&addr_st, 0, sizeof addr_st);
    if (handle->flags & UV_HANDLE_IPV6) {
      addr_st.ss_family = AF_INET6;
      addr6->sin6_scope_id = 0;
    } else {
      addr_st.ss_family = AF_INET;
      addr4->sin_addr.s_addr = htonl(INADDR_ANY);
    }
  } else if (uv_ip4_addr(interface_addr, 0, addr4) == 0) {
    /* nothing, address was parsed */
  } else if (uv_ip6_addr(interface_addr, 0, addr6) == 0) {
    /* nothing, address was parsed */
  } else {
    return UV_EINVAL;
  }
 
  if (addr_st.ss_family == AF_INET) {
    if (setsockopt(handle->io_watcher.fd,
                   IPPROTO_IP,
                   IP_MULTICAST_IF,
                   (void*) &addr4->sin_addr,
                   sizeof(addr4->sin_addr)) == -1) {
      return UV__ERR(errno);
    }
  } else if (addr_st.ss_family == AF_INET6) {
    if (setsockopt(handle->io_watcher.fd,
                   IPPROTO_IPV6,
                   IPV6_MULTICAST_IF,
                   &addr6->sin6_scope_id,
                   sizeof(addr6->sin6_scope_id)) == -1) {
      return UV__ERR(errno);
    }
  } else {
    assert(0 && "unexpected address family");
    abort();
  }
 
  return 0;
}

References AF_INET, AF_INET6, assert(), handle, memset(), in_addr::s_addr, sockaddr_in6::sin6_scope_id, sockaddr_in::sin_addr, UV__ERR, UV_HANDLE_IPV6, uv_ip4_addr(), uv_ip6_addr(), and uv_translate_sys_error().

uv_udp_set_multicast_loop()

UV_EXTERN int uv_udp_set_multicast_loop	(	uv_udp_t *	handle,
		int	on
	)

Definition at line 1203 of file udp.c.

                                                        {
/*
 * On Solaris and derivatives such as SmartOS, the length of socket options
 * is sizeof(int) for IPV6_MULTICAST_LOOP and sizeof(char) for
 * IP_MULTICAST_LOOP, so hardcode the size of the option in the IPv6 case,
 * and use the general uv__setsockopt_maybe_char call otherwise.
 */
#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
    defined(__MVS__) || defined(__QNX__)
  if (handle->flags & UV_HANDLE_IPV6)
    return uv__setsockopt(handle,
                          IP_MULTICAST_LOOP,
                          IPV6_MULTICAST_LOOP,
                          &on,
                          sizeof(on));
#endif /* defined(__sun) || defined(_AIX) ||defined(__OpenBSD__) ||
    defined(__MVS__) || defined(__QNX__) */
 
  return uv__setsockopt_maybe_char(handle,
                                   IP_MULTICAST_LOOP,
                                   IPV6_MULTICAST_LOOP,
                                   on);
}

References handle, uv__setsockopt(), uv__setsockopt_maybe_char(), and UV_HANDLE_IPV6.

uv_udp_set_multicast_ttl()

UV_EXTERN int uv_udp_set_multicast_ttl	(	uv_udp_t *	handle,
		int	ttl
	)

Definition at line 1178 of file udp.c.

                                                        {
/*
 * On Solaris and derivatives such as SmartOS, the length of socket options
 * is sizeof(int) for IPV6_MULTICAST_HOPS and sizeof(char) for
 * IP_MULTICAST_TTL, so hardcode the size of the option in the IPv6 case,
 * and use the general uv__setsockopt_maybe_char call otherwise.
 */
#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
    defined(__MVS__) || defined(__QNX__)
  if (handle->flags & UV_HANDLE_IPV6)
    return uv__setsockopt(handle,
                          IP_MULTICAST_TTL,
                          IPV6_MULTICAST_HOPS,
                          &ttl,
                          sizeof(ttl));
#endif /* defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
    defined(__MVS__) || defined(__QNX__) */
 
  return uv__setsockopt_maybe_char(handle,
                                   IP_MULTICAST_TTL,
                                   IPV6_MULTICAST_HOPS,
                                   ttl);
}

References handle, uv__setsockopt(), uv__setsockopt_maybe_char(), and UV_HANDLE_IPV6.

uv_udp_set_source_membership()

UV_EXTERN int uv_udp_set_source_membership	(	uv_udp_t *	handle,
		const char *	multicast_addr,
		const char *	interface_addr,
		const char *	source_addr,
		uv_membership	membership
	)

Definition at line 1041 of file udp.c.

                                                           {
#if !defined(__OpenBSD__) &&                                        \
    !defined(__NetBSD__) &&                                         \
    !defined(__ANDROID__) &&                                        \
    !defined(__DragonFly__) &&                                      \
    !defined(__QNX__)
  int err;
  union uv__sockaddr mcast_addr;
  union uv__sockaddr src_addr;
 
  err = uv_ip4_addr(multicast_addr, 0, &mcast_addr.in);
  if (err) {
    err = uv_ip6_addr(multicast_addr, 0, &mcast_addr.in6);
    if (err)
      return err;
    err = uv_ip6_addr(source_addr, 0, &src_addr.in6);
    if (err)
      return err;
    return uv__udp_set_source_membership6(handle,
                                          &mcast_addr.in6,
                                          interface_addr,
                                          &src_addr.in6,
                                          membership);
  }
 
  err = uv_ip4_addr(source_addr, 0, &src_addr.in);
  if (err)
    return err;
  return uv__udp_set_source_membership4(handle,
                                        &mcast_addr.in,
                                        interface_addr,
                                        &src_addr.in,
                                        membership);
#else
  return UV_ENOSYS;
#endif
}

References err, handle, uv__sockaddr::in, uv__sockaddr::in6, uv__udp_set_source_membership4(), uv__udp_set_source_membership6(), uv_ip4_addr(), and uv_ip6_addr().

uv_udp_set_ttl()

UV_EXTERN int uv_udp_set_ttl	(	uv_udp_t *	handle,
		int	ttl
	)

Definition at line 1141 of file udp.c.

                                              {
  if (ttl < 1 || ttl > 255)
    return UV_EINVAL;
 
#if defined(__MVS__)
  if (!(handle->flags & UV_HANDLE_IPV6))
    return UV_ENOTSUP;  /* zOS does not support setting ttl for IPv4 */
#endif
 
/*
 * On Solaris and derivatives such as SmartOS, the length of socket options
 * is sizeof(int) for IP_TTL and IPV6_UNICAST_HOPS,
 * so hardcode the size of these options on this platform,
 * and use the general uv__setsockopt_maybe_char call on other platforms.
 */
#if defined(__sun) || defined(_AIX) || defined(__OpenBSD__) || \
    defined(__MVS__) || defined(__QNX__)
 
  return uv__setsockopt(handle,
                        IP_TTL,
                        IPV6_UNICAST_HOPS,
                        &ttl,
                        sizeof(ttl));
 
#else /* !(defined(__sun) || defined(_AIX) || defined (__OpenBSD__) ||
           defined(__MVS__) || defined(__QNX__)) */
 
  return uv__setsockopt_maybe_char(handle,
                                   IP_TTL,
                                   IPV6_UNICAST_HOPS,
                                   ttl);
 
#endif /* defined(__sun) || defined(_AIX) || defined (__OpenBSD__) ||
          defined(__MVS__) || defined(__QNX__) */
}

References handle, uv__setsockopt(), uv__setsockopt_maybe_char(), and UV_HANDLE_IPV6.

uv_udp_try_send()

UV_EXTERN int uv_udp_try_send	(	uv_udp_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		const struct sockaddr *	addr
	)

Definition at line 454 of file uv-common.c.

                                                 {
  int addrlen;
 
  addrlen = uv__udp_check_before_send(handle, addr);
  if (addrlen < 0)
    return addrlen;
 
  return uv__udp_try_send(handle, bufs, nbufs, addr, addrlen);
}

References addr, addrlen, bufs, handle, uv__udp_check_before_send(), and uv__udp_try_send().

uv_udp_using_recvmmsg()

UV_EXTERN int uv_udp_using_recvmmsg

(

const uv_udp_t *

handle

)

Definition at line 980 of file udp.c.

                                                  {
#if HAVE_MMSG
  if (handle->flags & UV_HANDLE_UDP_RECVMMSG) {
    uv_once(&once, uv__udp_mmsg_init);
    return uv__recvmmsg_avail;
  }
#endif
  return 0;
}

References handle, once, UV_HANDLE_UDP_RECVMMSG, and uv_once().

Referenced by uv__udp_recvmsg().

uv_unref()

UV_EXTERN void uv_unref

(

uv_handle_t *

handle

)

Definition at line 552 of file uv-common.c.

                                   {
  uv__handle_unref(handle);
}

References handle, and uv__handle_unref.

Referenced by eof_timer_init(), and main().

uv_update_time()

UV_EXTERN void uv_update_time

(

uv_loop_t *

loop

)

Definition at line 425 of file core.c.

                                     {
  uv__update_time(loop);
}

References assert(), loop, and uv__hrtime().

Referenced by uv__poll(), uv__poll_wine(), uv_loop_init(), and uv_run().

uv_uptime()

UV_EXTERN int uv_uptime

(

double *

uptime

)

Definition at line 1017 of file aix.c.

                              {
  struct utmp *utmp_buf;
  size_t entries = 0;
  time_t boot_time;
 
  boot_time = 0;
  utmpname(UTMP_FILE);
 
  setutent();
 
  while ((utmp_buf = getutent()) != NULL) {
    if (utmp_buf->ut_user[0] && utmp_buf->ut_type == USER_PROCESS)
      ++entries;
    if (utmp_buf->ut_type == BOOT_TIME)
      boot_time = utmp_buf->ut_time;
  }
 
  endutent();
 
  if (boot_time == 0)
    return UV_ENOSYS;
 
  *uptime = time(NULL) - boot_time;
  return 0;
}

References ARRAY_SIZE, buffer_size, CLOCK_BOOTTIME, DWORD, EINVAL, entries(), i, info(), L, LONG, NULL, r, sp, sysinfo, time, timespec::tv_sec, UV__ERR, uv__free(), uv__malloc(), uv_translate_sys_error(), v, value, and which.

uv_version()

UV_EXTERN unsigned int uv_version

(

void

)

Definition at line 38 of file version.c.

                              {
  return UV_VERSION_HEX;
}

References UV_VERSION_HEX.

uv_version_string()

UV_EXTERN const char* uv_version_string

(

void

)

Definition at line 43 of file version.c.

                                    {
  return UV_VERSION_STRING;
}

References UV_VERSION_STRING.

uv_walk()

UV_EXTERN void uv_walk	(	uv_loop_t *	loop,
		uv_walk_cb	walk_cb,
		void *	arg
	)

Definition at line 486 of file uv-common.c.

                                                             {
  QUEUE queue;
  QUEUE* q;
  uv_handle_t* h;
 
  QUEUE_MOVE(&loop->handle_queue, &queue);
  while (!QUEUE_EMPTY(&queue)) {
    q = QUEUE_HEAD(&queue);
    h = QUEUE_DATA(q, uv_handle_t, handle_queue);
 
    QUEUE_REMOVE(q);
    QUEUE_INSERT_TAIL(&loop->handle_queue, q);
 
    if (h->flags & UV_HANDLE_INTERNAL) continue;
    walk_cb(h, arg);
  }
}

References h, uv_loop_s::handle_queue, loop, queue, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INSERT_TAIL, QUEUE_MOVE, QUEUE_REMOVE, and UV_HANDLE_INTERNAL.

uv_write()

UV_EXTERN int uv_write	(	uv_write_t *	req,
		uv_stream_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_write_cb	cb
	)

Definition at line 1492 of file stream.c.

                             {
  return uv_write2(req, handle, bufs, nbufs, NULL, cb);
}

References assert(), bufs, cb, err, handle, loop, NULL, req, uv__pipe_write(), UV_HANDLE_WRITABLE, uv_tcp_write(), uv_translate_sys_error(), uv_tty_write(), and uv_write2().

Referenced by echo_read(), main(), update(), uv_try_write(), uv_write2(), and write_data().

uv_write2()

UV_EXTERN int uv_write2	(	uv_write_t *	req,
		uv_stream_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_stream_t *	send_handle,
		uv_write_cb	cb
	)

Definition at line 1393 of file stream.c.

                              {
  int empty_queue;
 
  assert(nbufs > 0);
  assert((stream->type == UV_TCP ||
          stream->type == UV_NAMED_PIPE ||
          stream->type == UV_TTY) &&
         "uv_write (unix) does not yet support other types of streams");
 
  if (uv__stream_fd(stream) < 0)
    return UV_EBADF;
 
  if (!(stream->flags & UV_HANDLE_WRITABLE))
    return UV_EPIPE;
 
  if (send_handle) {
    if (stream->type != UV_NAMED_PIPE || !((uv_pipe_t*)stream)->ipc)
      return UV_EINVAL;
 
    /* XXX We abuse uv_write2() to send over UDP handles to child processes.
     * Don't call uv__stream_fd() on those handles, it's a macro that on OS X
     * evaluates to a function that operates on a uv_stream_t with a couple of
     * OS X specific fields. On other Unices it does (handle)->io_watcher.fd,
     * which works but only by accident.
     */
    if (uv__handle_fd((uv_handle_t*) send_handle) < 0)
      return UV_EBADF;
 
#if defined(__CYGWIN__) || defined(__MSYS__)
    /* Cygwin recvmsg always sets msg_controllen to zero, so we cannot send it.
       See https://github.com/mirror/newlib-cygwin/blob/86fc4bf0/winsup/cygwin/fhandler_socket.cc#L1736-L1743 */
    return UV_ENOSYS;
#endif
  }
 
  /* It's legal for write_queue_size > 0 even when the write_queue is empty;
   * it means there are error-state requests in the write_completed_queue that
   * will touch up write_queue_size later, see also uv__write_req_finish().
   * We could check that write_queue is empty instead but that implies making
   * a write() syscall when we know that the handle is in error mode.
   */
  empty_queue = (stream->write_queue_size == 0);
 
  /* Initialize the req */
  uv__req_init(stream->loop, req, UV_WRITE);
  req->cb = cb;
  req->handle = stream;
  req->error = 0;
  req->send_handle = send_handle;
  QUEUE_INIT(&req->queue);
 
  req->bufs = req->bufsml;
  if (nbufs > ARRAY_SIZE(req->bufsml))
    req->bufs = uv__malloc(nbufs * sizeof(bufs[0]));
 
  if (req->bufs == NULL)
    return UV_ENOMEM;
 
  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
  req->nbufs = nbufs;
  req->write_index = 0;
  stream->write_queue_size += uv__count_bufs(bufs, nbufs);
 
  /* Append the request to write_queue. */
  QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue);
 
  /* If the queue was empty when this function began, we should attempt to
   * do the write immediately. Otherwise start the write_watcher and wait
   * for the fd to become writable.
   */
  if (stream->connect_req) {
    /* Still connecting, do nothing. */
  }
  else if (empty_queue) {
    uv__write(stream);
  }
  else {
    /*
     * blocking streams should never have anything in the queue.
     * if this assert fires then somehow the blocking stream isn't being
     * sufficiently flushed in uv__write.
     */
    assert(!(stream->flags & UV_HANDLE_BLOCKING_WRITES));
    uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
    uv__stream_osx_interrupt_select(stream);
  }
 
  return 0;
}

References ARRAY_SIZE, assert(), bufs, cb, err, handle, loop, memcpy(), NULL, QUEUE_INIT, QUEUE_INSERT_TAIL, req, uv__count_bufs(), uv__handle_fd(), uv__io_start(), uv__malloc(), uv__pipe_write(), uv__req_init, uv__stream_fd, uv__stream_osx_interrupt_select(), uv__write(), UV_HANDLE_BLOCKING_WRITES, UV_HANDLE_WRITABLE, uv_translate_sys_error(), and uv_write().

Referenced by on_new_connection(), and uv_write().