socket.c File Reference

#include <rz_socket.h>
#include <rz_types.h>
#include <rz_util.h>
#include <errno.h>

Go to the source code of this file.

Macros
#define	NETWORK_DISABLED   0
#define	D   if (0)
#define	BUFFER_SIZE   4096

Functions
	RZ_LIB_VERSION (rz_socket)
RZ_API bool	rz_socket_is_connected (RzSocket *s)
RZ_API RzSocket *	rz_socket_new (bool is_ssl)
RZ_API bool	rz_socket_spawn (RzSocket *s, const char *cmd, unsigned int timeout)
RZ_API bool	rz_socket_connect (RzSocket *s, const char *host, const char *port, int proto, unsigned int timeout)
RZ_API int	rz_socket_close_fd (RzSocket *s)
RZ_API int	rz_socket_close (RzSocket *s)
RZ_API int	rz_socket_free (RzSocket *s)
RZ_API int	rz_socket_port_by_name (const char *name)
RZ_API bool	rz_socket_listen (RzSocket *s, const char *port, const char *certfile)
RZ_API RzSocket *	rz_socket_accept (RzSocket *s)
RZ_API RzSocket *	rz_socket_accept_timeout (RzSocket *s, unsigned int timeout)
RZ_API bool	rz_socket_block_time (RzSocket *s, bool block, int sec, int usec)
RZ_API int	rz_socket_flush (RzSocket *s)
RZ_API int	rz_socket_ready (RzSocket *s, int secs, int usecs)
RZ_API char *	rz_socket_to_string (RzSocket *s)
RZ_API int	rz_socket_write (RzSocket *s, void *buf, int len)
RZ_API int	rz_socket_puts (RzSocket *s, char *buf)
RZ_API void	rz_socket_printf (RzSocket *s, const char *fmt,...)
RZ_API int	rz_socket_read (RzSocket *s, unsigned char *buf, int len)
RZ_API int	rz_socket_read_block (RzSocket *s, ut8 *buf, int len)
RZ_API int	rz_socket_gets (RzSocket *s, char *buf, int size)
RZ_API RzSocket *	rz_socket_new_from_fd (int fd)
RZ_API ut8 *	rz_socket_slurp (RzSocket *s, int *len)

Macro Definition Documentation

BUFFER_SIZE

#define BUFFER_SIZE   4096

Definition at line 99 of file socket.c.

D

#define D   if (0)

Definition at line 16 of file socket.c.

NETWORK_DISABLED

#define NETWORK_DISABLED   0

Definition at line 13 of file socket.c.

Function Documentation

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_socket

)

rz_socket_accept()

RZ_API RzSocket* rz_socket_accept

(

RzSocket *

s

)

Definition at line 582 of file socket.c.

                                               {
    RzSocket *sock;
    socklen_t salen = sizeof(s->sa);
    if (!s) {
        return NULL;
    }
    sock = RZ_NEW0(RzSocket);
    if (!sock) {
        return NULL;
    }
    // signal (SIGPIPE, SIG_DFL);
    sock->fd = accept(s->fd, (struct sockaddr *)&s->sa, &salen);
    if (sock->fd == RZ_INVALID_SOCKET) {
        if (errno != EWOULDBLOCK) {
            // not just a timeout
            rz_sys_perror("accept");
        }
        free(sock);
        return NULL;
    }
#if HAVE_LIB_SSL
    sock->is_ssl = s->is_ssl;
    if (sock->is_ssl) {
        sock->sfd = NULL;
        sock->ctx = NULL;
        sock->bio = NULL;
        BIO *sbio = BIO_new_socket(sock->fd, BIO_NOCLOSE);
        sock->sfd = SSL_new(s->ctx);
        SSL_set_bio(sock->sfd, sbio, sbio);
        if (SSL_accept(sock->sfd) <= 0) {
            rz_socket_free(sock);
            return NULL;
        }
        sock->bio = BIO_new(BIO_f_buffer());
        sbio = BIO_new(BIO_f_ssl());
        BIO_set_ssl(sbio, sock->sfd, BIO_CLOSE);
        BIO_push(sock->bio, sbio);
    }
#else
    sock->is_ssl = 0;
#endif
    return sock;
}

References accept, rz_socket_t::fd, free(), rz_socket_t::is_ssl, NULL, RZ_INVALID_SOCKET, RZ_NEW0, rz_socket_free(), rz_sys_perror, s, and rz_socket_t::sa.

Referenced by rz_core_rtr_cmds(), rz_core_rtr_gdb_run(), rz_core_serve(), rz_run_config_env(), rz_socket_accept_timeout(), rz_socket_http_accept(), rz_socket_rap_server_accept(), rz_write_from_socket_handler(), and tcpme().

rz_socket_accept_timeout()

RZ_API RzSocket* rz_socket_accept_timeout	(	RzSocket *	s,
		unsigned int	timeout
	)

Definition at line 626 of file socket.c.

                                                                             {
    fd_set read_fds;
    fd_set except_fds;
 
    FD_ZERO(&read_fds);
    FD_SET(s->fd, &read_fds);
 
    FD_ZERO(&except_fds);
    FD_SET(s->fd, &except_fds);
 
    struct timeval t = { timeout, 0 };
 
    int r = select(s->fd + 1, &read_fds, NULL, &except_fds, &t);
    if (r < 0) {
        perror("select");
    } else if (r > 0 && FD_ISSET(s->fd, &read_fds)) {
        return rz_socket_accept(s);
    }
 
    return NULL;
}

References rz_socket_t::fd, FD_ISSET, FD_SET, FD_ZERO, NULL, r, rz_socket_accept(), s, select, and timeout.

Referenced by rz_socket_http_accept().

rz_socket_block_time()

RZ_API bool rz_socket_block_time	(	RzSocket *	s,
		bool	block,
		int	sec,
		int	usec
	)

Definition at line 649 of file socket.c.

                                                                             {
#if __UNIX__
    int ret, flags;
#endif
    if (!s) {
        return false;
    }
#if __UNIX__
    flags = fcntl(s->fd, F_GETFL, 0);
    if (flags < 0) {
        return false;
    }
    ret = fcntl(s->fd, F_SETFL, block ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK));
    if (ret < 0) {
        return false;
    }
#elif __WINDOWS__
    ioctlsocket(s->fd, FIONBIO, (u_long FAR *)&block);
#endif
    if (sec > 0 || usec > 0) {
        struct timeval tv = { sec, usec };
        if (setsockopt(s->fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv)) < 0) {
            return false;
        }
    }
    return true;
}

References F_GETFL, F_SETFL, FAR, fcntl, rz_socket_t::fd, FIONBIO, flags, O_NONBLOCK, s, SO_RCVTIMEO, SOL_SOCKET, and tv.

Referenced by runcmd(), rz_socket_connect(), rz_socket_http_accept(), rz_socket_is_connected(), rz_socket_rap_client_open(), rz_socket_rap_client_read(), and socket_slurp().

rz_socket_close()

RZ_API int rz_socket_close

(

RzSocket *

s

)

Definition at line 419 of file socket.c.

                                        {
    int ret = false;
    if (!s) {
        return false;
    }
    if (s->fd != RZ_INVALID_SOCKET) {
#if __UNIX__
        shutdown(s->fd, SHUT_RDWR);
#endif
#if __WINDOWS__
        // https://msdn.microsoft.com/en-us/library/windows/desktop/ms740481(v=vs.85).aspx
        shutdown(s->fd, SD_SEND);
        if (rz_socket_ready(s, 0, 250)) {
            do {
                char buf = 0;
                ret = recv(s->fd, &buf, 1, 0);
            } while (ret != 0 && ret != SOCKET_ERROR);
        }
        ret = closesocket(s->fd);
#else
        ret = close(s->fd);
#endif
        s->fd = RZ_INVALID_SOCKET;
    }
#if HAVE_LIB_SSL
    if (s->is_ssl && s->sfd) {
        SSL_free(s->sfd);
        s->sfd = NULL;
    }
#endif
    return ret;
}

References close, rz_socket_t::fd, rz_socket_t::is_ssl, NULL, RZ_INVALID_SOCKET, rz_socket_ready(), s, and SD_SEND.

Referenced by __rap_close(), gdbr_connect(), gdbr_disconnect(), iob_net_close(), qnxr_disconnect(), rap_break(), rz_core_rtr_cmd(), rz_core_rtr_cmds(), rz_core_rtr_gdb_run(), rz_core_serve(), rz_socket_connect(), rz_socket_free(), rz_socket_gets(), rz_socket_rap_server_continue(), rz_socket_spawn(), and socket_http_answer().

rz_socket_close_fd()

RZ_API int rz_socket_close_fd

(

RzSocket *

s

)

Definition at line 410 of file socket.c.

                                           {
#ifdef _MSC_VER
    return s->fd != INVALID_SOCKET ? closesocket(s->fd) : false;
#else
    return s->fd != -1 ? close(s->fd) : false;
#endif
}

References close, rz_socket_t::fd, and s.

Referenced by redirect_socket_to_pty(), and rz_run_config_env().

rz_socket_connect()

RZ_API bool rz_socket_connect	(	RzSocket *	s,
		const char *	host,
		const char *	port,
		int	proto,
		unsigned int	timeout
	)

Definition at line 257 of file socket.c.

                                                                                                                {
    rz_return_val_if_fail(s, false);
#if __WINDOWS__
#define gai_strerror gai_strerrorA
    WSADATA wsadata;
 
    if (WSAStartup(MAKEWORD(1, 1), &wsadata) == SOCKET_ERROR) {
        eprintf("Error creating socket.");
        return false;
    }
#endif
    int ret;
    struct addrinfo hints = { 0 };
    struct addrinfo *res, *rp;
    if (proto == RZ_SOCKET_PROTO_NONE) {
        proto = RZ_SOCKET_PROTO_DEFAULT;
    }
#if __UNIX__
    rz_sys_signal(SIGPIPE, SIG_IGN);
#endif
    if (proto == RZ_SOCKET_PROTO_UNIX) {
#if __UNIX__
        if (!__connect_unix(s, host)) {
            return false;
        }
#endif
    } else {
        hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
        hints.ai_protocol = proto;
        int gai = getaddrinfo(host, port, &hints, &res);
        if (gai != 0) {
            eprintf("rz_socket_connect: Error in getaddrinfo: %s (%s:%s)\n",
                gai_strerror(gai), host, port);
            return false;
        }
        for (rp = res; rp != NULL; rp = rp->ai_next) {
            int flag = 1;
 
            s->fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
            if (s->fd == -1) {
                perror("socket");
                continue;
            }
 
            switch (proto) {
            case RZ_SOCKET_PROTO_TCP:
                ret = setsockopt(s->fd, IPPROTO_TCP, TCP_NODELAY, (char *)&flag, sizeof(flag));
                if (ret < 0) {
                    perror("setsockopt");
                    close(s->fd);
                    s->fd = -1;
                    continue;
                }
                rz_socket_block_time(s, true, 1, 0);
                ret = connect(s->fd, rp->ai_addr, rp->ai_addrlen);
                break;
            case RZ_SOCKET_PROTO_UDP:
                memset(&s->sa, 0, sizeof(s->sa));
                s->sa.sin_family = AF_INET;
                s->sa.sin_addr.s_addr = htonl(s->local ? INADDR_LOOPBACK : INADDR_ANY);
                s->port = rz_socket_port_by_name(port);
                if (s->port < 1) {
                    continue;
                }
                s->sa.sin_port = htons(s->port);
                if (bind(s->fd, (struct sockaddr *)&s->sa, sizeof(s->sa)) < 0) {
                    rz_sys_perror("bind");
#ifdef __WINDOWS__
                    closesocket(s->fd);
#else
                    close(s->fd);
#endif
                    continue;
                }
                ret = connect(s->fd, rp->ai_addr, rp->ai_addrlen);
                break;
            default:
                rz_socket_block_time(s, true, 1, 0);
                ret = connect(s->fd, rp->ai_addr, rp->ai_addrlen);
                break;
            }
 
            if (ret == 0) {
                freeaddrinfo(res);
                return true;
            }
            if (errno == EINPROGRESS) {
                struct timeval tv = { timeout, 0 };
                fd_set wfds;
                FD_ZERO(&wfds);
                FD_SET(s->fd, &wfds);
 
                if (select(s->fd + 1, NULL, &wfds, NULL, &tv) != -1) {
                    if (rz_socket_is_connected(s)) {
                        freeaddrinfo(res);
                        goto success;
                    }
                } else {
                    perror("connect");
                }
            }
            rz_socket_close(s);
        }
        freeaddrinfo(res);
        if (!rp) {
            eprintf("Could not resolve address '%s' or failed to connect\n", host);
            return false;
        }
    }
success:
#if HAVE_LIB_SSL
    if (s->is_ssl) {
        s->ctx = SSL_CTX_new(SSLv23_client_method());
        if (!s->ctx) {
            rz_socket_close(s);
            return false;
        }
        s->sfd = SSL_new(s->ctx);
        SSL_set_fd(s->sfd, s->fd);
        int ret = SSL_connect(s->sfd);
        if (ret != 1) {
            int error = SSL_get_error(s->sfd, ret);
            int tries = 10;
            while (tries && ret && (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)) {
                struct timeval tv = { 1, 0 };
                fd_set rfds, wfds;
                FD_ZERO(&rfds);
                FD_ZERO(&wfds);
                if (error == SSL_ERROR_WANT_READ) {
                    FD_SET(s->fd, &rfds);
                } else {
                    FD_SET(s->fd, &wfds);
                }
                if ((ret = select(s->fd + 1, &rfds, &wfds, NULL, &tv)) < 1) {
                    rz_socket_close(s);
                    return false;
                }
                ret = SSL_connect(s->sfd);
                if (ret == 1) {
                    return true;
                }
                error = SSL_get_error(s->sfd, ret);
                tries--;
            }
            rz_socket_close(s);
            return false;
        }
    }
#endif
    return true;
}

References AF_INET, AF_UNSPEC, bind, close, EINPROGRESS, eprintf, error(), rz_socket_t::fd, FD_SET, FD_ZERO, htons, rz_socket_t::is_ssl, rz_socket_t::local, memset(), NULL, rz_socket_t::port, rp, rz_return_val_if_fail, rz_socket_block_time(), rz_socket_close(), rz_socket_is_connected(), rz_socket_port_by_name(), RZ_SOCKET_PROTO_DEFAULT, RZ_SOCKET_PROTO_NONE, RZ_SOCKET_PROTO_TCP, RZ_SOCKET_PROTO_UDP, RZ_SOCKET_PROTO_UNIX, rz_sys_perror, rz_sys_signal(), s, in_addr::s_addr, rz_socket_t::sa, select, sockaddr_in::sin_addr, sockaddr_in::sin_port, socket, timeout, and tv.

Referenced by __rap_open(), rz_core_rtr_cmd(), rz_core_rtr_cmds_query(), rz_core_rtr_http_stop(), rz_socket_spawn(), and tcpme().

rz_socket_flush()

RZ_API int rz_socket_flush

(

RzSocket *

s

)

Definition at line 677 of file socket.c.

                                        {
#if HAVE_LIB_SSL
    if (s->is_ssl && s->bio) {
        return BIO_flush(s->bio);
    }
#endif
    return true;
}

References rz_socket_t::is_ssl, and s.

Referenced by __rap_system(), rz_core_serve(), rz_socket_rap_client_command(), rz_socket_rap_client_open(), rz_socket_rap_client_read(), rz_socket_rap_client_seek(), rz_socket_rap_client_write(), and rz_socket_rap_server_continue().

rz_socket_free()

RZ_API int rz_socket_free

(

RzSocket *

s

)

Definition at line 453 of file socket.c.

                                       {
    int res = rz_socket_close(s);
#if HAVE_LIB_SSL
    if (s && s->is_ssl) {
        if (s->sfd) {
            SSL_free(s->sfd);
        }
        if (s->ctx) {
            SSL_CTX_free(s->ctx);
        }
    }
#endif
    free(s);
    return res;
}

References free(), rz_socket_t::is_ssl, rz_socket_close(), and s.

Referenced by __rap_open(), __rtr_shell(), gdbr_cleanup(), iob_net_close(), redirect_socket_to_pty(), rz_core_rtr_add(), rz_core_rtr_cmd(), rz_core_rtr_cmds(), rz_core_rtr_cmds_query(), rz_core_rtr_gdb_run(), rz_core_rtr_http_run(), rz_core_rtr_http_stop(), rz_core_rtr_remove(), rz_core_serve(), rz_main_rz_agent(), rz_run_config_env(), rz_socket_accept(), rz_socket_http_close(), rz_socket_listen(), rz_socket_new(), rz_socket_rap_server_free(), rz_socket_rap_server_new(), rz_write_from_socket_handler(), socket_http_get_recursive(), and tcpme().

rz_socket_gets()

RZ_API int rz_socket_gets	(	RzSocket *	s,
		char *	buf,
		int	size
	)

Definition at line 830 of file socket.c.

                                                            {
    int i = 0;
    int ret = 0;
 
    if (s->fd == RZ_INVALID_SOCKET) {
        return -1;
    }
    while (i < size) {
        ret = rz_socket_read(s, (ut8 *)buf + i, 1);
        if (ret == 0) {
            if (i > 0) {
                return i;
            }
            return -1;
        }
        if (ret < 0) {
            rz_socket_close(s);
            return i == 0 ? -1 : i;
        }
        if (buf[i] == '\r' || buf[i] == '\n') {
            buf[i] = 0;
            break;
        }
        i += ret;
    }
    buf[i] = '\0';
    return i;
}

References rz_socket_t::fd, i, RZ_INVALID_SOCKET, rz_socket_close(), rz_socket_read(), and s.

Referenced by rz_socket_http_accept(), and rz_socket_proc_gets().

rz_socket_is_connected()

RZ_API bool rz_socket_is_connected

(

RzSocket *

s

)

Definition at line 101 of file socket.c.

                                                {
#if __WINDOWS__
    char buf[2];
    rz_socket_block_time(s, false, 0, 0);
#ifdef _MSC_VER
    int ret = recv(s->fd, (char *)&buf, 1, MSG_PEEK);
#else
    ssize_t ret = recv(s->fd, (char *)&buf, 1, MSG_PEEK);
#endif
    rz_socket_block_time(s, true, 0, 0);
    return ret == 1;
#else
    int error = 0;
    socklen_t len = sizeof(error);
    int ret = getsockopt(s->fd, SOL_SOCKET, SO_ERROR, &error, &len);
    if (ret != 0) {
        perror("getsockopt");
        return false;
    }
    return (error == 0);
#endif
}

References error(), rz_socket_t::fd, len, rz_socket_block_time(), s, SO_ERROR, and SOL_SOCKET.

Referenced by rz_socket_connect(), rz_socket_rap_server_continue(), and send_vcont().

rz_socket_listen()

RZ_API bool rz_socket_listen	(	RzSocket *	s,
		const char *	port,
		const char *	certfile
	)

Definition at line 474 of file socket.c.

                                                                                  {
    int optval = 1;
    int ret;
    struct linger linger = { 0 };
 
    if (s->proto == RZ_SOCKET_PROTO_UNIX) {
#if __UNIX__
        return __listen_unix(s, port);
#endif
        return false;
    }
 
#if __WINDOWS__
    WSADATA wsadata;
    if (WSAStartup(MAKEWORD(1, 1), &wsadata) == SOCKET_ERROR) {
        eprintf("Error creating socket.");
        return false;
    }
#endif
    if (s->proto == RZ_SOCKET_PROTO_NONE) {
        s->proto = RZ_SOCKET_PROTO_DEFAULT;
    }
    switch (s->proto) {
    case RZ_SOCKET_PROTO_TCP:
        if ((s->fd = socket(AF_INET, SOCK_STREAM, RZ_SOCKET_PROTO_TCP)) == RZ_INVALID_SOCKET) {
            return false;
        }
        break;
    case RZ_SOCKET_PROTO_UDP:
        if ((s->fd = socket(AF_INET, SOCK_DGRAM, RZ_SOCKET_PROTO_UDP)) == RZ_INVALID_SOCKET) {
            return false;
        }
        break;
    default:
        eprintf("Invalid protocol for socket\n");
        return false;
    }
 
    linger.l_onoff = 1;
    linger.l_linger = 1;
    ret = setsockopt(s->fd, SOL_SOCKET, SO_LINGER, (void *)&linger, sizeof(linger));
    if (ret < 0) {
        return false;
    }
    { // fix close after write bug //
        int x = 1500; // FORCE MTU
        ret = setsockopt(s->fd, SOL_SOCKET, SO_SNDBUF, (void *)&x, sizeof(int));
        if (ret < 0) {
            return false;
        }
    }
    ret = setsockopt(s->fd, SOL_SOCKET, SO_REUSEADDR, (void *)&optval, sizeof optval);
    if (ret < 0) {
        return false;
    }
 
    memset(&s->sa, 0, sizeof(s->sa));
    s->sa.sin_family = AF_INET;
    s->sa.sin_addr.s_addr = htonl(s->local ? INADDR_LOOPBACK : INADDR_ANY);
    s->port = rz_socket_port_by_name(port);
    if (s->port < 1) {
        return false;
    }
    s->sa.sin_port = htons(s->port); // TODO honor etc/services
    if (bind(s->fd, (struct sockaddr *)&s->sa, sizeof(s->sa)) < 0) {
        rz_sys_perror("bind");
#ifdef _MSC_VER
        closesocket(s->fd);
#else
        close(s->fd);
#endif
        return false;
    }
#if __UNIX__
    rz_sys_signal(SIGPIPE, SIG_IGN);
#endif
    if (s->proto == RZ_SOCKET_PROTO_TCP) {
        if (listen(s->fd, 32) < 0) {
            rz_sys_perror("listen");
#ifdef _MSC_VER
            closesocket(s->fd);
#else
            close(s->fd);
#endif
            return false;
        }
    }
#if HAVE_LIB_SSL
    if (s->is_ssl) {
        s->ctx = SSL_CTX_new(SSLv23_method());
        if (!s->ctx) {
            rz_socket_free(s);
            return false;
        }
        if (!SSL_CTX_use_certificate_chain_file(s->ctx, certfile)) {
            rz_socket_free(s);
            return false;
        }
        if (!SSL_CTX_use_PrivateKey_file(s->ctx, certfile, SSL_FILETYPE_PEM)) {
            rz_socket_free(s);
            return false;
        }
        SSL_CTX_set_verify_depth(s->ctx, 1);
    }
#endif
    return true;
}

References AF_INET, bind, close, eprintf, rz_socket_t::fd, htons, rz_socket_t::is_ssl, listen, rz_socket_t::local, memset(), rz_socket_t::port, rz_socket_t::proto, RZ_INVALID_SOCKET, rz_socket_free(), rz_socket_port_by_name(), RZ_SOCKET_PROTO_DEFAULT, RZ_SOCKET_PROTO_NONE, RZ_SOCKET_PROTO_TCP, RZ_SOCKET_PROTO_UDP, RZ_SOCKET_PROTO_UNIX, rz_sys_perror, rz_sys_signal(), s, in_addr::s_addr, rz_socket_t::sa, sockaddr_in::sin_addr, sockaddr_in::sin_port, SO_LINGER, SO_REUSEADDR, SO_SNDBUF, SOCK_DGRAM, SOCK_STREAM, socket, SOL_SOCKET, and x.

Referenced by __rap_open(), rz_core_rtr_cmds(), rz_core_rtr_gdb_run(), rz_core_rtr_http_run(), rz_main_rz_agent(), rz_run_config_env(), rz_socket_rap_server_listen(), rz_write_from_socket_handler(), and tcpme().

rz_socket_new()

RZ_API RzSocket* rz_socket_new

(

bool

is_ssl

)

Definition at line 179 of file socket.c.

                                            {
    RzSocket *s = RZ_NEW0(RzSocket);
    if (!s) {
        return NULL;
    }
    s->is_ssl = is_ssl;
    s->port = 0;
#if __UNIX_
    rz_sys_signal(SIGPIPE, SIG_IGN);
#endif
    s->local = 0;
    s->fd = RZ_INVALID_SOCKET;
#if HAVE_LIB_SSL
    if (is_ssl) {
        s->sfd = NULL;
        s->ctx = NULL;
        s->bio = NULL;
#if OPENSSL_VERSION_NUMBER < 0x1010000fL
        if (!SSL_library_init()) {
            rz_socket_free(s);
            return NULL;
        }
        SSL_load_error_strings();
#endif
    }
#endif
    return s;
}

References rz_socket_t::fd, rz_socket_t::is_ssl, rz_socket_t::local, NULL, rz_socket_t::port, RZ_INVALID_SOCKET, RZ_NEW0, rz_socket_free(), rz_sys_signal(), and s.

Referenced by __open(), __rap_open(), gdbr_init(), iob_net_open(), qnxr_connect(), rz_core_rtr_add(), rz_core_rtr_cmds(), rz_core_rtr_cmds_query(), rz_core_rtr_gdb_run(), rz_core_rtr_http_run(), rz_core_rtr_http_stop(), rz_main_rz_agent(), rz_run_config_env(), rz_socket_http_post(), rz_socket_rap_server_new(), rz_write_from_socket_handler(), socket_http_get_recursive(), and tcpme().

rz_socket_new_from_fd()

RZ_API RzSocket* rz_socket_new_from_fd

(

int

fd

)

Definition at line 859 of file socket.c.

                                               {
    RzSocket *s = RZ_NEW0(RzSocket);
    if (s) {
        s->fd = fd;
        s->proto = RZ_SOCKET_PROTO_DEFAULT;
    }
    return s;
}

References fd, rz_socket_t::fd, rz_socket_t::proto, RZ_NEW0, RZ_SOCKET_PROTO_DEFAULT, and s.

Referenced by __rap_accept().

rz_socket_port_by_name()

RZ_API int rz_socket_port_by_name

(

const char *

name

)

Definition at line 469 of file socket.c.

                                                    {
    struct servent *p = getservbyname(name, "tcp");
    return (p && p->s_port) ? ntohs(p->s_port) : rz_num_get(NULL, name);
}

References ntohs, NULL, p, and rz_num_get().

Referenced by rz_socket_connect(), and rz_socket_listen().

rz_socket_printf()

RZ_API void rz_socket_printf	(	RzSocket *	s,
		const char *	fmt,
			...
	)

Definition at line 772 of file socket.c.

                                                                {
    char buf[BUFFER_SIZE];
    va_list ap;
    if (s->fd != RZ_INVALID_SOCKET) {
        va_start(ap, fmt);
        vsnprintf(buf, BUFFER_SIZE, fmt, ap);
        (void)rz_socket_write(s, buf, strlen(buf));
        va_end(ap);
    }
}

References BUFFER_SIZE, rz_socket_t::fd, RZ_INVALID_SOCKET, rz_socket_write(), s, and vsnprintf.

rz_socket_puts()

RZ_API int rz_socket_puts	(	RzSocket *	s,
		char *	buf
	)

Definition at line 768 of file socket.c.

                                                  {
    return rz_socket_write(s, buf, strlen(buf));
}

References rz_socket_write(), and s.

rz_socket_read()

RZ_API int rz_socket_read	(	RzSocket *	s,
		unsigned char *	buf,
		int	len
	)

Definition at line 783 of file socket.c.

                                                                    {
    if (!s) {
        return -1;
    }
#if HAVE_LIB_SSL
    if (s->is_ssl) {
        if (s->bio) {
            return BIO_read(s->bio, buf, len);
        }
        return SSL_read(s->sfd, buf, len);
    }
#endif
    // int r = read (s->fd, buf, len);
    int r = recv(s->fd, (char *)buf, len, 0);
    D {
        eprintf("READ ");
        int i;
        for (i = 0; i < len; i++) {
            eprintf("%02x ", buf[i]);
        }
        eprintf("\n");
    }
    return r;
}

References D, eprintf, rz_socket_t::fd, i, rz_socket_t::is_ssl, len, r, and s.

Referenced by __rap_system(), iob_net_read(), qnxr_read_packet(), read_packet(), runcmd(), rz_core_rtr_cmds(), rz_core_rtr_cmds_query(), rz_socket_gets(), rz_socket_proc_read(), rz_socket_read_block(), rz_socket_slurp(), and rz_write_from_socket_handler().

rz_socket_read_block()

RZ_API int rz_socket_read_block	(	RzSocket *	s,
		ut8 *	buf,
		int	len
	)

Definition at line 808 of file socket.c.

                                                                {
    int ret = 0;
    for (ret = 0; ret < len;) {
        int r = rz_socket_read(s, buf + ret, len - ret);
        if (r == -1) {
#if HAVE_LIB_SSL
            if (s->is_ssl && SSL_get_error(s->sfd, r) == SSL_ERROR_WANT_READ) {
                if (rz_socket_ready(s, 1, 0) == 1) {
                    continue;
                }
            }
#endif
            return -1;
        }
        if (r < 1) {
            break;
        }
        ret += r;
    }
    return ret;
}

References rz_socket_t::is_ssl, len, r, rz_socket_read(), rz_socket_ready(), and s.

Referenced by __rap_system(), rz_core_rtr_cmd(), rz_core_serve(), rz_socket_http_accept(), rz_socket_rap_client_command(), rz_socket_rap_client_open(), rz_socket_rap_client_read(), rz_socket_rap_client_seek(), rz_socket_rap_client_write(), rz_socket_rap_server_continue(), socket_http_answer(), and socket_slurp().

rz_socket_ready()

RZ_API int rz_socket_ready	(	RzSocket *	s,
		int	secs,
		int	usecs
	)

Definition at line 688 of file socket.c.

                                                             {
    fd_set rfds;
    struct timeval tv = { secs, usecs };
    if (s->fd == RZ_INVALID_SOCKET) {
        return -1;
    }
    FD_ZERO(&rfds);
    FD_SET(s->fd, &rfds);
    return select(s->fd + 1, &rfds, NULL, NULL, &tv);
}

References rz_socket_t::fd, FD_SET, FD_ZERO, NULL, RZ_INVALID_SOCKET, s, select, and tv.

Referenced by qnxr_read_packet(), read_packet(), rz_socket_close(), rz_socket_http_accept(), rz_socket_proc_ready(), rz_socket_read_block(), and socket_slurp().

rz_socket_slurp()

RZ_API ut8* rz_socket_slurp	(	RzSocket *	s,
		int *	len
	)

Definition at line 868 of file socket.c.

                                                   {
    int blockSize = 4096;
    ut8 *ptr, *buf = malloc(blockSize);
    if (!buf) {
        return NULL;
    }
    int copied = 0;
    if (len) {
        *len = 0;
    }
    for (;;) {
        int rc = rz_socket_read(s, buf + copied, blockSize);
        if (rc > 0) {
            copied += rc;
        }
        ptr = realloc(buf, copied + blockSize);
        if (!ptr) {
            break;
        }
        buf = ptr;
        if (rc < 1) {
            break;
        }
    }
    if (copied == 0) {
        RZ_FREE(buf);
    }
    if (len) {
        *len = copied;
    }
    return buf;
}

References len, malloc(), NULL, realloc(), RZ_FREE, rz_socket_read(), and s.

Referenced by tcpme().

rz_socket_spawn()

RZ_API bool rz_socket_spawn	(	RzSocket *	s,
		const char *	cmd,
		unsigned int	timeout
	)

Definition at line 208 of file socket.c.

                                                                                {
    // XXX TODO: dont use sockets, we can achieve the same with pipes
    const int port = 2000 + rz_num_rand(2000);
    int childPid = rz_sys_fork();
    if (childPid == 0) {
        char *a = rz_str_replace(strdup(cmd), "\\", "\\\\", true);
        int res = rz_sys_cmdf("rz-run system=\"%s\" listen=%d", a, port);
        free(a);
#if 0
        // TODO: use the api
        char *profile = rz_str_newf (
                "system=%s\n"
                "listen=%d\n", cmd, port);
        RzRunProfile *rp = rz_run_new (profile);
        rz_run_start (rp);
        rz_run_free (rp);
        free (profile);
#endif
        if (res != 0) {
            eprintf("rz_socket_spawn: rz-run failed\n");
            exit(1);
        }
        eprintf("rz_socket_spawn: %s is dead\n", cmd);
        exit(0);
    }
    rz_sys_sleep(1);
    rz_sys_usleep(timeout);
 
    char aport[32];
    sprintf(aport, "%d", port);
    // redirect stdin/stdout/stderr
    bool sock = rz_socket_connect(s, "127.0.0.1", aport, RZ_SOCKET_PROTO_TCP, 2000);
    if (!sock) {
        return false;
    }
#if __UNIX__
    rz_sys_sleep(4);
    rz_sys_usleep(timeout);
 
    int status = 0;
    int ret = waitpid(childPid, &status, WNOHANG);
    if (ret != 0) {
        rz_socket_close(s);
        return false;
    }
#endif
    return true;
}

References a, cmd, eprintf, test-lz4-list::exit, free(), rp, rz_num_rand(), rz_run_free(), rz_run_new(), rz_run_start(), rz_socket_close(), rz_socket_connect(), RZ_SOCKET_PROTO_TCP, rz_str_newf(), rz_str_replace(), rz_sys_cmdf(), rz_sys_fork(), rz_sys_sleep(), rz_sys_usleep(), s, sprintf, status, strdup(), and timeout.

Referenced by __open().

rz_socket_to_string()

RZ_API char* rz_socket_to_string

(

RzSocket *

s

)

Definition at line 699 of file socket.c.

                                              {
#if __WINDOWS__
    return rz_str_newf("fd%d", (int)(size_t)s->fd);
#elif __UNIX__
    char *str = NULL;
    struct sockaddr sa;
    socklen_t sl = sizeof(sa);
    memset(&sa, 0, sizeof(sa));
    if (!getpeername(s->fd, &sa, &sl)) {
        struct sockaddr_in *sain = (struct sockaddr_in *)&sa;
        ut8 *a = (ut8 *)&(sain->sin_addr);
        if ((str = malloc(32))) {
            sprintf(str, "%d.%d.%d.%d:%d",
                a[0], a[1], a[2], a[3], ntohs(sain->sin_port));
        }
    } else {
        eprintf("getperrname: failed\n"); // rz_sys_perror ("getpeername");
    }
    return str;
#else
    return NULL;
#endif
}

References a, eprintf, rz_socket_t::fd, malloc(), memset(), ntohs, NULL, rz_str_newf(), s, sockaddr_in::sin_addr, sockaddr_in::sin_port, sprintf, and cmd_descs_generate::str.

Referenced by rz_core_rtr_http_run().

rz_socket_write()

RZ_API int rz_socket_write	(	RzSocket *	s,
		void *	buf,
		int	len
	)

Definition at line 724 of file socket.c.

                                                            {
    D {
        eprintf("WRITE ");
        int i;
        ut8 *b = buf;
        for (i = 0; i < len; i++) {
            eprintf("%02x ", b[i]);
        }
        eprintf("\n");
    }
    int ret, delta = 0;
#if __UNIX__
    rz_sys_signal(SIGPIPE, SIG_IGN);
#endif
    for (;;) {
        int b = 1500; // 65536; // Use MTU 1500?
        if (b > len) {
            b = len;
        }
#if HAVE_LIB_SSL
        if (s->is_ssl) {
            if (s->bio) {
                ret = BIO_write(s->bio, buf + delta, b);
            } else {
                ret = SSL_write(s->sfd, buf + delta, b);
            }
        } else
#endif
        {
            ret = send(s->fd, (char *)buf + delta, b, 0);
        }
        // if (ret == 0) return -1;
        if (ret < 1) {
            break;
        }
        if (ret == len) {
            return len;
        }
        delta += ret;
        len -= ret;
    }
    return (ret == -1) ? -1 : delta;
}

References b, D, delta, eprintf, rz_socket_t::fd, i, rz_socket_t::is_ssl, len, rz_sys_signal(), s, and send.

Referenced by __rap_system(), _sendResponsePacket(), iob_net_write(), qnxr_send_ch_debug(), qnxr_send_ch_reset(), qnxr_send_ch_text(), qnxr_send_nak(), qnxr_send_packet(), rz_core_rtr_cmd(), rz_core_rtr_cmds(), rz_core_rtr_cmds_query(), rz_core_rtr_pushout(), rz_core_serve(), rz_socket_http_post(), rz_socket_http_response(), rz_socket_printf(), rz_socket_proc_printf(), rz_socket_proc_write(), rz_socket_puts(), rz_socket_rap_client_command(), rz_socket_rap_client_open(), rz_socket_rap_client_read(), rz_socket_rap_client_seek(), rz_socket_rap_client_write(), rz_socket_rap_server_continue(), send_ack(), send_packet(), and send_vcont().