src/monkey/gnunet-monkey.c

   1 /**[txh]********************************************************************
   2
   3   Copyright (c) 2004 by Salvador E. Tropea.
   4   Covered by the GPL license.
   5
   6   Comment:
   7   X11 example/test of the libmigdb.
   8   Run it from an X11 terminal (xterm, Eterm, etc.).
   9
  10 ***************************************************************************/
  11
  12 #include <stdio.h>
  13 #include <unistd.h> //usleep
  14 #include <libesmtp.h>
  15 #include "gdbmi.h"
  16 #include "platform.h"
  17 #include "gnunet_common.h"
  18 #include "gnunet_getopt_lib.h"
  19 #include "gnunet_program_lib.h"
  20
  21 extern void sendMail (const char *messageContents);
  22 static const char* mode;
  23 static const char* dumpFileName;
  24 static const char* binaryName;
  25 static int ret = 0;
  26
  27 void cb_console(const char *str, void *data)
  28 {
  29  printf("CONSOLE> %s\n",str);
  30 }
  31
  32 /* Note that unlike what's documented in gdb docs it isn't usable. */
  33 void cb_target(const char *str, void *data)
  34 {
  35  printf("TARGET> %s\n",str);
  36 }
  37
  38 void cb_log(const char *str, void *data)
  39 {
  40  printf("LOG> %s\n",str);
  41 }
  42
  43 void cb_to(const char *str, void *data)
  44 {
  45  printf(">> %s",str);
  46 }
  47
  48 void cb_from(const char *str, void *data)
  49 {
  50  printf("<< %s\n",str);
  51 }
  52
  53 static int async_c=0;
  54
  55 void cb_async(mi_output *o, void *data)
  56 {
  57  printf("ASYNC\n");
  58  async_c++;
  59 }
  60
  61
  62 static void dumpText(const char* message)
  63 {
  64         FILE* file = fopen(dumpFileName, "w");
  65         GNUNET_assert(NULL != file);
  66         fprintf(file,"%s", message);
  67         fclose(file);
  68 }
  69
  70
  71 void send_bug_mail(mi_stop* sr, mi_frames* f)
  72 {
  73         char *message;
  74         GNUNET_asprintf(&message,
  75                         "Bug detected in file:%s\nfunction:%s\nline:%d\nreason:%s\nreceived signal:%s\n%s\n",
  76                         f->file, f->func, f->line, mi_reason_enum_to_str(sr->reason), sr->signal_name, sr->signal_meaning);
  77         if (strcasecmp(mode, "mail") == 0)
  78                 sendMail(message);
  79         else
  80                 dumpText(message);
  81
  82         GNUNET_free (message);
  83 }
  84
  85
  86 int wait_for_stop(mi_h *h)
  87 {
  88  int res=1;
  89  mi_stop *sr;
  90  mi_frames *f;
  91
  92  while (!mi_get_response(h))
  93     usleep(1000);
  94  /* The end of the async. */
  95  sr=mi_res_stop(h);
  96  if (sr)
  97    {
  98     f = gmi_stack_info_frame(h);
  99     send_bug_mail(sr, f);
 100     mi_free_stop(sr);
 101     res = 0;
 102    }
 103  else
 104    {
 105     printf("Error while waiting\n");
 106     printf("mi_error: %d\nmi_error_from_gdb: %s\n",mi_error,mi_error_from_gdb);
 107     res=0;
 108    }
 109  return res;
 110 }
 111
 112
 113
 114 /**
 115  * Main function that will be run by the scheduler.
 116  *
 117  * @param cls closure
 118  * @param s the scheduler to use
 119  * @param args remaining command-line arguments
 120  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 121  * @param c configuration
 122  */
 123 static void
 124 run (void *cls,
 125      struct GNUNET_SCHEDULER_Handle *s,
 126      char *const *args,
 127      const char *cfgfile,
 128      const struct GNUNET_CONFIGURATION_Handle *c)
 129 {
 130         mi_aux_term *xterm_tty=NULL;
 131
 132         /* This is like a file-handle for fopen.
 133             Here we have all the state of gdb "connection". */
 134          mi_h *h;
 135
 136          /* Connect to gdb child. */
 137          h=mi_connect_local();
 138          if (!h)
 139            {
 140             printf("Connect failed\n");
 141             ret = 1;
 142             return;
 143            }
 144          printf("Connected to gdb!\n");
 145
 146          /* Set all callbacks. */
 147          mi_set_console_cb(h,cb_console,NULL);
 148          mi_set_target_cb(h,cb_target,NULL);
 149          mi_set_log_cb(h,cb_log,NULL);
 150          mi_set_async_cb(h,cb_async,NULL);
 151          mi_set_to_gdb_cb(h,cb_to,NULL);
 152          mi_set_from_gdb_cb(h,cb_from,NULL);
 153
 154          /* Set the name of the child and the command line aguments. */
 155          if (!gmi_set_exec(h, binaryName, NULL))
 156            {
 157             printf("Error setting exec y args\n");
 158             mi_disconnect(h);
 159             ret = 1;
 160             return;
 161            }
 162
 163          /* Tell gdb to attach the child to a terminal. */
 164          if (!gmi_target_terminal(h, ttyname(STDIN_FILENO)))
 165            {
 166             printf("Error selecting target terminal\n");
 167             mi_disconnect(h);
 168             ret = 1;
 169             return;
 170            }
 171
 172          /* Run the program. */
 173          if (!gmi_exec_run(h))
 174            {
 175             printf("Error in run!\n");
 176             mi_disconnect(h);
 177             ret = 1;
 178             return;
 179            }
 180          /* Here we should be stopped when the program crashes */
 181          if (!wait_for_stop(h))
 182            {
 183             mi_disconnect(h);
 184             ret = 1;
 185             return;
 186            }
 187
 188          /* Continue execution. */
 189          if (!gmi_exec_continue(h))
 190            {
 191             printf("Error in continue!\n");
 192             mi_disconnect(h);
 193             ret = 1;
 194             return;
 195            }
 196          /* Here we should be terminated. */
 197          if (!wait_for_stop(h))
 198            {
 199             mi_disconnect(h);
 200             ret = 1;
 201             return;
 202            }
 203
 204          /* Exit from gdb. */
 205          gmi_gdb_exit(h);
 206          /* Close the connection. */
 207          mi_disconnect(h);
 208          /* Wait 5 seconds and close the auxiliar terminal. */
 209          printf("Waiting 5 seconds\n");
 210          sleep(5);
 211          gmi_end_aux_term(xterm_tty);
 212 }
 213
 214
 215 int main(int argc, char *argv[])
 216 {
 217         /*
 218          * FIXME:
 219          * Command should accept email address to which monkey sends the debugging report.
 220          * The email address can also be read from the configuration file.
 221          */
 222  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 223      {'m', "mode", NULL, gettext_noop ("monkey's mode of operation: options are \"text\" or \"email\""),
 224       GNUNET_YES, &GNUNET_GETOPT_set_string, &mode},
 225      {'b', "binary", NULL, gettext_noop ("binary for program to debug with monkey"),
 226       GNUNET_YES, &GNUNET_GETOPT_set_string, &binaryName},
 227      {'o', "output", NULL, gettext_noop ("path to file to dump monkey's output in case of working in text mode"),
 228       GNUNET_YES, &GNUNET_GETOPT_set_string, &dumpFileName},
 229       GNUNET_GETOPT_OPTION_END
 230    };
 231
 232  if (argc < 2) {
 233          printf("%s", "Monkey should take arguments: Use --help to get a list of options.\n");
 234          return 1;
 235  }
 236
 237  if (GNUNET_OK == GNUNET_PROGRAM_run (argc,
 238                        argv,
 239                        "gnunet-monkey",
 240                        gettext_noop
 241                        ("Automatically debug a service"),
 242                        options, &run, NULL))
 243      {
 244        return ret;
 245      }
 246
 247      return 1;
 248 }