rz_socket.h File Reference

#include "rz_types.h"
#include "rz_bind.h"
#include "rz_list.h"

Go to the source code of this file.

Classes
struct	RzPipe
struct	rz_socket_t
struct	rz_socket_http_options
struct	rz_socket_proc_t
struct	rz_socket_http_request
struct	rz_socket_rap_server_t
struct	rz_run_profile_t

Macros
#define	MSG_DONTWAIT   0
#define	SD_RECEIVE   0
#define	SD_SEND   1
#define	SD_BOTH   2
#define	RZ_INVALID_SOCKET   -1
#define	RZ_SOCKET_PROTO_TCP   IPPROTO_TCP
#define	RZ_SOCKET_PROTO_UDP   IPPROTO_UDP
#define	RZ_SOCKET_PROTO_UNIX   0x1337
#define	RZ_SOCKET_PROTO_NONE   0
#define	RZ_SOCKET_PROTO_DEFAULT   RZ_SOCKET_PROTO_TCP
#define	rz_socket_connect_tcp(a, b, c, d)   rz_socket_connect(a, b, c, RZ_SOCKET_PROTO_TCP, d)
#define	rz_socket_connect_udp(a, b, c, d)   rz_socket_connect(a, b, c, RZ_SOCKET_PROTO_UDP, d)
#define	rz_socket_connect_unix(a, b)   (false)
#define	RZ_RUN_PROFILE_NARGS   512

Typedefs
typedef struct rz_socket_t	RzSocket
typedef struct rz_socket_http_options	RzSocketHTTPOptions
typedef struct rz_socket_proc_t	RzSocketProc
typedef struct rz_socket_http_request	RzSocketHTTPRequest
typedef int(*	rap_server_open) (void *user, const char *file, int flg, int mode)
typedef int(*	rap_server_seek) (void *user, ut64 offset, int whence)
typedef int(*	rap_server_read) (void *user, ut8 *buf, int len)
typedef int(*	rap_server_write) (void *user, ut8 *buf, int len)
typedef char *(*	rap_server_cmd) (void *user, const char *command)
typedef int(*	rap_server_close) (void *user, int fd)
typedef struct rz_socket_rap_server_t	RzSocketRapServer
typedef struct rz_run_profile_t	RzRunProfile

Enumerations
enum	{   RAP_PACKET_OPEN = 1 , RAP_PACKET_READ = 2 , RAP_PACKET_WRITE = 3 , RAP_PACKET_SEEK = 4 ,   RAP_PACKET_CLOSE = 5 , RAP_PACKET_CMD = 7 , RAP_PACKET_REPLY = 0x80 , RAP_PACKET_MAX = 4096 }

Functions
	RZ_LIB_VERSION_HEADER (rz_socket)
RZ_API RzSocket *	rz_socket_new_from_fd (int fd)
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_connect_serial (RzSocket *sock, const char *path, int speed, int parity)
RZ_API bool	rz_socket_listen (RzSocket *s, const char *port, const char *certfile)
RZ_API int	rz_socket_port_by_name (const char *name)
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 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_PRINTF_CHECK(2
RZ_API void RZ_API int	rz_socket_read (RzSocket *s, ut8 *read, int len)
RZ_API int	rz_socket_read_block (RzSocket *s, unsigned char *buf, int len)
RZ_API int	rz_socket_gets (RzSocket *s, char *buf, int size)
RZ_API ut8 *	rz_socket_slurp (RzSocket *s, int *len)
RZ_API bool	rz_socket_is_connected (RzSocket *)
RZ_API RzSocketProc *	rz_socket_proc_open (char *const argv[])
RZ_API int	rz_socket_proc_close (RzSocketProc *sp)
RZ_API int	rz_socket_proc_read (RzSocketProc *sp, unsigned char *buf, int len)
RZ_API int	rz_socket_proc_gets (RzSocketProc *sp, char *buf, int size)
RZ_API int	rz_socket_proc_write (RzSocketProc *sp, void *buf, int len)
RZ_API void	rz_socket_proc_printf (RzSocketProc *sp, const char *fmt,...) RZ_PRINTF_CHECK(2
RZ_API void RZ_API int	rz_socket_proc_ready (RzSocketProc *sp, int secs, int usecs)
RZ_API char *	rz_socket_http_get (const char *url, int *code, int *rlen)
RZ_API char *	rz_socket_http_post (const char *url, const char *data, int *code, int *rlen)
RZ_API void	rz_socket_http_server_set_breaked (bool *b)
RZ_API RzSocketHTTPRequest *	rz_socket_http_accept (RzSocket *s, RzSocketHTTPOptions *so)
RZ_API void	rz_socket_http_response (RzSocketHTTPRequest *rs, int code, const char *out, int x, const char *headers)
RZ_API void	rz_socket_http_close (RzSocketHTTPRequest *rs)
RZ_API ut8 *	rz_socket_http_handle_upload (const ut8 *str, int len, int *olen)
RZ_API RzSocketRapServer *	rz_socket_rap_server_new (bool is_ssl, const char *port)
RZ_API RzSocketRapServer *	rz_socket_rap_server_create (const char *pathname)
RZ_API void	rz_socket_rap_server_free (RzSocketRapServer *rap_s)
RZ_API bool	rz_socket_rap_server_listen (RzSocketRapServer *rap_s, const char *certfile)
RZ_API RzSocket *	rz_socket_rap_server_accept (RzSocketRapServer *rap_s)
RZ_API bool	rz_socket_rap_server_continue (RzSocketRapServer *rap_s)
RZ_API int	rz_socket_rap_client_open (RzSocket *s, const char *file, int rw)
RZ_API char *	rz_socket_rap_client_command (RzSocket *s, const char *cmd, RzCoreBind *c)
RZ_API int	rz_socket_rap_client_write (RzSocket *s, const ut8 *buf, int count)
RZ_API int	rz_socket_rap_client_read (RzSocket *s, ut8 *buf, int count)
RZ_API int	rz_socket_rap_client_seek (RzSocket *s, ut64 offset, int whence)
RZ_API RzRunProfile *	rz_run_new (const char *str)
RZ_API bool	rz_run_parse (RzRunProfile *pf, const char *profile)
RZ_API void	rz_run_free (RzRunProfile *r)
RZ_API bool	rz_run_parseline (RzRunProfile *p, const char *b)
RZ_API const char *	rz_run_help (void)
RZ_API int	rz_run_config_env (RzRunProfile *p)
RZ_API int	rz_run_start (RzRunProfile *p)
RZ_API void	rz_run_reset (RzRunProfile *p)
RZ_API bool	rz_run_parsefile (RzRunProfile *p, const char *b)
RZ_API char *	rz_run_get_environ_profile (char **env)
RZ_API int	rzpipe_write (RzPipe *rzpipe, const char *str)
RZ_API char *	rzpipe_read (RzPipe *rzpipe)
RZ_API int	rzpipe_close (RzPipe *rzpipe)
RZ_API RzPipe *	rzpipe_open_corebind (RzCoreBind *coreb)
RZ_API RzPipe *	rzpipe_open (const char *cmd)
RZ_API RzPipe *	rzpipe_open_dl (const char *file)
RZ_API char *	rzpipe_cmd (RzPipe *rzpipe, const char *str)
RZ_API char *	rzpipe_cmdf (RzPipe *rzpipe, const char *fmt,...) RZ_PRINTF_CHECK(2

Macro Definition Documentation

MSG_DONTWAIT

#define MSG_DONTWAIT   0

Definition at line 37 of file rz_socket.h.

RZ_INVALID_SOCKET

#define RZ_INVALID_SOCKET   -1

Definition at line 48 of file rz_socket.h.

RZ_RUN_PROFILE_NARGS

#define RZ_RUN_PROFILE_NARGS   512

Definition at line 211 of file rz_socket.h.

rz_socket_connect_tcp

#define rz_socket_connect_tcp	(		a,
			b,
			c,
			d
	)		rz_socket_connect(a, b, c, RZ_SOCKET_PROTO_TCP, d)

Definition at line 99 of file rz_socket.h.

rz_socket_connect_udp

#define rz_socket_connect_udp	(		a,
			b,
			c,
			d
	)		rz_socket_connect(a, b, c, RZ_SOCKET_PROTO_UDP, d)

Definition at line 100 of file rz_socket.h.

rz_socket_connect_unix

#define rz_socket_connect_unix	(		a,
			b
	)		(false)

Definition at line 104 of file rz_socket.h.

RZ_SOCKET_PROTO_DEFAULT

#define RZ_SOCKET_PROTO_DEFAULT   RZ_SOCKET_PROTO_TCP

Definition at line 91 of file rz_socket.h.

RZ_SOCKET_PROTO_NONE

#define RZ_SOCKET_PROTO_NONE   0

Definition at line 90 of file rz_socket.h.

RZ_SOCKET_PROTO_TCP

#define RZ_SOCKET_PROTO_TCP   IPPROTO_TCP

Definition at line 87 of file rz_socket.h.

RZ_SOCKET_PROTO_UDP

#define RZ_SOCKET_PROTO_UDP   IPPROTO_UDP

Definition at line 88 of file rz_socket.h.

RZ_SOCKET_PROTO_UNIX

#define RZ_SOCKET_PROTO_UNIX   0x1337

Definition at line 89 of file rz_socket.h.

SD_BOTH

#define SD_BOTH   2

Definition at line 42 of file rz_socket.h.

SD_RECEIVE

#define SD_RECEIVE   0

Definition at line 40 of file rz_socket.h.

SD_SEND

#define SD_SEND   1

Definition at line 41 of file rz_socket.h.

Typedef Documentation

rap_server_close

typedef int(* rap_server_close) (void *user, int fd)

Definition at line 168 of file rz_socket.h.

rap_server_cmd

typedef char*(* rap_server_cmd) (void *user, const char *command)

Definition at line 167 of file rz_socket.h.

rap_server_open

typedef int(* rap_server_open) (void *user, const char *file, int flg, int mode)

Definition at line 163 of file rz_socket.h.

rap_server_read

typedef int(* rap_server_read) (void *user, ut8 *buf, int len)

Definition at line 165 of file rz_socket.h.

rap_server_seek

typedef int(* rap_server_seek) (void *user, ut64 offset, int whence)

Definition at line 164 of file rz_socket.h.

rap_server_write

typedef int(* rap_server_write) (void *user, ut8 *buf, int len)

Definition at line 166 of file rz_socket.h.

RzRunProfile

typedef struct rz_run_profile_t RzRunProfile

RzSocket

typedef struct rz_socket_t RzSocket

RzSocketHTTPOptions

typedef struct rz_socket_http_options RzSocketHTTPOptions

RzSocketHTTPRequest

typedef struct rz_socket_http_request RzSocketHTTPRequest

RzSocketProc

typedef struct rz_socket_proc_t RzSocketProc

RzSocketRapServer

typedef struct rz_socket_rap_server_t RzSocketRapServer

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
RAP_PACKET_OPEN
RAP_PACKET_READ
RAP_PACKET_WRITE
RAP_PACKET_SEEK
RAP_PACKET_CLOSE
RAP_PACKET_CMD
RAP_PACKET_REPLY
RAP_PACKET_MAX

Definition at line 170 of file rz_socket.h.

     {
    RAP_PACKET_OPEN = 1,
    RAP_PACKET_READ = 2,
    RAP_PACKET_WRITE = 3,
    RAP_PACKET_SEEK = 4,
    RAP_PACKET_CLOSE = 5,
    // system was deprecated in slot 6,
    RAP_PACKET_CMD = 7,
    RAP_PACKET_REPLY = 0x80,
    RAP_PACKET_MAX = 4096
};

Function Documentation

RZ_LIB_VERSION_HEADER()

RZ_LIB_VERSION_HEADER

(

rz_socket

)

rz_run_config_env()

RZ_API int rz_run_config_env

(

RzRunProfile *

p

)

Definition at line 809 of file run.c.

                                              {
    int ret;
 
#if HAVE_OPENPTY && HAVE_FORKPTY && HAVE_LOGIN_TTY
    dyn_init();
#endif
 
    if (!p->_program && !p->_system && !p->_runlib) {
        eprintf("No program, system or runlib rule defined\n");
        return 1;
    }
    // when IO is redirected to a process, handle them together
    if (handle_redirection(p->_stdio, true, true, false) != 0) {
        return 1;
    }
    if (handle_redirection(p->_stdin, true, false, false) != 0) {
        return 1;
    }
    if (handle_redirection(p->_stdout, false, true, false) != 0) {
        return 1;
    }
    if (handle_redirection(p->_stderr, false, false, true) != 0) {
        return 1;
    }
    if (p->_aslr != -1) {
        setASLR(p, p->_aslr);
    }
#if __UNIX__
    set_limit(p->_docore, RLIMIT_CORE, RLIM_INFINITY);
    if (p->_maxfd) {
        set_limit(p->_maxfd, RLIMIT_NOFILE, p->_maxfd);
    }
#ifdef RLIMIT_NPROC
    if (p->_maxproc) {
        set_limit(p->_maxproc, RLIMIT_NPROC, p->_maxproc);
    }
#endif
    if (p->_maxstack) {
        set_limit(p->_maxstack, RLIMIT_STACK, p->_maxstack);
    }
#else
    if (p->_docore || p->_maxfd || p->_maxproc || p->_maxstack)
        eprintf("Warning: setrlimits not supported for this platform\n");
#endif
    if (p->_connect) {
        char *q = strchr(p->_connect, ':');
        if (q) {
            RzSocket *fd = rz_socket_new(0);
            *q = 0;
            if (!rz_socket_connect_tcp(fd, p->_connect, q + 1, 30)) {
                eprintf("Cannot connect\n");
                return 1;
            }
            if (p->_pty) {
                if (redirect_socket_to_pty(fd) != 0) {
                    eprintf("socket redirection failed\n");
                    rz_socket_free(fd);
                    return 1;
                }
            } else {
                redirect_socket_to_stdio(fd);
            }
        } else {
            eprintf("Invalid format for connect. missing ':'\n");
            return 1;
        }
    }
    if (p->_listen) {
        RzSocket *child, *fd = rz_socket_new(0);
        bool is_child = false;
        if (!rz_socket_listen(fd, p->_listen, NULL)) {
            eprintf("rz-run: cannot listen\n");
            rz_socket_free(fd);
            return 1;
        }
        while (true) {
            child = rz_socket_accept(fd);
            if (child) {
                is_child = true;
 
                if (p->_dofork && !p->_dodebug) {
                    pid_t child_pid = rz_sys_fork();
                    if (child_pid == -1) {
                        eprintf("rz-run: cannot fork\n");
                        rz_socket_free(child);
                        rz_socket_free(fd);
                        return 1;
                    } else if (child_pid != 0) {
                        // parent code
                        is_child = false;
                    }
                }
 
                if (is_child) {
                    rz_socket_close_fd(fd);
                    eprintf("connected\n");
                    if (p->_pty) {
                        if (redirect_socket_to_pty(child) != 0) {
                            eprintf("socket redirection failed\n");
                            rz_socket_free(child);
                            rz_socket_free(fd);
                            return 1;
                        }
                    } else {
                        redirect_socket_to_stdio(child);
                    }
                    break;
                } else {
                    rz_socket_close_fd(child);
                }
            }
        }
        if (!is_child) {
            rz_socket_free(child);
        }
        rz_socket_free(fd);
    }
    if (p->_rzsleep != 0) {
        rz_sys_sleep(p->_rzsleep);
    }
#if __UNIX__
    if (p->_chroot) {
        if (chdir(p->_chroot) == -1) {
            eprintf("Cannot chdir to chroot in %s\n", p->_chroot);
            return 1;
        } else {
            if (chroot(".") == -1) {
                eprintf("Cannot chroot to %s\n", p->_chroot);
                return 1;
            } else {
                // Silenting pedantic meson flags...
                if (chdir("/") == -1) {
                    eprintf("Cannot chdir to /\n");
                    return 1;
                }
                if (p->_chgdir) {
                    if (chdir(p->_chgdir) == -1) {
                        eprintf("Cannot chdir after chroot to %s\n", p->_chgdir);
                        return 1;
                    }
                }
            }
        }
    } else if (p->_chgdir) {
        if (chdir(p->_chgdir) == -1) {
            eprintf("Cannot chdir after chroot to %s\n", p->_chgdir);
            return 1;
        }
    }
#else
    if (p->_chgdir) {
        ret = chdir(p->_chgdir);
        if (ret < 0) {
            return 1;
        }
    }
    if (p->_chroot) {
        ret = chdir(p->_chroot);
        if (ret < 0) {
            return 1;
        }
    }
#endif
#if __UNIX__
    if (p->_setuid) {
        ret = setgroups(0, NULL);
        if (ret < 0) {
            return 1;
        }
        ret = setuid(atoi(p->_setuid));
        if (ret < 0) {
            return 1;
        }
    }
    if (p->_seteuid) {
        ret = seteuid(atoi(p->_seteuid));
        if (ret < 0) {
            return 1;
        }
    }
    if (p->_setgid) {
        ret = setgid(atoi(p->_setgid));
        if (ret < 0) {
            return 1;
        }
    }
    if (p->_input) {
        char *inp;
        int f2[2];
        if (rz_sys_pipe(f2, true) != -1) {
            close(0);
            dup2(f2[0], 0);
        } else {
            eprintf("[ERROR] rz-run: Cannot create pipe\n");
            return 1;
        }
        inp = getstr(p->_input);
        if (inp) {
            size_t inpl = strlen(inp);
            if (write(f2[1], inp, inpl) != inpl) {
                eprintf("[ERROR] rz-run: Cannot write to the pipe\n");
            }
            rz_sys_pipe_close(f2[1]);
            free(inp);
        } else {
            eprintf("Invalid input\n");
        }
    }
#endif
    if (p->_rzpreload) {
        if (p->_preload) {
            eprintf("WARNING: Only one library can be opened at a time\n");
        }
        char *libdir = rz_path_libdir();
        p->_preload = rz_file_path_join(libdir, "librz." RZ_LIB_EXT);
        free(libdir);
    }
    if (p->_libpath) {
#if __WINDOWS__
        eprintf("rz-run: libpath unsupported for this platform\n");
#elif __HAIKU__
        char *orig = rz_sys_getenv("LIBRARY_PATH");
        char *newlib = rz_str_newf("%s:%s", p->_libpath, orig);
        rz_sys_setenv("LIBRARY_PATH", newlib);
        free(newlib);
        free(orig);
#elif __APPLE__
        rz_sys_setenv("DYLD_LIBRARY_PATH", p->_libpath);
#else
        rz_sys_setenv("LD_LIBRARY_PATH", p->_libpath);
#endif
    }
    if (p->_preload) {
#if __APPLE__
        // 10.6
#ifndef __MAC_10_7
        rz_sys_setenv("DYLD_PRELOAD", p->_preload);
#endif
        rz_sys_setenv("DYLD_INSERT_LIBRARIES", p->_preload);
        // 10.8
        rz_sys_setenv("DYLD_FORCE_FLAT_NAMESPACE", "1");
#else
        rz_sys_setenv("LD_PRELOAD", p->_preload);
#endif
    }
    if (p->_timeout) {
#if __UNIX__
        int mypid = getpid();
        if (!rz_sys_fork()) {
            int use_signal = p->_timeout_sig;
            if (use_signal < 1) {
                use_signal = SIGKILL;
            }
            sleep(p->_timeout);
            if (!kill(mypid, 0)) {
                // eprintf ("\nrz_run: Interrupted by timeout\n");
            }
            kill(mypid, use_signal);
            exit(0);
        }
#else
        if (p->_timeout_sig < 1 || p->_timeout_sig == 9) {
            rz_th_new(exit_process, (void *)p->_timeout);
        } else {
            eprintf("timeout with signal not supported for this platform\n");
        }
#endif
    }
    return 0;
}

References chdir, chroot, close, dup2, eprintf, test-lz4-list::exit, autogen_x86imm::f2, fd, free(), getstr(), handle_redirection(), kill, NULL, p, redirect_socket_to_pty(), redirect_socket_to_stdio(), rz_file_path_join(), RZ_LIB_EXT, rz_path_libdir(), rz_socket_accept(), rz_socket_close_fd(), rz_socket_connect_tcp, rz_socket_free(), rz_socket_listen(), rz_socket_new(), rz_str_newf(), rz_sys_fork(), rz_sys_getenv(), rz_sys_pipe(), rz_sys_pipe_close(), rz_sys_setenv(), rz_sys_sleep(), rz_th_new(), setASLR(), setgid, setgroups, SIGKILL, and write.

Referenced by rz_main_rz_run().

rz_run_free()

RZ_API void rz_run_free

(

RzRunProfile *

r

)

Definition at line 122 of file run.c.

                                         {
    if (r) {
        free(r->_system);
        free(r->_program);
        free(r->_runlib);
        free(r->_runlib_fcn);
        free(r->_stdio);
        free(r->_stdin);
        free(r->_stdout);
        free(r->_stderr);
        free(r->_chgdir);
        free(r->_chroot);
        free(r->_libpath);
        free(r->_preload);
        free(r);
    }
}

References free(), and r.

Referenced by rz_main_rz_run(), and rz_socket_spawn().

rz_run_get_environ_profile()

RZ_API char* rz_run_get_environ_profile

(

char **

env

)

Definition at line 1329 of file run.c.

                                                    {
    if (!env) {
        return NULL;
    }
    RzStrBuf *sb = rz_strbuf_new(NULL);
    while (*env) {
        char *k = strdup(*env);
        char *v = strchr(k, '=');
        if (v) {
            *v++ = 0;
            RzStrEscOptions opt = { 0 };
            opt.show_asciidot = false;
            opt.esc_bslash = true;
            v = rz_str_escape_8bit(v, true, &opt);
            if (v) {
                rz_strbuf_appendf(sb, "setenv=%s=\"%s\"\n", k, v);
                free(v);
            }
        }
        free(k);
        env++;
    }
    return rz_strbuf_drain(sb);
}

References env, RzStrEscOptions::esc_bslash, free(), k, NULL, rz_str_escape_8bit(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), sb, RzStrEscOptions::show_asciidot, strdup(), and v.

Referenced by rz_main_rizin().

rz_run_help()

RZ_API const char* rz_run_help

(

void

)

Definition at line 630 of file run.c.

                                     {
    return "program=/bin/ls\n"
           "arg1=/bin\n"
           "# arg2=hello\n"
           "# arg3=\"hello\\nworld\"\n"
           "# arg4=:048490184058104849\n"
           "# arg5=:!rz-gg -p n50 -d 10:0x8048123\n"
           "# arg6=@arg.txt\n"
           "# arg7=@300@ABCD # 300 chars filled with ABCD pattern\n"
           "# system=rizin -\n"
           "# daemon=false\n"
           "# aslr=no\n"
           "setenv=FOO=BAR\n"
           "# unsetenv=FOO\n"
           "# clearenv=true\n"
           "# envfile=environ.txt\n"
           "timeout=3\n"
           "# timeoutsig=SIGTERM # or 15\n"
           "# connect=localhost:8080\n"
           "# listen=8080\n"
           "# pty=false\n"
           "# fork=true\n"
           "# bits=32\n"
           "# pid=0\n"
           "# pidfile=/tmp/foo.pid\n"
           "# #sleep=0\n"
           "# #maxfd=0\n"
           "# #execve=false\n"
           "# #maxproc=0\n"
           "# #maxstack=0\n"
           "# #core=false\n"
           "# #stdio=blah.txt\n"
           "# #stderr=foo.txt\n"
           "# stdout=foo.txt\n"
           "# stdin=input.txt # or !program to redirect input from another program\n"
           "# input=input.txt\n"
           "# chdir=/\n"
           "# chroot=/mnt/chroot\n"
           "# libpath=$PWD:/tmp/lib\n"
           "# rzpreload=yes\n"
           "# preload=/lib/libfoo.so\n"
           "# setuid=2000\n"
           "# seteuid=2000\n"
           "# setgid=2001\n"
           "# setegid=2001\n"
           "# nice=5\n";
}

Referenced by rz_main_rz_run().

rz_run_new()

RZ_API RzRunProfile* rz_run_new

(

const char *

str

)

Definition at line 86 of file run.c.

                                                 {
    RzRunProfile *p = RZ_NEW0(RzRunProfile);
    if (p) {
        rz_run_reset(p);
        if (str) {
            rz_run_parsefile(p, str);
        }
    }
    return p;
}

References p, RZ_NEW0, rz_run_parsefile(), rz_run_reset(), and cmd_descs_generate::str.

Referenced by rz_main_rz_run(), and rz_socket_spawn().

rz_run_parse()

RZ_API bool rz_run_parse	(	RzRunProfile *	pf,
		const char *	profile
	)

Definition at line 103 of file run.c.

                                                                {
    rz_return_val_if_fail(pf && profile, false);
    char *p, *o, *str = strdup(profile);
    if (!str) {
        return false;
    }
    rz_str_replace_char(str, '\r', 0);
    p = str;
    while (p) {
        if ((o = strchr(p, '\n'))) {
            *o++ = 0;
        }
        rz_run_parseline(pf, p);
        p = o;
    }
    free(str);
    return true;
}

References free(), p, rz_return_val_if_fail, rz_run_parseline(), rz_str_replace_char(), cmd_descs_generate::str, and strdup().

Referenced by rz_run_parsefile().

rz_run_parsefile()

RZ_API bool rz_run_parsefile	(	RzRunProfile *	p,
		const char *	b
	)

Definition at line 468 of file run.c.

                                                             {
    rz_return_val_if_fail(p && b, false);
    char *s = rz_file_slurp(b, NULL);
    if (s) {
        bool ret = rz_run_parse(p, s);
        free(s);
        return ret;
    }
    return 0;
}

References b, free(), NULL, p, rz_file_slurp(), rz_return_val_if_fail, rz_run_parse(), and s.

Referenced by rz_run_new().

rz_run_parseline()

RZ_API bool rz_run_parseline	(	RzRunProfile *	p,
		const char *	b
	)

Definition at line 479 of file run.c.

                                                             {
    int must_free = false;
    char *e = strchr(b, '=');
    if (!e || *b == '#') {
        return 0;
    }
    *e++ = 0;
    if (*e == '$') {
        must_free = true;
        e = rz_sys_getenv(e);
    }
    if (!e) {
        return 0;
    }
    if (!strcmp(b, "program")) {
        p->_args[0] = p->_program = strdup(e);
    } else if (!strcmp(b, "daemon")) {
        p->_daemon = true;
    } else if (!strcmp(b, "system")) {
        p->_system = strdup(e);
    } else if (!strcmp(b, "runlib")) {
        p->_runlib = strdup(e);
    } else if (!strcmp(b, "runlib.fcn")) {
        p->_runlib_fcn = strdup(e);
    } else if (!strcmp(b, "aslr")) {
        p->_aslr = parseBool(e);
    } else if (!strcmp(b, "pid")) {
        p->_pid = parseBool(e);
    } else if (!strcmp(b, "pidfile")) {
        p->_pidfile = strdup(e);
    } else if (!strcmp(b, "connect")) {
        p->_connect = strdup(e);
    } else if (!strcmp(b, "listen")) {
        p->_listen = strdup(e);
    } else if (!strcmp(b, "pty")) {
        p->_pty = parseBool(e);
    } else if (!strcmp(b, "stdio")) {
        if (e[0] == '!') {
            p->_stdio = strdup(e);
        } else {
            p->_stdout = strdup(e);
            p->_stderr = strdup(e);
            p->_stdin = strdup(e);
        }
    } else if (!strcmp(b, "stdout")) {
        p->_stdout = strdup(e);
    } else if (!strcmp(b, "stdin")) {
        p->_stdin = strdup(e);
    } else if (!strcmp(b, "stderr")) {
        p->_stderr = strdup(e);
    } else if (!strcmp(b, "input")) {
        p->_input = strdup(e);
    } else if (!strcmp(b, "chdir")) {
        p->_chgdir = strdup(e);
    } else if (!strcmp(b, "core")) {
        p->_docore = parseBool(e);
    } else if (!strcmp(b, "fork")) {
        p->_dofork = parseBool(e);
    } else if (!strcmp(b, "sleep")) {
        p->_rzsleep = atoi(e);
    } else if (!strcmp(b, "maxstack")) {
        p->_maxstack = atoi(e);
    } else if (!strcmp(b, "maxproc")) {
        p->_maxproc = atoi(e);
    } else if (!strcmp(b, "maxfd")) {
        p->_maxfd = atoi(e);
    } else if (!strcmp(b, "bits")) {
        p->_bits = atoi(e);
    } else if (!strcmp(b, "chroot")) {
        p->_chroot = strdup(e);
    } else if (!strcmp(b, "libpath")) {
        p->_libpath = strdup(e);
    } else if (!strcmp(b, "preload")) {
        p->_preload = strdup(e);
    } else if (!strcmp(b, "rzpreload")) {
        p->_rzpreload = parseBool(e);
    } else if (!strcmp(b, "rzpreweb")) {
        rz_sys_setenv("RZ_RUN_WEB", "yes");
    } else if (!strcmp(b, "setuid")) {
        p->_setuid = strdup(e);
    } else if (!strcmp(b, "seteuid")) {
        p->_seteuid = strdup(e);
    } else if (!strcmp(b, "setgid")) {
        p->_setgid = strdup(e);
    } else if (!strcmp(b, "setegid")) {
        p->_setegid = strdup(e);
    } else if (!strcmp(b, "nice")) {
        p->_nice = atoi(e);
    } else if (!strcmp(b, "timeout")) {
        p->_timeout = atoi(e);
    } else if (!strcmp(b, "timeoutsig")) {
        p->_timeout_sig = rz_signal_from_string(e);
    } else if (!memcmp(b, "arg", 3)) {
        int n = atoi(b + 3);
        if (n >= 0 && n < RZ_RUN_PROFILE_NARGS) {
            p->_args[n] = getstr(e);
            p->_argc++;
        } else {
            eprintf("Out of bounds args index: %d\n", n);
        }
    } else if (!strcmp(b, "envfile")) {
        char *p, buf[1024];
        size_t len;
        FILE *fd = rz_sys_fopen(e, "r");
        if (!fd) {
            eprintf("Cannot open '%s'\n", e);
            if (must_free == true) {
                free(e);
            }
            return false;
        }
        for (;;) {
            if (!fgets(buf, sizeof(buf), fd)) {
                break;
            }
            if (feof(fd)) {
                break;
            }
            p = strchr(buf, '=');
            if (p) {
                *p++ = 0;
                len = strlen(p);
                if (len > 0 && p[len - 1] == '\n') {
                    p[len - 1] = 0;
                }
                if (len > 1 && p[len - 2] == '\r') {
                    p[len - 2] = 0;
                }
                rz_sys_setenv(buf, p);
            }
        }
        fclose(fd);
    } else if (!strcmp(b, "unsetenv")) {
        rz_sys_setenv(e, NULL);
    } else if (!strcmp(b, "setenv")) {
        char *V, *v = strchr(e, '=');
        if (v) {
            *v++ = 0;
            V = getstr(v);
            rz_sys_setenv(e, V);
            free(V);
        }
    } else if (!strcmp(b, "clearenv")) {
        rz_sys_clearenv();
    }
    if (must_free == true) {
        free(e);
    }
    return true;
}

References b, e, eprintf, fd, benchmark::FILE, free(), getstr(), len, n, NULL, p, parseBool(), RZ_RUN_PROFILE_NARGS, rz_signal_from_string(), rz_sys_clearenv(), rz_sys_fopen(), rz_sys_getenv(), rz_sys_setenv(), strdup(), v, and V.

Referenced by rz_main_rz_run(), and rz_run_parse().

rz_run_reset()

RZ_API void rz_run_reset

(

RzRunProfile *

p

)

Definition at line 97 of file run.c.

                                          {
    rz_return_if_fail(p);
    memset(p, 0, sizeof(RzRunProfile));
    p->_aslr = -1;
}

References memset(), p, and rz_return_if_fail.

Referenced by rz_run_new().

rz_run_start()

RZ_API int rz_run_start

(

RzRunProfile *

p

)

Definition at line 1081 of file run.c.

                                         {
#if HAVE_EXECVE
    if (p->_execve) {
        exit(rz_sys_execv(p->_program, (char *const *)p->_args));
    }
#endif
#if __APPLE__ && HAVE_FORK
    posix_spawnattr_t attr = { 0 };
    pid_t pid = -1;
    int ret;
    posix_spawnattr_init(&attr);
    if (p->_args[0]) {
        char **envp = rz_sys_get_environ();
        ut32 spflags = 0; // POSIX_SPAWN_START_SUSPENDED;
        spflags |= POSIX_SPAWN_SETEXEC;
        if (p->_aslr == 0) {
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
            spflags |= _POSIX_SPAWN_DISABLE_ASLR;
        }
        (void)posix_spawnattr_setflags(&attr, spflags);
        if (p->_bits) {
            size_t copied = 1;
            cpu_type_t cpu;
#if __i386__ || __x86_64__
            cpu = CPU_TYPE_I386;
            if (p->_bits == 64) {
                cpu |= CPU_ARCH_ABI64;
            }
#else
            cpu = CPU_TYPE_ANY;
#endif
            posix_spawnattr_setbinpref_np(
                &attr, 1, &cpu, &copied);
        }
        ret = posix_spawnp(&pid, p->_args[0],
            NULL, &attr, p->_args, envp);
        switch (ret) {
        case 0:
            break;
        default:
            eprintf("posix_spawnp: %s\n", strerror(ret));
            break;
        }
        exit(ret);
    }
#endif
    if (p->_system) {
        if (p->_pid) {
            eprintf("PID: Cannot determine pid with 'system' directive. Use 'program'.\n");
        }
        if (p->_daemon) {
#if __WINDOWS__
            //      eprintf ("PID: Cannot determine pid with 'system' directive. Use 'program'.\n");
#else
            pid_t child = rz_sys_fork();
            if (child == -1) {
                perror("fork");
                exit(1);
            }
            if (child) {
                if (p->_pidfile) {
                    char pidstr[32];
                    snprintf(pidstr, sizeof(pidstr), "%d\n", child);
                    rz_file_dump(p->_pidfile,
                        (const ut8 *)pidstr,
                        strlen(pidstr), 0);
                }
                exit(0);
            }
            setsid();
            if (p->_timeout) {
#if __UNIX__
                int mypid = getpid();
                if (!rz_sys_fork()) {
                    int use_signal = p->_timeout_sig;
                    if (use_signal < 1) {
                        use_signal = SIGKILL;
                    }
                    sleep(p->_timeout);
                    if (!kill(mypid, 0)) {
                        // eprintf ("\nrz_run: Interrupted by timeout\n");
                    }
                    kill(mypid, use_signal);
                    exit(0);
                }
#else
                eprintf("timeout not supported for this platform\n");
#endif
            }
#endif
#if __UNIX__
            close(0);
            close(1);
            char *bin_sh = rz_file_binsh();
            int ret = rz_sys_execl(bin_sh, "sh", "-c", p->_system, NULL);
            free(bin_sh);
            exit(ret);
#else
            exit(rz_sys_system(p->_system));
#endif
        } else {
            if (p->_pidfile) {
                eprintf("Warning: pidfile doesnt work with 'system'.\n");
            }
            exit(rz_sys_system(p->_system));
        }
    }
    if (p->_program) {
        if (!rz_file_exists(p->_program)) {
            char *progpath = rz_file_path(p->_program);
            if (progpath && *progpath) {
                free(p->_program);
                p->_program = progpath;
            } else {
                free(progpath);
                eprintf("rz-run: %s: file not found\n", p->_program);
                return 1;
            }
        }
#if __UNIX__
        // XXX HACK close all non-tty fds
        {
            int i;
            for (i = 3; i < 1024; i++) {
                close(i);
            }
        }
        // TODO: use posix_spawn
        if (p->_setgid) {
            int ret = setgid(atoi(p->_setgid));
            if (ret < 0) {
                return 1;
            }
        }
        if (p->_pid) {
            eprintf("PID: %d\n", getpid());
        }
        if (p->_pidfile) {
            char pidstr[32];
            snprintf(pidstr, sizeof(pidstr), "%d\n", getpid());
            rz_file_dump(p->_pidfile,
                (const ut8 *)pidstr,
                strlen(pidstr), 0);
        }
#endif
 
        if (p->_nice) {
#if HAVE_NICE
            if (nice(p->_nice) == -1) {
                return 1;
            }
#else
            eprintf("nice not supported for this platform\n");
#endif
        }
        if (p->_daemon) {
#if __WINDOWS__
            eprintf("PID: Cannot determine pid with 'system' directive. Use 'program'.\n");
#else
            pid_t child = rz_sys_fork();
            if (child == -1) {
                perror("fork");
                exit(1);
            }
            if (child) {
                if (p->_pidfile) {
                    char pidstr[32];
                    snprintf(pidstr, sizeof(pidstr), "%d\n", child);
                    rz_file_dump(p->_pidfile,
                        (const ut8 *)pidstr,
                        strlen(pidstr), 0);
                    exit(0);
                }
            }
            setsid();
#if HAVE_EXECVE
            exit(rz_sys_execv(p->_program, (char *const *)p->_args));
#endif
#endif
        }
#if HAVE_EXECVE
        exit(rz_sys_execv(p->_program, (char *const *)p->_args));
#endif
    }
    if (p->_runlib) {
        if (!p->_runlib_fcn) {
            eprintf("No function specified. Please set runlib.fcn\n");
            return 1;
        }
        void *addr = rz_lib_dl_open(p->_runlib);
        if (!addr) {
            eprintf("Could not load the library '%s'\n", p->_runlib);
            return 1;
        }
        void (*fcn)(void) = rz_lib_dl_sym(addr, p->_runlib_fcn);
        if (!fcn) {
            eprintf("Could not find the function '%s'\n", p->_runlib_fcn);
            return 1;
        }
        switch (p->_argc) {
        case 0:
            fcn();
            break;
        case 1:
            rz_run_call1(fcn, p->_args[1]);
            break;
        case 2:
            rz_run_call2(fcn, p->_args[1], p->_args[2]);
            break;
        case 3:
            rz_run_call3(fcn, p->_args[1], p->_args[2], p->_args[3]);
            break;
        case 4:
            rz_run_call4(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4]);
            break;
        case 5:
            rz_run_call5(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4],
                p->_args[5]);
            break;
        case 6:
            rz_run_call6(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4],
                p->_args[5], p->_args[6]);
            break;
        case 7:
            rz_run_call7(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4],
                p->_args[5], p->_args[6], p->_args[7]);
            break;
        case 8:
            rz_run_call8(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4],
                p->_args[5], p->_args[6], p->_args[7], p->_args[8]);
            break;
        case 9:
            rz_run_call9(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4],
                p->_args[5], p->_args[6], p->_args[7], p->_args[8], p->_args[9]);
            break;
        case 10:
            rz_run_call10(fcn, p->_args[1], p->_args[2], p->_args[3], p->_args[4],
                p->_args[5], p->_args[6], p->_args[7], p->_args[8], p->_args[9], p->_args[10]);
            break;
        default:
            eprintf("Too many arguments.\n");
            return 1;
        }
        rz_lib_dl_close(addr);
    }
    return 0;
}

References addr, close, cpu, CPU_ARCH_ABI64, CPU_TYPE_ANY, CPU_TYPE_I386, eprintf, test-lz4-list::exit, free(), i, kill, nice, NULL, p, pid, rz_file_binsh(), rz_file_dump(), rz_file_exists(), rz_file_path(), rz_lib_dl_close(), rz_lib_dl_open(), rz_lib_dl_sym(), rz_run_call1(), rz_run_call10(), rz_run_call2(), rz_run_call3(), rz_run_call4(), rz_run_call5(), rz_run_call6(), rz_run_call7(), rz_run_call8(), rz_run_call9(), rz_sys_execl(), rz_sys_execv(), rz_sys_fork(), rz_sys_get_environ(), rz_sys_system(), setgid, SIGKILL, and snprintf.

Referenced by rz_main_rz_run(), and rz_socket_spawn().

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_connect_serial()

RZ_API int rz_socket_connect_serial	(	RzSocket *	sock,
		const char *	path,
		int	speed,
		int	parity
	)

Definition at line 63 of file socket_serial.c.

                                                                                             {
    return -1;
}

Referenced by gdbr_connect().

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_http_accept()

RZ_API RzSocketHTTPRequest* rz_socket_http_accept	(	RzSocket *	s,
		RzSocketHTTPOptions *	so
	)

Definition at line 13 of file socket_http_server.c.

                                                                                        {
    int content_length = 0, xx, yy;
    int pxx = 1, first = 0;
    char buf[1500], *p, *q;
    RzSocketHTTPRequest *hr = RZ_NEW0(RzSocketHTTPRequest);
    if (!hr) {
        return NULL;
    }
    if (so->accept_timeout) {
        hr->s = rz_socket_accept_timeout(s, 1);
    } else {
        hr->s = rz_socket_accept(s);
    }
    if (!hr->s) {
        free(hr);
        return NULL;
    }
    if (so->timeout > 0) {
        rz_socket_block_time(hr->s, true, so->timeout, 0);
    }
    hr->auth = !so->httpauth;
    for (;;) {
#if __WINDOWS__
        if (breaked && *breaked) {
            rz_socket_http_close(hr);
            return NULL;
        }
#endif
        memset(buf, 0, sizeof(buf));
        xx = rz_socket_gets(hr->s, buf, sizeof(buf));
        yy = rz_socket_ready(hr->s, 0, 20 * 1000); // this function uses usecs as argument
        //      eprintf ("READ %d (%s) READY %d\n", xx, buf, yy);
        if (!yy || (!xx && !pxx)) {
            break;
        }
        pxx = xx;
 
        if (first == 0) {
            first = 1;
            if (strlen(buf) < 3) {
                rz_socket_http_close(hr);
                return NULL;
            }
            p = strchr(buf, ' ');
            if (p) {
                *p = 0;
            }
            hr->method = strdup(buf);
            if (p) {
                q = strstr(p + 1, " HTTP"); // strchr (p+1, ' ');
                if (q) {
                    *q = 0;
                }
                hr->path = strdup(p + 1);
            }
        } else {
            if (!hr->referer && !strncmp(buf, "Referer: ", 9)) {
                hr->referer = strdup(buf + 9);
            } else if (!hr->agent && !strncmp(buf, "User-Agent: ", 12)) {
                hr->agent = strdup(buf + 12);
            } else if (!hr->host && !strncmp(buf, "Host: ", 6)) {
                hr->host = strdup(buf + 6);
            } else if (!strncmp(buf, "Content-Length: ", 16)) {
                content_length = atoi(buf + 16);
            } else if (so->httpauth && !strncmp(buf, "Authorization: Basic ", 21)) {
                char *authtoken = buf + 21;
                size_t authlen = strlen(authtoken);
                char *curauthtoken;
                RzListIter *iter;
                char *decauthtoken = calloc(4, authlen + 1);
                if (!decauthtoken) {
                    eprintf("Could not allocate decoding buffer\n");
                    return hr;
                }
 
                if (rz_base64_decode((ut8 *)decauthtoken, authtoken, authlen) == -1) {
                    eprintf("Could not decode authorization token\n");
                } else {
                    rz_list_foreach (so->authtokens, iter, curauthtoken) {
                        if (!strcmp(decauthtoken, curauthtoken)) {
                            hr->auth = true;
                            break;
                        }
                    }
                }
 
                free(decauthtoken);
 
                if (!hr->auth) {
                    eprintf("Failed attempt login from '%s'\n", hr->host);
                }
            }
        }
    }
    if (content_length > 0) {
        rz_socket_read_block(hr->s, (ut8 *)buf, 1); // one missing byte
        if (ST32_ADD_OVFCHK(content_length, 1)) {
            rz_socket_http_close(hr);
            eprintf("Could not allocate hr data\n");
            return NULL;
        }
        hr->data = malloc(content_length + 1);
        hr->data_length = content_length;
        rz_socket_read_block(hr->s, hr->data, hr->data_length);
        hr->data[content_length] = 0;
    }
    return hr;
}

References rz_socket_http_options::accept_timeout, rz_socket_http_request::agent, rz_socket_http_request::auth, rz_socket_http_options::authtokens, breaked, calloc(), rz_socket_http_request::data, rz_socket_http_request::data_length, eprintf, free(), rz_socket_http_request::host, rz_socket_http_options::httpauth, malloc(), memset(), rz_socket_http_request::method, NULL, p, rz_socket_http_request::path, rz_socket_http_request::referer, rz_base64_decode(), RZ_NEW0, rz_socket_accept(), rz_socket_accept_timeout(), rz_socket_block_time(), rz_socket_gets(), rz_socket_http_close(), rz_socket_read_block(), rz_socket_ready(), s, rz_socket_http_request::s, ST32_ADD_OVFCHK, strdup(), and rz_socket_http_options::timeout.

Referenced by rz_core_rtr_http_run(), and rz_main_rz_agent().

rz_socket_http_close()

RZ_API void rz_socket_http_close

(

RzSocketHTTPRequest *

rs

)

Definition at line 191 of file socket_http_server.c.

                                                          {
    rz_socket_free(rs->s);
    free(rs->path);
    free(rs->host);
    free(rs->agent);
    free(rs->method);
    free(rs->data);
    free(rs);
}

References free(), rs, and rz_socket_free().

Referenced by rz_core_rtr_http_run(), rz_main_rz_agent(), and rz_socket_http_accept().

rz_socket_http_get()

RZ_API char* rz_socket_http_get	(	const char *	url,
		int *	code,
		int *	rlen
	)

Definition at line 287 of file socket_http.c.

                                                                       {
    return socket_http_get_recursive(url, code, rlen, SOCKET_HTTP_MAX_REDIRECTS);
}

References socket_http_get_recursive(), SOCKET_HTTP_MAX_REDIRECTS, and setup::url.

Referenced by __open(), __read(), __rtr_shell(), __system(), __write(), download_and_write(), rtrcmd(), rz_core_rtr_add(), rz_core_rtr_cmd(), and rz_core_rtr_http_run().

rz_socket_http_handle_upload()

RZ_API ut8* rz_socket_http_handle_upload	(	const ut8 *	str,
		int	len,
		int *	olen
	)

Definition at line 144 of file socket_http_server.c.

                                                                               {
    if (retlen) {
        *retlen = 0;
    }
    if (!strncmp((const char *)str, "----------", 10)) {
        int datalen;
        char *ret;
        const char *data, *token = (const char *)str + 10;
        const char *end = strchr(token, '\n');
        if (!end) {
            return NULL;
        }
        data = strstr(end, "Content-Disposition: form-data; ");
        if (data) {
            data = strchr(data, '\n');
            if (data) {
                data = strchr(data + 1, '\n');
            }
        }
        if (data) {
            while (*data == 10 || *data == 13) {
                data++;
            }
            end = (const char *)str + len - 40;
            while (*end == '-') {
                end--;
            }
            if (*end == 10 || *end == 13) {
                end--;
            }
            datalen = (size_t)(end - data);
            ret = malloc(datalen + 1);
            if (!ret) {
                return NULL;
            }
            memcpy(ret, data, datalen);
            ret[datalen] = 0;
            if (retlen) {
                *retlen = datalen;
            }
            return (ut8 *)ret;
        }
    }
    return NULL;
}

References test_evm::end, len, malloc(), memcpy(), NULL, and cmd_descs_generate::str.

Referenced by rz_core_rtr_http_run().

rz_socket_http_post()

RZ_API char* rz_socket_http_post	(	const char *	url,
		const char *	data,
		int *	code,
		int *	rlen
	)

Definition at line 291 of file socket_http.c.

                                                                                          {
    RzSocket *s;
    bool ssl = rz_str_startswith(url, "https://");
    char *uri = strdup(url);
    if (!uri) {
        return NULL;
    }
 
    char *host = strstr(uri, "://");
    if (!host) {
        free(uri);
        printf("Invalid URI");
        return NULL;
    }
    host += 3;
    char *port = strchr(host, ':');
    if (!port) {
        port = (ssl) ? "443" : "80";
    } else {
        *port++ = 0;
    }
    char *path = strchr(host, '/');
    if (!path) {
        path = "";
    } else {
        *path++ = 0;
    }
    s = rz_socket_new(ssl);
    if (!s) {
        printf("Cannot create socket\n");
        free(uri);
        return NULL;
    }
    if (!rz_socket_connect_tcp(s, host, port, 0)) {
        eprintf("Cannot connect to %s:%s\n", host, port);
        free(uri);
        return NULL;
    }
    /* Send */
    rz_socket_printf(s,
        "POST /%s HTTP/1.0\r\n"
        "User-Agent: rizin " RZ_VERSION "\r\n"
        "Accept: */*\r\n"
        "Host: %s\r\n"
        "Content-Length: %i\r\n"
        "Content-Type: application/x-www-form-urlencoded\r\n"
        "\r\n",
        path, host, (int)strlen(data));
    free(uri);
    rz_socket_write(s, (void *)data, strlen(data));
    return socket_http_answer(s, code, rlen, 0);
}

References eprintf, free(), NULL, path, printf(), rz_socket_connect_tcp, rz_socket_new(), rz_socket_printf(), rz_socket_write(), rz_str_startswith(), RZ_VERSION, s, socket_http_answer(), strdup(), and setup::url.

rz_socket_http_response()

RZ_API void rz_socket_http_response	(	RzSocketHTTPRequest *	rs,
		int	code,
		const char *	out,
		int	x,
		const char *	headers
	)

Definition at line 122 of file socket_http_server.c.

                                                                                                                      {
    const char *strcode =
        code == 200 ? "ok" : code == 301 ? "Moved permanently"
        : code == 302                    ? "Found"
        : code == 401                    ? "Unauthorized"
        : code == 403                    ? "Permission denied"
        : code == 404                    ? "not found"
                         : "UNKNOWN";
    if (len < 1) {
        len = out ? strlen(out) : 0;
    }
    if (!headers) {
        headers = code == 401 ? "WWW-Authenticate: Basic realm=\"R2 Web UI Access\"\n" : "";
    }
    rz_socket_printf(rs->s, "HTTP/1.0 %d %s\r\n%s"
                "Connection: close\r\nContent-Length: %d\r\n\r\n",
        code, strcode, headers, len);
    if (out && len > 0) {
        rz_socket_write(rs->s, (void *)out, len);
    }
}

References len, out, rs, rz_socket_printf(), and rz_socket_write().

Referenced by rz_core_rtr_http_run(), and rz_main_rz_agent().

rz_socket_http_server_set_breaked()

RZ_API void rz_socket_http_server_set_breaked

(

bool *

b

)

Definition at line 9 of file socket_http_server.c.

                                                       {
    breaked = b;
}

References b, and breaked.

Referenced by rz_core_rtr_http_stop().

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,
			...
	)

Referenced by runcmd(), rz_core_serve(), rz_socket_http_post(), rz_socket_http_response(), and socket_http_get_recursive().

rz_socket_proc_close()

RZ_API int rz_socket_proc_close

(

RzSocketProc *

sp

)

Definition at line 60 of file socket_proc.c.

                                                             {
#if __UNIX__
    /* this is wrong */
    kill(sp->pid, SIGKILL);
    waitpid(sp->pid, NULL, 0); // WNOHANG);
    close(sp->fd0[0]);
    close(sp->fd0[1]);
    // close(sp->fd1[0]);
    close(sp->fd1[1]);
    // sp->fd[0] = -1;
    // sp->fd[1] = -1;
#endif
    return 0;
}

References close, kill, NULL, SIGKILL, and sp.

Referenced by rz_socket_proc_open().

rz_socket_proc_gets()

RZ_API int rz_socket_proc_gets	(	RzSocketProc *	sp,
		char *	buf,
		int	size
	)

Definition at line 82 of file socket_proc.c.

                                                                      {
    RzSocket s;
    s.is_ssl = false;
    s.fd = sp->fd1[0];
    return rz_socket_gets(&s, buf, size);
}

References rz_socket_t::fd, rz_socket_t::is_ssl, rz_socket_gets(), s, and sp.

rz_socket_proc_open()

RZ_API RzSocketProc* rz_socket_proc_open

(

char *const

argv[]

)

Definition at line 17 of file socket_proc.c.

                                                                        {
#if __UNIX__ && HAVE_FORK
    RzSocketProc *sp = RZ_NEW(RzSocketProc);
 
    if (!sp) {
        return NULL;
    }
 
    if (rz_sys_pipe(sp->fd0, true) == -1) {
        perror("pipe");
        goto error;
    }
 
    if (rz_sys_pipe(sp->fd1, true) == -1) {
        perror("pipe");
        goto error;
    }
 
    sp->pid = rz_sys_fork();
    switch (sp->pid) {
    case 0:
        close(0);
        dup2(sp->fd0[0], 0);
        close(1);
        dup2(sp->fd1[1], 1);
        rz_sys_execv(argv[0], argv);
        exit(1);
        break;
    case -1:
        perror("fork");
        rz_socket_proc_close(sp);
        goto error;
        // rz_socket_block_time (sp, false, 0);
    }
    return sp;
error:
    free(sp);
    return NULL;
#else
    return NULL;
#endif
}

References argv, close, dup2, error(), test-lz4-list::exit, free(), NULL, RZ_NEW, rz_socket_proc_close(), rz_sys_execv(), rz_sys_fork(), rz_sys_pipe(), and sp.

rz_socket_proc_printf()

RZ_API void rz_socket_proc_printf	(	RzSocketProc *	sp,
		const char *	fmt,
			...
	)

rz_socket_proc_read()

RZ_API int rz_socket_proc_read	(	RzSocketProc *	sp,
		unsigned char *	buf,
		int	len
	)

Definition at line 75 of file socket_proc.c.

                                                                              {
    RzSocket s;
    s.is_ssl = false;
    s.fd = sp->fd1[0];
    return rz_socket_read(&s, buf, len);
}

References rz_socket_t::fd, rz_socket_t::is_ssl, len, rz_socket_read(), s, and sp.

rz_socket_proc_ready()

RZ_API void RZ_API int rz_socket_proc_ready	(	RzSocketProc *	sp,
		int	secs,
		int	usecs
	)

Definition at line 110 of file socket_proc.c.

                                                                       {
    RzSocket s;
    s.is_ssl = false;
    s.fd = sp->fd1[0];
    return rz_socket_ready(&s, secs, usecs);
}

References rz_socket_t::fd, rz_socket_t::is_ssl, rz_socket_ready(), s, and sp.

rz_socket_proc_write()

RZ_API int rz_socket_proc_write	(	RzSocketProc *	sp,
		void *	buf,
		int	len
	)

Definition at line 89 of file socket_proc.c.

                                                                      {
    RzSocket s;
    s.is_ssl = false;
    s.fd = sp->fd0[1];
    return rz_socket_write(&s, buf, len);
}

References rz_socket_t::fd, rz_socket_t::is_ssl, len, rz_socket_write(), s, and sp.

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_rap_client_command()

RZ_API char* rz_socket_rap_client_command	(	RzSocket *	s,
		const char *	cmd,
		RzCoreBind *	c
	)

Definition at line 58 of file socket_rap_client.c.

                                                                                       {
    char *buf = malloc(strlen(cmd) + 8);
    if (!buf) {
        return NULL;
    }
    /* send request */
    buf[0] = RAP_PACKET_CMD;
    size_t i = strlen(cmd) + 1;
    rz_write_be32(buf + 1, i);
    memcpy(buf + 5, cmd, i);
    rz_socket_write(s, buf, 5 + i);
    rz_socket_flush(s);
    free(buf);
    /* read response */
    char bufr[8];
    rz_socket_read_block(s, (ut8 *)bufr, 5);
    while (bufr[0] == (char)(RAP_PACKET_CMD)) {
        size_t cmd_len = rz_read_at_be32(bufr, 1);
        char *rcmd = calloc(1, cmd_len + 1);
        if (rcmd) {
            rz_socket_read_block(s, (ut8 *)rcmd, cmd_len);
            // char *res = rz_core_cmd_str (core, rcmd);
            char *res = c->cmdstr(c->core, rcmd);
            if (res) {
                int res_len = strlen(res) + 1;
                ut8 *pkt = rz_rap_packet((RAP_PACKET_CMD | RAP_PACKET_REPLY), res_len);
                rz_rap_packet_fill(pkt, (const ut8 *)res, res_len);
                rz_socket_write(s, pkt, 5 + res_len);
                rz_socket_flush(s);
                free(res);
                free(pkt);
            }
            free(rcmd);
        }
        /* read response */
        bufr[0] = -1;
        (void)rz_socket_read_block(s, (ut8 *)bufr, 5);
    }
    if (bufr[0] != (char)(RAP_PACKET_CMD | RAP_PACKET_REPLY)) {
        eprintf("Error: Wrong reply for command 0x%02x\n", bufr[0]);
        return NULL;
    }
    size_t cmd_len = rz_read_at_be32(bufr, 1);
    if (cmd_len < 1 || cmd_len > 16384) {
        eprintf("Error: cmd_len is wrong\n");
        return NULL;
    }
    char *cmd_output = calloc(1, cmd_len + 1);
    if (!cmd_output) {
        eprintf("Error: Allocating cmd output\n");
        return NULL;
    }
    rz_socket_read_block(s, (ut8 *)cmd_output, cmd_len);
    // ensure the termination
    cmd_output[cmd_len] = 0;
    return cmd_output;
}

References c, calloc(), cmd, eprintf, free(), i, malloc(), memcpy(), NULL, RAP_PACKET_CMD, RAP_PACKET_REPLY, rz_rap_packet(), rz_rap_packet_fill(), rz_read_at_be32(), rz_socket_flush(), rz_socket_read_block(), rz_socket_write(), rz_write_be32(), and s.

Referenced by __rap_system(), and rz_core_rtr_cmd().

rz_socket_rap_client_open()

RZ_API int rz_socket_rap_client_open	(	RzSocket *	s,
		const char *	file,
		int	rw
	)

Definition at line 23 of file socket_rap_client.c.

                                                                            {
    rz_socket_block_time(s, true, 1, 0);
    size_t file_len0 = strlen(file) + 1;
    if (file_len0 > 255) {
        eprintf("Filename too long\n");
        return -1;
    }
    char *buf = malloc(file_len0 + 7);
    if (!buf) {
        return -1;
    }
    // >>
    buf[0] = RAP_PACKET_OPEN;
    buf[1] = rw;
    buf[2] = (ut8)(file_len0 & 0xff);
    memcpy(buf + 3, file, file_len0);
    (void)rz_socket_write(s, buf, 3 + file_len0);
    rz_socket_flush(s);
    // <<
    int fd = -1;
    memset(buf, 0, 5);
    int r = rz_socket_read_block(s, (ut8 *)buf, 5);
    if (r == 5) {
        if (buf[0] == (char)(RAP_PACKET_OPEN | RAP_PACKET_REPLY)) {
            fd = rz_read_at_be32(buf + 1, 1);
        } else {
            eprintf("RapClientOpen: Bad packet 0x%02x\n", buf[0]);
        }
    } else {
        eprintf("Cannot read 5 bytes from server\n");
    }
    free(buf);
    return fd;
}

References eprintf, fd, free(), malloc(), memcpy(), memset(), r, RAP_PACKET_OPEN, RAP_PACKET_REPLY, rz_read_at_be32(), rz_socket_block_time(), rz_socket_flush(), rz_socket_read_block(), rz_socket_write(), s, and ut8.

Referenced by __rap_open(), and rz_core_rtr_add().

rz_socket_rap_client_read()

RZ_API int rz_socket_rap_client_read	(	RzSocket *	s,
		ut8 *	buf,
		int	count
	)

Definition at line 149 of file socket_rap_client.c.

                                                                       {
    ut8 tmp[32];
    if (count < 1) {
        return count;
    }
    rz_socket_block_time(s, 1, 1, 0);
    // XXX. if count is > RAP_PACKET_MAX, just perform multiple queries
    if (count > RAP_PACKET_MAX) {
        count = RAP_PACKET_MAX;
    }
    // send
    tmp[0] = RAP_PACKET_READ;
    rz_write_be32(tmp + 1, count);
    (void)rz_socket_write(s, tmp, 5);
    rz_socket_flush(s);
    // recv
    int ret = rz_socket_read_block(s, tmp, 5);
    if (ret != 5 || tmp[0] != (RAP_PACKET_READ | RAP_PACKET_REPLY)) {
        eprintf("__rap_read: Unexpected rap read reply "
            "(%d=0x%02x) expected (%d=0x%02x)\n",
            ret, tmp[0], 2, (RAP_PACKET_READ | RAP_PACKET_REPLY));
        return -1;
    }
    int i = rz_read_at_be32(tmp, 1);
    if (i > count) {
        eprintf("__rap_read: Unexpected data size %d vs %d\n", i, count);
        return -1;
    }
    rz_socket_read_block(s, buf, i);
    return count;
}

References count, eprintf, i, RAP_PACKET_MAX, RAP_PACKET_READ, RAP_PACKET_REPLY, rz_read_at_be32(), rz_socket_block_time(), rz_socket_flush(), rz_socket_read_block(), rz_socket_write(), rz_write_be32(), s, and autogen_x86imm::tmp.

Referenced by __rap_read().

rz_socket_rap_client_seek()

RZ_API int rz_socket_rap_client_seek	(	RzSocket *	s,
		ut64	offset,
		int	whence
	)

Definition at line 181 of file socket_rap_client.c.

                                                                           {
    ut8 tmp[10];
    tmp[0] = RAP_PACKET_SEEK;
    tmp[1] = (ut8)whence;
    rz_write_be64(tmp + 2, offset);
    (void)rz_socket_write(s, &tmp, 10);
    rz_socket_flush(s);
    int ret = rz_socket_read_block(s, (ut8 *)&tmp, 9);
    if (ret != 9) {
        eprintf("Truncated socket read\n");
        return -1;
    }
    if (tmp[0] != (RAP_PACKET_SEEK | RAP_PACKET_REPLY)) {
        // eprintf ("%d %d  - %02x %02x %02x %02x %02x %02x %02x\n",
        // ret, whence, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6]);
        eprintf("Unexpected seek reply (%02x -> %02x)\n", tmp[0], (RAP_PACKET_SEEK | RAP_PACKET_REPLY));
        return -1;
    }
    return rz_read_at_be64(tmp, 1);
}

References eprintf, RAP_PACKET_REPLY, RAP_PACKET_SEEK, rz_read_at_be64(), rz_socket_flush(), rz_socket_read_block(), rz_socket_write(), rz_write_be64(), s, autogen_x86imm::tmp, and ut8.

Referenced by __rap_lseek().

rz_socket_rap_client_write()

RZ_API int rz_socket_rap_client_write	(	RzSocket *	s,
		const ut8 *	buf,
		int	count
	)

Definition at line 116 of file socket_rap_client.c.

                                                                              {
    ut8 *tmp;
    int ret;
    if (count < 1) {
        return count;
    }
    // TOOD: if count > RAP_PACKET_MAX iterate !
    if (count > RAP_PACKET_MAX) {
        count = RAP_PACKET_MAX;
    }
    if (!(tmp = (ut8 *)malloc(count + 5))) {
        eprintf("__rap_write: malloc failed\n");
        return -1;
    }
    tmp[0] = RAP_PACKET_WRITE;
    rz_write_be32(tmp + 1, count);
    memcpy(tmp + 5, buf, count);
 
    (void)rz_socket_write(s, tmp, count + 5);
    rz_socket_flush(s);
    if (rz_socket_read_block(s, tmp, 5) != 5) { // TODO read_block?
        eprintf("__rap_write: error\n");
        ret = -1;
    } else {
        ret = rz_read_be32(tmp + 1);
        if (!ret) {
            ret = -1;
        }
    }
    free(tmp);
    return ret;
}

References count, eprintf, free(), malloc(), memcpy(), RAP_PACKET_MAX, RAP_PACKET_WRITE, rz_read_be32(), rz_socket_flush(), rz_socket_read_block(), rz_socket_write(), rz_write_be32(), s, and autogen_x86imm::tmp.

Referenced by __rap_write().

rz_socket_rap_server_accept()

RZ_API RzSocket* rz_socket_rap_server_accept

(

RzSocketRapServer *

rap_s

)

Definition at line 48 of file socket_rap_server.c.

                                                                   {
    rz_return_val_if_fail(s && s->fd, NULL);
    return rz_socket_accept(s->fd);
}

References rz_socket_t::fd, NULL, rz_return_val_if_fail, rz_socket_accept(), and s.

rz_socket_rap_server_continue()

RZ_API bool rz_socket_rap_server_continue

(

RzSocketRapServer *

rap_s

)

Definition at line 53 of file socket_rap_server.c.

                                                                {
    rz_return_val_if_fail(s && s->fd, false);
 
    int i;
    char *ptr = NULL;
 
    if (!rz_socket_is_connected(s->fd)) {
        return false;
    }
    rz_socket_read_block(s->fd, s->buf, 1);
    switch (s->buf[0]) {
    case RAP_PACKET_OPEN:
        rz_socket_read_block(s->fd, &s->buf[1], 2);
        rz_socket_read_block(s->fd, &s->buf[3], (int)s->buf[2]);
        {
            int fd = s->open(s->user, (const char *)&s->buf[3], (int)s->buf[1], 0);
            s->buf[0] = RAP_PACKET_OPEN | RAP_PACKET_REPLY;
            eprintf("REPLY BACK %d\n", fd);
            rz_write_be32(s->buf + 1, fd);
        }
        rz_socket_write(s->fd, s->buf, 5);
        rz_socket_flush(s->fd);
        break;
    case RAP_PACKET_READ:
        rz_socket_read_block(s->fd, &s->buf[1], 4);
        i = rz_read_be32(&s->buf[1]);
        if (i > RAP_PACKET_MAX || i < 0) {
            i = RAP_PACKET_MAX;
        }
        s->read(s->user, &s->buf[5], i);
        s->buf[0] = RAP_PACKET_READ | RAP_PACKET_REPLY;
        rz_socket_write(s->fd, s->buf, i + 5);
        rz_socket_flush(s->fd);
        break;
    case RAP_PACKET_WRITE:
        rz_socket_read_block(s->fd, s->buf + 1, 4);
        i = rz_read_be32(s->buf + 1);
        if (i > RAP_PACKET_MAX || i < 0) {
            i = RAP_PACKET_MAX;
        }
        rz_socket_read_block(s->fd, s->buf + 5, i);
        rz_write_be32(s->buf + 1, s->write(s->user, s->buf + 5, i));
        s->buf[0] = RAP_PACKET_WRITE | RAP_PACKET_REPLY;
        rz_socket_write(s->fd, s->buf, 5);
        rz_socket_flush(s->fd);
        break;
    case RAP_PACKET_SEEK: {
        rz_socket_read_block(s->fd, &s->buf[1], 9);
        int whence = s->buf[0];
        ut64 offset = rz_read_be64(s->buf + 1);
        offset = s->seek(s->user, offset, whence);
        /* prepare reply */
        s->buf[0] = RAP_PACKET_SEEK | RAP_PACKET_REPLY;
        rz_write_be64(s->buf + 1, offset);
        rz_socket_write(s->fd, s->buf, 9);
        rz_socket_flush(s->fd);
    } break;
    case RAP_PACKET_CMD:
        rz_socket_read_block(s->fd, &s->buf[1], 4);
        i = rz_read_be32(&s->buf[1]);
        if (rz_socket_read_block(s->fd, &s->buf[5], i) > 0) {
            ptr = s->cmd(s->user, (const char *)s->buf + 5);
            i = (ptr) ? strlen(ptr) + 1 : 0;
            rz_write_be32(&s->buf[1], i);
            s->buf[0] = RAP_PACKET_CMD | RAP_PACKET_REPLY;
            rz_socket_write(s->fd, s->buf, 5);
            if (i) {
                rz_socket_write(s->fd, ptr, i);
            }
            rz_socket_flush(s->fd);
            RZ_FREE(ptr);
        }
        break;
    case RAP_PACKET_CLOSE:
        rz_socket_read_block(s->fd, &s->buf[1], 4);
        i = rz_read_be32(&s->buf[1]);
        s->close(s->user, i);
        s->buf[0] = RAP_PACKET_CLOSE | RAP_PACKET_REPLY;
        rz_socket_write(s->fd, s->buf, 5);
        rz_socket_flush(s->fd);
        break;
    default:
        eprintf("unknown command 0x%02x\n", (ut8)(s->buf[0] & 0xff));
        rz_socket_close(s->fd);
        return false;
    }
    return true;
}

References eprintf, fd, rz_socket_t::fd, i, NULL, RAP_PACKET_CLOSE, RAP_PACKET_CMD, RAP_PACKET_MAX, RAP_PACKET_OPEN, RAP_PACKET_READ, RAP_PACKET_REPLY, RAP_PACKET_SEEK, RAP_PACKET_WRITE, RZ_FREE, rz_read_be32(), rz_read_be64(), rz_return_val_if_fail, rz_socket_close(), rz_socket_flush(), rz_socket_is_connected(), rz_socket_read_block(), rz_socket_write(), rz_write_be32(), rz_write_be64(), s, and ut64().

rz_socket_rap_server_create()

RZ_API RzSocketRapServer* rz_socket_rap_server_create

(

const char *

pathname

)

Definition at line 23 of file socket_rap_server.c.

                                                                            {
    rz_return_val_if_fail(pathname, NULL);
    if (strlen(pathname) < 11) {
        return NULL;
    }
    if (strncmp(pathname, "rap", 3)) {
        return NULL;
    }
    bool is_ssl = (pathname[3] == 's');
    const char *port = &pathname[7 + is_ssl];
    return rz_socket_rap_server_new(is_ssl, port);
}

References NULL, pathname, rz_return_val_if_fail, and rz_socket_rap_server_new().

rz_socket_rap_server_free()

RZ_API void rz_socket_rap_server_free

(

RzSocketRapServer *

rap_s

)

Definition at line 36 of file socket_rap_server.c.

                                                            {
    if (s) {
        rz_socket_free(s->fd);
        free(s);
    }
}

References rz_socket_t::fd, free(), rz_socket_free(), and s.

rz_socket_rap_server_listen()

RZ_API bool rz_socket_rap_server_listen	(	RzSocketRapServer *	rap_s,
		const char *	certfile
	)

Definition at line 43 of file socket_rap_server.c.

                                                                                    {
    rz_return_val_if_fail(s && s->port && *s->port, false);
    return rz_socket_listen(s->fd, s->port, certfile);
}

References rz_socket_t::fd, rz_socket_t::port, rz_return_val_if_fail, rz_socket_listen(), and s.

rz_socket_rap_server_new()

RZ_API RzSocketRapServer* rz_socket_rap_server_new	(	bool	is_ssl,
		const char *	port
	)

Definition at line 8 of file socket_rap_server.c.

                                                                                   {
    rz_return_val_if_fail(port, NULL);
    RzSocketRapServer *s = RZ_NEW0(RzSocketRapServer);
    if (s) {
        s->port = strdup(port);
        s->fd = rz_socket_new(use_ssl);
        if (s->fd) {
            return s;
        }
        rz_socket_free(s->fd);
        free(s);
    }
    return NULL;
}

References rz_socket_t::fd, free(), NULL, rz_socket_t::port, RZ_NEW0, rz_return_val_if_fail, rz_socket_free(), rz_socket_new(), s, and strdup().

Referenced by rz_socket_rap_server_create().

rz_socket_read()

RZ_API void RZ_API int rz_socket_read	(	RzSocket *	s,
		ut8 *	read,
		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,
		unsigned char *	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().

rzpipe_close()

RZ_API int rzpipe_close

(

RzPipe *

rzpipe

)

Definition at line 110 of file rzpipe.c.

                                        {
    if (!rzpipe) {
        return 0;
    }
    /*
    if (rzpipe->coreb.core && !rzpipe->coreb.puts) {
        void (*rfre)(void *c) = rz_lib_dl_sym (librz, "rz_core_free");
        if (rfre) {
            rfre (rzpipe->coreb.core);
        }
    }
    */
#if __WINDOWS__
    if (rzpipe->pipe) {
        CloseHandle(rzpipe->pipe);
        rzpipe->pipe = NULL;
    }
#else
    if (rzpipe->input[0] != -1) {
        rz_sys_pipe_close(rzpipe->input[0]);
        rzpipe->input[0] = -1;
    }
    if (rzpipe->input[1] != -1) {
        rz_sys_pipe_close(rzpipe->input[1]);
        rzpipe->input[1] = -1;
    }
    if (rzpipe->output[0] != -1) {
        rz_sys_pipe_close(rzpipe->output[0]);
        rzpipe->output[0] = -1;
    }
    if (rzpipe->output[1] != -1) {
        rz_sys_pipe_close(rzpipe->output[1]);
        rzpipe->output[1] = -1;
    }
    if (rzpipe->child != -1) {
        kill(rzpipe->child, SIGTERM);
        waitpid(rzpipe->child, NULL, 0);
        rzpipe->child = -1;
    }
#endif
    free(rzpipe);
    return 0;
}

References RzPipe::child, free(), RzPipe::input, kill, NULL, RzPipe::output, and rz_sys_pipe_close().

Referenced by __close(), and rzpipe_open().

rzpipe_cmd()

RZ_API char* rzpipe_cmd	(	RzPipe *	rzpipe,
		const char *	str
	)

Definition at line 316 of file rzpipe.c.

                                                      {
    rz_return_val_if_fail(rzp && str, NULL);
    if (!*str || !rzpipe_write(rzp, str)) {
        perror("rzpipe_write");
        return NULL;
    }
    return rzpipe_read(rzp);
}

References NULL, rz_return_val_if_fail, rzpipe_read(), rzpipe_write(), and cmd_descs_generate::str.

Referenced by rzpipe_cmdf().

rzpipe_cmdf()

RZ_API char* rzpipe_cmdf	(	RzPipe *	rzpipe,
		const char *	fmt,
			...
	)

rzpipe_open()

RZ_API RzPipe* rzpipe_open

(

const char *

cmd

)

Definition at line 235 of file rzpipe.c.

                                            {
    RzPipe *rzp = rzpipe_new();
    if (!rzp) {
        return NULL;
    }
    if (RZ_STR_ISEMPTY(cmd)) {
        rzp->child = -1;
        return rzp_open_spawn(rzp, cmd);
    }
#if __WINDOWS__
    w32_createPipe(rzp, cmd);
    rzp->child = (int)(rzp->pipe);
#else
    int r = rz_sys_pipe(rzp->input, false);
    if (r != 0) {
        eprintf("pipe failed on input\n");
        rzpipe_close(rzp);
        return NULL;
    }
    r = rz_sys_pipe(rzp->output, false);
    if (r != 0) {
        eprintf("pipe failed on output\n");
        rzpipe_close(rzp);
        return NULL;
    }
    rzp->child = rz_sys_fork();
    if (rzp->child == -1) {
        rzpipe_close(rzp);
        return NULL;
    }
    env("RZ_PIPE_IN", rzp->input[0]);
    env("RZ_PIPE_OUT", rzp->output[1]);
 
    if (rzp->child) {
        signed char ch = -1;
        // eprintf ("[+] rzpipeipe child is %d\n", rzpipe->child);
        if (read(rzp->output[0], &ch, 1) != 1) {
            eprintf("Failed to read 1 byte\n");
            rzpipe_close(rzp);
            return NULL;
        }
        if (ch == -1) {
            eprintf("[+] rzpipe link error.\n");
            rzpipe_close(rzp);
            return NULL;
        }
        // Close parent's end of pipes
        rz_sys_pipe_close(rzp->input[0]);
        rz_sys_pipe_close(rzp->output[1]);
        rzp->input[0] = -1;
        rzp->output[1] = -1;
    } else {
        int rc = 0;
        if (cmd && *cmd) {
            close(0);
            close(1);
            dup2(rzp->input[0], 0);
            dup2(rzp->output[1], 1);
            rz_sys_pipe_close(rzp->input[1]);
            rz_sys_pipe_close(rzp->output[0]);
            rzp->input[1] = -1;
            rzp->output[0] = -1;
            rc = rz_sys_system(cmd);
            if (rc != 0) {
                eprintf("return code %d for %s\n", rc, cmd);
            }
            // trigger the blocking read
            rz_xwrite(1, "\xff", 1);
            rz_sys_pipe_close(rzp->output[1]);
            close(0);
            close(1);
        }
        rzp->child = -1;
        rzpipe_close(rzp);
        exit(rc);
        return NULL;
    }
#endif
    return rzp;
}

References RzPipe::child, close, cmd, dup2, env(), eprintf, test-lz4-list::exit, RzPipe::input, int, NULL, RzPipe::output, r, read(), RZ_STR_ISEMPTY, rz_sys_fork(), rz_sys_pipe(), rz_sys_pipe_close(), rz_sys_system(), rz_xwrite, rzp_open_spawn(), rzpipe_close(), and rzpipe_new().

Referenced by __open().

rzpipe_open_corebind()

RZ_API RzPipe* rzpipe_open_corebind

(

RzCoreBind *

coreb

)

Definition at line 209 of file rzpipe.c.

                                                       {
    RzPipe *rzpipe = rzpipe_new();
    if (rzpipe) {
        memcpy(&rzpipe->coreb, coreb, sizeof(RzCoreBind));
    }
    return rzpipe;
}

References RzPipe::coreb, memcpy(), and rzpipe_new().

rzpipe_open_dl()

RZ_API RzPipe* rzpipe_open_dl

(

const char *

file

)

Definition at line 217 of file rzpipe.c.

                                                     {
    void *librz = rz_lib_dl_open(libr_path);
    void *(*rnew)() = rz_lib_dl_sym(librz, "rz_core_new");
    char *(*rcmd)(void *c, const char *cmd) = rz_lib_dl_sym(librz, "rz_core_cmd_str");
 
    if (rnew && rcmd) {
        RzPipe *rzpipe = rzpipe_new();
        if (rzpipe) {
            rzpipe->coreb.core = rnew();
            rzpipe->coreb.cmdstr = rcmd;
            // rzpipe->coreb.free = rfre;
        }
        return rzpipe;
    }
    eprintf("Cannot resolve rz_core_cmd, rz_core_cmd_str, rz_core_free\n");
    return NULL;
}

References c, cmd, rz_core_bind_t::cmdstr, rz_core_bind_t::core, RzPipe::coreb, eprintf, NULL, rz_lib_dl_open(), rz_lib_dl_sym(), and rzpipe_new().

rzpipe_read()

RZ_API char* rzpipe_read

(

RzPipe *

rzpipe

)

Definition at line 61 of file rzpipe.c.

                                         {
    int bufsz = 0;
    char *buf = NULL;
    if (!rzpipe) {
        return NULL;
    }
    bufsz = 4096;
    buf = calloc(1, bufsz);
    if (!buf) {
        return NULL;
    }
#if __WINDOWS__
    BOOL bSuccess = FALSE;
    DWORD dwRead = 0;
    // TODO: handle > 4096 buffers here
    bSuccess = ReadFile(rzpipe->pipe, buf, bufsz, &dwRead, NULL);
    if (!bSuccess || !buf[0]) {
        return NULL;
    }
    if (dwRead > 0) {
        buf[dwRead] = 0;
    }
    buf[bufsz - 1] = 0;
#else
    char *newbuf;
    int i, rv;
    for (i = 0; i < bufsz; i++) {
        rv = read(rzpipe->output[0], buf + i, 1);
        if (i + 2 >= bufsz) {
            bufsz += 4096;
            newbuf = realloc(buf, bufsz);
            if (!newbuf) {
                RZ_FREE(buf);
                break;
            }
            buf = newbuf;
        }
        if (rv != 1 || !buf[i]) {
            break;
        }
    }
    if (buf) {
        int zpos = (i < bufsz) ? i : i - 1;
        buf[zpos] = 0;
    }
#endif
    return buf;
}

References calloc(), DWORD, FALSE, i, NULL, RzPipe::output, read(), realloc(), and RZ_FREE.

Referenced by __read(), __system(), __write(), and rzpipe_cmd().

rzpipe_write()

RZ_API int rzpipe_write	(	RzPipe *	rzpipe,
		const char *	str
	)

Definition at line 36 of file rzpipe.c.

                                                         {
    char *cmd;
    int ret, len;
    if (!rzpipe || !str) {
        return -1;
    }
    len = strlen(str) + 2; /* include \n\x00 */
    cmd = malloc(len + 2);
    if (!cmd) {
        return 0;
    }
    memcpy(cmd, str, len - 1);
    strcpy(cmd + len - 2, "\n");
#if __WINDOWS__
    DWORD dwWritten = -1;
    WriteFile(rzpipe->pipe, cmd, len, &dwWritten, NULL);
    ret = (dwWritten == len);
#else
    ret = (write(rzpipe->input[1], cmd, len) == len);
#endif
    free(cmd);
    return ret;
}

References cmd, DWORD, free(), RzPipe::input, len, malloc(), memcpy(), NULL, cmd_descs_generate::str, and write.

Referenced by __read(), __system(), __write(), and rzpipe_cmd().