gdb/remote-nrom.c

   1 /* Remote debugging with the XLNT Designs, Inc (XDI) NetROM.
   2    Copyright 1990, 1991, 1992, 1995 Free Software Foundation, Inc.
   3    Contributed by:
   4          Roger Moyers
   5          XLNT Designs, Inc.
   6          15050 Avenue of Science, Suite 106
   7          San Diego, CA  92128
   8          (619)487-9320
   9          roger@xlnt.com
  10    Adapted from work done at Cygnus Support in remote-nindy.c,
  11    later merged in by Stan Shebs at Cygnus.
  12
  13 This file is part of GDB.
  14
  15 This program is free software; you can redistribute it and/or modify
  16 it under the terms of the GNU General Public License as published by
  17 the Free Software Foundation; either version 2 of the License, or
  18 (at your option) any later version.
  19
  20 This program is distributed in the hope that it will be useful,
  21 but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 GNU General Public License for more details.
  24
  25 You should have received a copy of the GNU General Public License
  26 along with this program; if not, write to the Free Software
  27 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  28
  29 #include "defs.h"
  30 #include "gdbcmd.h"
  31 #include "serial.h"
  32 #include "target.h"
  33
  34 /* Default ports used to talk with the NetROM.  */
  35
  36 #define DEFAULT_NETROM_LOAD_PORT    1236
  37 #define DEFAULT_NETROM_CONTROL_PORT 1237
  38
  39 static void nrom_close PARAMS ((int quitting));
  40
  41 /* New commands.  */
  42
  43 static void nrom_passthru PARAMS ((char *, int));
  44
  45 /* We talk to the NetROM over these sockets.  */
  46
  47 static serial_t load_desc = NULL;
  48 static serial_t ctrl_desc = NULL;
  49
  50 static int load_port = DEFAULT_NETROM_LOAD_PORT;
  51 static int control_port = DEFAULT_NETROM_CONTROL_PORT;
  52
  53 static char nrom_hostname[100];
  54
  55 /* Forward data declaration. */
  56
  57 extern struct target_ops nrom_ops;
  58
  59 /* Scan input from the remote system, until STRING is found.  Print chars that
  60    don't match.  */
  61
  62 static int
  63 expect (string)
  64      char *string;
  65 {
  66   char *p = string;
  67   int c;
  68
  69   immediate_quit = 1;
  70
  71   while (1)
  72     {
  73       c = SERIAL_READCHAR (ctrl_desc, 5);
  74
  75       if (c == *p++)
  76         {
  77           if (*p == '\0')
  78             {
  79               immediate_quit = 0;
  80
  81               return 0;
  82             }
  83         }
  84       else
  85         {
  86           fputc_unfiltered (c, gdb_stdout);
  87           p = string;
  88           if (c == *p)
  89             p++;
  90         }
  91     }
  92 }
  93
  94 static void
  95 nrom_kill ()
  96 {
  97   nrom_close (0);
  98 }
  99
 100 static serial_t
 101 open_socket (name, port)
 102      char *name;
 103      int port;
 104 {
 105   char sockname[100];
 106   serial_t desc;
 107
 108   sprintf (sockname, "%s:%d", name, port);
 109   desc = SERIAL_OPEN (sockname);
 110   if (!desc)
 111     perror_with_name (sockname);
 112
 113   return desc;
 114 }
 115
 116 static void
 117 load_cleanup ()
 118 {
 119   SERIAL_CLOSE (load_desc);
 120   load_desc = NULL;
 121 }
 122
 123 /* Download a file specified in ARGS to the netROM.  */
 124
 125 static void
 126 nrom_load (args, fromtty)
 127      char *args;
 128      int fromtty;
 129 {
 130   int fd, rd_amt, fsize;
 131   bfd *pbfd;
 132   asection *section;
 133   char *downloadstring = "download 0\n";
 134   struct cleanup *old_chain;
 135
 136   /* Tell the netrom to get ready to download. */
 137   if (SERIAL_WRITE (ctrl_desc, downloadstring, strlen (downloadstring)))
 138     error ("nrom_load: control_send() of `%s' failed", downloadstring);
 139
 140   expect ("Waiting for a connection...\n");
 141
 142   load_desc = open_socket (nrom_hostname, load_port);
 143
 144   old_chain = make_cleanup (load_cleanup, 0);
 145
 146   pbfd = bfd_openr (args, 0);
 147
 148   if (pbfd)
 149     {
 150       make_cleanup (bfd_close, pbfd);
 151
 152       if (!bfd_check_format (pbfd, bfd_object))
 153         error ("\"%s\": not in executable format: %s",
 154                args, bfd_errmsg (bfd_get_error ()));
 155
 156       for (section = pbfd->sections; section; section = section->next)
 157         {
 158           if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC)
 159             {
 160               bfd_vma section_address;
 161               unsigned long section_size;
 162               const char *section_name;
 163
 164               section_name = bfd_get_section_name (pbfd, section);
 165               section_address = bfd_get_section_vma (pbfd, section);
 166               section_size = bfd_section_size (pbfd, section);
 167
 168               if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
 169                 {
 170                   file_ptr fptr;
 171
 172                   printf_filtered ("[Loading section %s at %x (%d bytes)]\n",
 173                                    section_name, section_address,
 174                                    section_size);
 175
 176                   fptr = 0;
 177
 178                   while (section_size > 0)
 179                     {
 180                       char buffer[1024];
 181                       int count;
 182
 183                       count = min (section_size, 1024);
 184
 185                       bfd_get_section_contents (pbfd, section, buffer, fptr,
 186                                                 count);
 187
 188                       SERIAL_WRITE (load_desc, buffer, count);
 189                       section_address += count;
 190                       fptr += count;
 191                       section_size -= count;
 192                     }
 193                 }
 194               else                      /* BSS and such */
 195                 {
 196                   printf_filtered ("[section %s: not loading]\n",
 197                                    section_name);
 198                 }
 199             }
 200         }
 201     }
 202   else
 203     error ("\"%s\": Could not open", args);
 204
 205   do_cleanups (old_chain);
 206 }
 207
 208 /* Open a connection to the remote NetROM devices.  */
 209
 210 static void
 211 nrom_open (name, from_tty)
 212      char *name;
 213      int from_tty;
 214 {
 215   int errn;
 216
 217   if (!name || strchr (name, '/') || strchr (name, ':'))
 218     error (
 219 "To open a NetROM connection, you must specify the hostname\n\
 220 or IP address of the NetROM device you wish to use.");
 221
 222   strcpy (nrom_hostname, name);
 223
 224   target_preopen (from_tty);
 225
 226   unpush_target (&nrom_ops);
 227
 228   ctrl_desc = open_socket (nrom_hostname, control_port);
 229
 230   push_target (&nrom_ops);
 231
 232   if (from_tty)
 233     printf_filtered ("Connected to NetROM device \"%s\"\n", nrom_hostname);
 234 }
 235
 236 /* Close out all files and local state before this target loses control. */
 237
 238 static void
 239 nrom_close (quitting)
 240      int quitting;
 241 {
 242   if (load_desc)
 243     SERIAL_CLOSE (load_desc);
 244   if (ctrl_desc)
 245     SERIAL_CLOSE (ctrl_desc);
 246 }
 247
 248 /* Pass arguments directly to the NetROM. */
 249
 250 static void
 251 nrom_passthru (args, fromtty)
 252      char *args;
 253      int fromtty;
 254 {
 255   char buf[1024];
 256
 257   sprintf (buf, "%s\n", args);
 258   if (SERIAL_WRITE (ctrl_desc, buf, strlen (buf)))
 259     error ("nrom_reset: control_send() of `%s'failed", args);
 260 }
 261
 262 static void
 263 nrom_mourn()
 264 {
 265   unpush_target (&nrom_ops);
 266   generic_mourn_inferior ();
 267 }
 268
 269 /* Define the target vector. */
 270
 271 struct target_ops nrom_ops ;
 272
 273 static void
 274 init_nrom_ops(void)
 275 {
 276   nrom_ops.to_shortname =   "nrom";
 277   nrom_ops.to_longname =   "Remote XDI `NetROM' target";
 278   nrom_ops.to_doc =   "Remote debug using a NetROM over Ethernet";
 279   nrom_ops.to_open =   nrom_open;
 280   nrom_ops.to_close =   nrom_close;
 281   nrom_ops.to_attach =   NULL;
 282   nrom_ops.to_post_attach = NULL;
 283   nrom_ops.to_require_attach = NULL;
 284   nrom_ops.to_detach =   NULL;
 285   nrom_ops.to_require_detach = NULL;
 286   nrom_ops.to_resume =   NULL;
 287   nrom_ops.to_wait  =   NULL;
 288   nrom_ops.to_post_wait = NULL;
 289   nrom_ops.to_fetch_registers  =   NULL;
 290   nrom_ops.to_store_registers  =   NULL;
 291   nrom_ops.to_prepare_to_store =   NULL;
 292   nrom_ops.to_xfer_memory  =   NULL;
 293   nrom_ops.to_files_info  =   NULL;
 294   nrom_ops.to_insert_breakpoint =   NULL;
 295   nrom_ops.to_remove_breakpoint =   NULL;
 296   nrom_ops.to_terminal_init  =   NULL;
 297   nrom_ops.to_terminal_inferior =   NULL;
 298   nrom_ops.to_terminal_ours_for_output =   NULL;
 299   nrom_ops.to_terminal_ours  =   NULL;
 300   nrom_ops.to_terminal_info  =   NULL;
 301   nrom_ops.to_kill  =   nrom_kill;
 302   nrom_ops.to_load  =   nrom_load;
 303   nrom_ops.to_lookup_symbol =   NULL;
 304   nrom_ops.to_create_inferior =   NULL;
 305   nrom_ops.to_post_startup_inferior = NULL;
 306   nrom_ops.to_acknowledge_created_inferior = NULL;
 307   nrom_ops.to_clone_and_follow_inferior = NULL;
 308   nrom_ops.to_post_follow_inferior_by_clone = NULL;
 309   nrom_ops.to_insert_fork_catchpoint = NULL;
 310   nrom_ops.to_remove_fork_catchpoint = NULL;
 311   nrom_ops.to_insert_vfork_catchpoint = NULL;
 312   nrom_ops.to_remove_vfork_catchpoint = NULL;
 313   nrom_ops.to_has_forked = NULL;
 314   nrom_ops.to_has_vforked = NULL;
 315   nrom_ops.to_can_follow_vfork_prior_to_exec = NULL;
 316   nrom_ops.to_post_follow_vfork = NULL;
 317   nrom_ops.to_insert_exec_catchpoint = NULL;
 318   nrom_ops.to_remove_exec_catchpoint = NULL;
 319   nrom_ops.to_has_execd = NULL;
 320   nrom_ops.to_reported_exec_events_per_exec_call = NULL;
 321   nrom_ops.to_has_exited = NULL;
 322   nrom_ops.to_mourn_inferior =   nrom_mourn;
 323   nrom_ops.to_can_run  =   NULL;
 324   nrom_ops.to_notice_signals =   0;
 325   nrom_ops.to_thread_alive  =   0;
 326   nrom_ops.to_stop  =   0;
 327   nrom_ops.to_pid_to_exec_file = NULL;
 328   nrom_ops.to_core_file_to_sym_file = NULL;
 329   nrom_ops.to_stratum =   download_stratum;
 330   nrom_ops.DONT_USE =   NULL;
 331   nrom_ops.to_has_all_memory =   1;
 332   nrom_ops.to_has_memory =   1;
 333   nrom_ops.to_has_stack =   1;
 334   nrom_ops.to_has_registers =   1;
 335   nrom_ops.to_has_execution =   0;
 336   nrom_ops.to_sections =   NULL;
 337   nrom_ops.to_sections_end =   NULL;
 338   nrom_ops.to_magic =   OPS_MAGIC ;
 339 };
 340
 341 void
 342 _initialize_remote_nrom ()
 343 {
 344   init_nrom_ops() ;
 345   add_target (&nrom_ops);
 346
 347   add_show_from_set (
 348     add_set_cmd ("nrom_load_port", no_class, var_zinteger, (char *)&load_port,
 349                  "Set the port to use for NetROM downloads\n", &setlist),
 350                      &showlist);
 351
 352   add_show_from_set (
 353     add_set_cmd ("nrom_control_port", no_class, var_zinteger, (char *)&control_port,
 354                  "Set the port to use for NetROM debugger services\n", &setlist),
 355                      &showlist);
 356
 357   add_cmd ("nrom", no_class, nrom_passthru,
 358            "Pass arguments as command to NetROM",
 359            &cmdlist);
 360 }