rz-bindgen/doxygen/librz_2main_2rz-agent_8c_source.html

 // SPDX-FileCopyrightText: 2013-2020 pancake <pancake@nopcode.org>

 // SPDX-License-Identifier: LGPL-3.0-only


 #include <rz_main.h>

 #include <rz_core.h>

 #include <rz_socket.h>


 static const char *page_index =

     "<html>"

     "<head>"

     "<title>rz-agent</title>"

     "<script>"

     "function file_open() {"

     "  var file = window.prompt ('path to file?');"

     "  window.open ('/file/open/'+file);"

     "}"

     "</script>"

     "</head>"

     "<body>"

     "  <h2>rz-agent</h2>"

     "  <hr size=1 />"

     "File<br />"

     " - <a href='javascript:file_open()'>open</a><br />"

     " - <a href='/file/list'>list</a><br />"

     " - push<br />"

     " - pull<br />"

     " - delete<br />"

     " - chmod<br />"

     "Processes<br />"

     " - list<br />"

     "Sessions<br />"

     " - list<br />"

     "</body>"

     "</html>";


 #if __APPLE__ && (__arm__ || __arm64__ || __aarch64__)

 #define USE_IOS_JETSAM 1


 #define MEMORYSTATUS_CMD_SET_JETSAM_TASK_LIMIT 6

 extern int memorystatus_control(uint32_t command, pid_t pid, uint32_t flags, void *buffer, size_t buffersize);


 #else

 #define USE_IOS_JETSAM 0

 #endif


 static int usage(int v) {

     printf("Usage: rz-agent [-adhs] [-p port]\n"

            "  -a        listen for everyone (localhost by default)\n"

            "  -d        run in daemon mode (background)\n"

            "  -h        show this help message\n"

            "  -u        enable http Authorization access\n"

            "  -t        user:password authentication file\n"

            "  -p [port] specify listening port (defaults to 8080)\n");

     return !v;

 }


 static int showversion(void) {

     return rz_main_version_print("rz-agent");

 }


 RZ_API int rz_main_rz_agent(int argc, const char **argv) {

     RzSocket *s;

     RzSocketHTTPOptions so;

     RzSocketHTTPRequest *rs;

     int c;

     int dodaemon = 0;

     bool listenlocal = true;

     const char *port = "8080";

     const char *httpauthfile = NULL;

     char *pfile = NULL;

     memset(&so, 0, sizeof(so));


     RzGetopt opt;

     rz_getopt_init(&opt, argc, argv, "adhup:t:sv");

     while ((c = rz_getopt_next(&opt)) != -1) {

         switch (c) {

         case 'a':

             listenlocal = false;

             break;

         case 'd':

             dodaemon = 1;

             break;

         case 'h':

             return usage(1);

         case 'v':

             return showversion();

         case 'u':

             so.httpauth = true;

             break;

         case 't':

             httpauthfile = opt.arg;

             break;

         case 'p':

             port = opt.arg;

             break;

         default:

             return usage(0);

         }

     }

     if (opt.ind != argc) {

         return usage(0);

     }


     so.accept_timeout = 0;

     so.timeout = 3;


     if (so.httpauth) {

         if (!httpauthfile) {

             eprintf("No authentication user list set\n");

             return usage(0);

         }


         size_t sz;

         pfile = rz_file_slurp(httpauthfile, &sz);

         if (pfile) {

             so.authtokens = rz_str_split_list(pfile, "\n", 0);

         } else {

             eprintf("Empty list of HTTP users\\n");

             return usage(0);

         }

     }

 #if USE_IOS_JETSAM

     memorystatus_control(MEMORYSTATUS_CMD_SET_JETSAM_TASK_LIMIT, getpid(), 256, NULL, 0);

 #endif

     if (dodaemon) {

 #if HAVE_FORK

         int pid = rz_sys_fork();

         if (pid > 0) {

             printf("%d\n", pid);

             return 0;

         }

 #endif

     }

     s = rz_socket_new(false);

     s->local = listenlocal;

     if (!rz_socket_listen(s, port, NULL)) {

         eprintf("Cannot listen on %d\n", s->port);

         rz_socket_free(s);

         return 1;

     }


     eprintf("http://localhost:%d/\n", s->port);


     (void)rz_cons_new();


     while (!rz_cons_singleton()->context->breaked) {

         char *result_heap = NULL;

         const char *result = page_index;


         rs = rz_socket_http_accept(s, &so);

         if (!rs) {

             continue;

         }

         if (!rs->auth) {

             rz_socket_http_response(rs, 401, "", 0, NULL);

         }

         if (!strcmp(rs->method, "GET")) {

             if (!strncmp(rs->path, "/proc/kill/", 11)) {

                 // TODO: show page here?

                 int pid = atoi(rs->path + 11);

                 if (pid > 0) {

 #if __WINDOWS__

                     rz_sys_kill(pid, 0);

 #else

                     rz_sys_kill(pid, SIGKILL);

 #endif

                 }

             } else if (!strncmp(rs->path, "/file/open/", 11)) {

                 int pid;

                 int session_port = 3000 + rz_num_rand(1024);

                 char *filename = rs->path + 11;

                 char *escaped_filename = rz_str_escape(filename);

                 size_t escaped_len = strlen(escaped_filename);

                 size_t cmd_len = escaped_len + 40;

                 char *cmd;


                 if (!(cmd = malloc(cmd_len))) {

                     perror("malloc");

                     return 1;

                 }

                 snprintf(cmd, cmd_len, "rizin -q %s-e http.port=%d -cRh \"%s\"",

                     listenlocal ? "" : "-e http.bind=public ",

                     session_port, escaped_filename);


                 // TODO: use rz_sys api to get pid when running in bg

                 pid = rz_sys_cmdbg(cmd);

                 free(cmd);

                 free(escaped_filename);

                 result = result_heap = malloc(1024 + escaped_len);

                 if (!result) {

                     perror("malloc");

                     free(pfile);

                     rz_list_free(so.authtokens);

                     return 1;

                 }

                 sprintf(result_heap,

                     "<html><body>"

                     "<a href='/'>back</a><hr size=1/>"

                     " - <a target='_blank' href='http://localhost:%d/'>open</a><br />"

                     " - <a href='/proc/kill/%d'>kill</a><br />"

                     "</body></html>",

                     session_port, pid);

                 eprintf("\nchild pid %d\n\n", pid);

             }

         }

         rz_socket_http_response(rs, 200, result, 0, NULL);

         rz_socket_http_close(rs);

         free(result_heap);

         result_heap = NULL;

     }

     rz_cons_free();

     free(pfile);

     rz_list_free(so.authtokens);

     rz_socket_free(s);

     return 0;

 }

rs
#define rs()
Definition: analysis_h8300.c:31

SIGKILL
#define SIGKILL

rz_cons_singleton
RZ_API RzCons * rz_cons_singleton(void)
Definition: cons.c:300

rz_cons_new
RZ_API RzCons * rz_cons_new(void)
Definition: cons.c:589

rz_cons_free
RZ_API RzCons * rz_cons_free(void)
Definition: cons.c:658

RZ_API
#define RZ_API
Definition: core_plugin_example.c:36

NULL
#define NULL
Definition: cris-opc.c:27

printf
_Use_decl_annotations_ int __cdecl printf(const char *const _Format,...)
Definition: cs_driver.c:93

cmd
static static sync static getppid static getegid const char static filename char static len const char char static bufsiz static mask static vfork const void static prot static getpgrp const char static swapflags cmd
Definition: sflib.h:79

v
const char * v
Definition: dsignal.c:12

free
RZ_API void Ht_() free(HtName_(Ht) *ht)
Definition: ht_inc.c:130

filename
const char * filename
Definition: ioapi.h:137

snprintf
snprintf
Definition: kernel.h:364

sprintf
sprintf
Definition: kernel.h:365

memset
return memset(p, 0, total)

page_index
static const char * page_index
Definition: rz-agent.c:8

usage
static int usage(int v)
Definition: rz-agent.c:46

rz_main_rz_agent
RZ_API int rz_main_rz_agent(int argc, const char **argv)
Definition: rz-agent.c:61

showversion
static int showversion(void)
Definition: rz-agent.c:57

rz_list_free
RZ_API void rz_list_free(RZ_NONNULL RzList *list)
Empties the list and frees the list pointer.
Definition: list.c:137

malloc
void * malloc(size_t size)
Definition: malloc.c:123

pid
static static fork const void static count static fd const char const char static newpath char char char static envp time_t static t const char static mode static whence const char static dir time_t static t unsigned static seconds const char struct utimbuf static buf static inc pid
Definition: sflib.h:64

argv
static static fork const void static count static fd const char const char static newpath char char argv
Definition: sflib.h:40

eprintf
#define eprintf(x, y...)
Definition: rlcc.c:7

s
static RzSocket * s
Definition: rtr.c:28

rz_core.h

rz_file_slurp
RZ_API RZ_OWN char * rz_file_slurp(const char *str, RZ_NULLABLE size_t *usz)
Definition: file.c:454

rz_getopt_init
RZ_API void rz_getopt_init(RzGetopt *go, int argc, const char **argv, const char *ostr)
Definition: getopt.c:17

rz_getopt_next
RZ_API int rz_getopt_next(RzGetopt *opt)
Definition: getopt.c:29

rz_main.h

rz_main_version_print
RZ_API int rz_main_version_print(const char *program)
Definition: main.c:49

rz_num_rand
RZ_API int rz_num_rand(int max)
Definition: unum.c:47

rz_socket.h

rz_socket_http_accept
RZ_API RzSocketHTTPRequest * rz_socket_http_accept(RzSocket *s, RzSocketHTTPOptions *so)
Definition: socket_http_server.c:13

rz_socket_http_response
RZ_API void rz_socket_http_response(RzSocketHTTPRequest *rs, int code, const char *out, int x, const char *headers)
Definition: socket_http_server.c:122

rz_socket_listen
RZ_API bool rz_socket_listen(RzSocket *s, const char *port, const char *certfile)
Definition: socket.c:474

rz_socket_new
RZ_API RzSocket * rz_socket_new(bool is_ssl)
Definition: socket.c:179

rz_socket_free
RZ_API int rz_socket_free(RzSocket *s)
Definition: socket.c:453

rz_socket_http_close
RZ_API void rz_socket_http_close(RzSocketHTTPRequest *rs)
Definition: socket_http_server.c:191

rz_str_escape
RZ_API RZ_OWN char * rz_str_escape(RZ_NONNULL const char *buf)
Definition: str.c:1550

rz_str_split_list
RZ_API RzList * rz_str_split_list(char *str, const char *c, int n)
Split the string str according to the substring c and returns a RzList with the result.
Definition: str.c:3429

rz_sys_fork
RZ_API int rz_sys_fork(void)
Definition: sys.c:1679

rz_sys_kill
RZ_API int rz_sys_kill(int pid, int sig)
Send signal sig to process with pid pid.
Definition: sys.c:1850

rz_sys_cmdbg
RZ_API int rz_sys_cmdbg(const char *cmd)
Definition: sys.c:644

flags
static struct sockaddr static addrlen static backlog const void static flags void flags
Definition: sfsocketcall.h:123

uint32_t
unsigned int uint32_t
Definition: sftypes.h:29

pid_t
int pid_t
Definition: sftypes.h:38

c
#define c(i)
Definition: sha256.c:43

buffer
Definition: buffer.h:15

rz_cons_context_t::breaked
bool breaked
Definition: rz_cons.h:472

rz_cons_t::context
RzConsContext * context
Definition: rz_cons.h:502

rz_getopt_t
Definition: rz_getopt.h:10

rz_getopt_t::ind
int ind
Definition: rz_getopt.h:12

rz_getopt_t::arg
const char * arg
Definition: rz_getopt.h:15

rz_socket_http_options
Definition: rz_socket.h:80

rz_socket_http_options::accept_timeout
bool accept_timeout
Definition: rz_socket.h:82

rz_socket_http_options::httpauth
bool httpauth
Definition: rz_socket.h:84

rz_socket_http_options::timeout
int timeout
Definition: rz_socket.h:83

rz_socket_http_options::authtokens
RzList * authtokens
Definition: rz_socket.h:81

rz_socket_http_request
Definition: rz_socket.h:146

rz_socket_t
Definition: rz_socket.h:62

rz_socket_t::port
int port
Definition: rz_socket.h:71

rz_socket_t::local
int local
Definition: rz_socket.h:70

command
const char * command
Definition: main.c:7