[deliverable/binutils-gdb.git] / gdb / remote-nrom.c

/* Remote debugging with the XLNT Designs, Inc (XDI) NetROM.
   Copyright 1990, 1991, 1992, 1995 Free Software Foundation, Inc.
   Contributed by:
   Roger Moyers 
   XLNT Designs, Inc.
   15050 Avenue of Science, Suite 106
   San Diego, CA  92128
   (619)487-9320
   roger@xlnt.com
   Adapted from work done at Cygnus Support in remote-nindy.c,
   later merged in by Stan Shebs at Cygnus.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "gdbcmd.h"
#include "serial.h"
#include "target.h"

/* Default ports used to talk with the NetROM.  */

#define DEFAULT_NETROM_LOAD_PORT    1236
#define DEFAULT_NETROM_CONTROL_PORT 1237

static void nrom_close (int quitting);

/* New commands.  */

static void nrom_passthru (char *, int);

/* We talk to the NetROM over these sockets.  */

static serial_t load_desc = NULL;
static serial_t ctrl_desc = NULL;

static int load_port = DEFAULT_NETROM_LOAD_PORT;
static int control_port = DEFAULT_NETROM_CONTROL_PORT;

static char nrom_hostname[100];

/* Forward data declaration. */

extern struct target_ops nrom_ops;

/* Scan input from the remote system, until STRING is found.  Print chars that
   don't match.  */

static int
expect (char *string)
{
  char *p = string;
  int c;

  immediate_quit = 1;

  while (1)
    {
      c = SERIAL_READCHAR (ctrl_desc, 5);

      if (c == *p++)
	{
	  if (*p == '\0')
	    {
	      immediate_quit = 0;

	      return 0;
	    }
	}
      else
	{
	  fputc_unfiltered (c, gdb_stdout);
	  p = string;
	  if (c == *p)
	    p++;
	}
    }
}

static void
nrom_kill (void)
{
  nrom_close (0);
}

static serial_t
open_socket (char *name, int port)
{
  char sockname[100];
  serial_t desc;

  sprintf (sockname, "%s:%d", name, port);
  desc = SERIAL_OPEN (sockname);
  if (!desc)
    perror_with_name (sockname);

  return desc;
}

static void
load_cleanup (void)
{
  SERIAL_CLOSE (load_desc);
  load_desc = NULL;
}

/* Download a file specified in ARGS to the netROM.  */

static void
nrom_load (char *args, int fromtty)
{
  int fd, rd_amt, fsize;
  bfd *pbfd;
  asection *section;
  char *downloadstring = "download 0\n";
  struct cleanup *old_chain;

  /* Tell the netrom to get ready to download. */
  if (SERIAL_WRITE (ctrl_desc, downloadstring, strlen (downloadstring)))
    error ("nrom_load: control_send() of `%s' failed", downloadstring);

  expect ("Waiting for a connection...\n");

  load_desc = open_socket (nrom_hostname, load_port);

  old_chain = make_cleanup (load_cleanup, 0);

  pbfd = bfd_openr (args, 0);

  if (pbfd)
    {
      make_cleanup (bfd_close, pbfd);

      if (!bfd_check_format (pbfd, bfd_object))
	error ("\"%s\": not in executable format: %s",
	       args, bfd_errmsg (bfd_get_error ()));

      for (section = pbfd->sections; section; section = section->next)
	{
	  if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC)
	    {
	      bfd_vma section_address;
	      unsigned long section_size;
	      const char *section_name;

	      section_name = bfd_get_section_name (pbfd, section);
	      section_address = bfd_get_section_vma (pbfd, section);
	      section_size = bfd_section_size (pbfd, section);

	      if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
		{
		  file_ptr fptr;

		  printf_filtered ("[Loading section %s at %x (%d bytes)]\n",
				   section_name, section_address,
				   section_size);

		  fptr = 0;

		  while (section_size > 0)
		    {
		      char buffer[1024];
		      int count;

		      count = min (section_size, 1024);

		      bfd_get_section_contents (pbfd, section, buffer, fptr,
						count);

		      SERIAL_WRITE (load_desc, buffer, count);
		      section_address += count;
		      fptr += count;
		      section_size -= count;
		    }
		}
	      else
		/* BSS and such */
		{
		  printf_filtered ("[section %s: not loading]\n",
				   section_name);
		}
	    }
	}
    }
  else
    error ("\"%s\": Could not open", args);

  do_cleanups (old_chain);
}

/* Open a connection to the remote NetROM devices.  */

static void
nrom_open (char *name, int from_tty)
{
  int errn;

  if (!name || strchr (name, '/') || strchr (name, ':'))
    error (
	    "To open a NetROM connection, you must specify the hostname\n\
or IP address of the NetROM device you wish to use.");

  strcpy (nrom_hostname, name);

  target_preopen (from_tty);

  unpush_target (&nrom_ops);

  ctrl_desc = open_socket (nrom_hostname, control_port);

  push_target (&nrom_ops);

  if (from_tty)
    printf_filtered ("Connected to NetROM device \"%s\"\n", nrom_hostname);
}

/* Close out all files and local state before this target loses control. */

static void
nrom_close (int quitting)
{
  if (load_desc)
    SERIAL_CLOSE (load_desc);
  if (ctrl_desc)
    SERIAL_CLOSE (ctrl_desc);
}

/* Pass arguments directly to the NetROM. */

static void
nrom_passthru (char *args, int fromtty)
{
  char buf[1024];

  sprintf (buf, "%s\n", args);
  if (SERIAL_WRITE (ctrl_desc, buf, strlen (buf)))
    error ("nrom_reset: control_send() of `%s'failed", args);
}

static void
nrom_mourn (void)
{
  unpush_target (&nrom_ops);
  generic_mourn_inferior ();
}

/* Define the target vector. */

struct target_ops nrom_ops;

static void
init_nrom_ops (void)
{
  nrom_ops.to_shortname = "nrom";
  nrom_ops.to_longname = "Remote XDI `NetROM' target";
  nrom_ops.to_doc = "Remote debug using a NetROM over Ethernet";
  nrom_ops.to_open = nrom_open;
  nrom_ops.to_close = nrom_close;
  nrom_ops.to_attach = NULL;
  nrom_ops.to_post_attach = NULL;
  nrom_ops.to_require_attach = NULL;
  nrom_ops.to_detach = NULL;
  nrom_ops.to_require_detach = NULL;
  nrom_ops.to_resume = NULL;
  nrom_ops.to_wait = NULL;
  nrom_ops.to_post_wait = NULL;
  nrom_ops.to_fetch_registers = NULL;
  nrom_ops.to_store_registers = NULL;
  nrom_ops.to_prepare_to_store = NULL;
  nrom_ops.to_xfer_memory = NULL;
  nrom_ops.to_files_info = NULL;
  nrom_ops.to_insert_breakpoint = NULL;
  nrom_ops.to_remove_breakpoint = NULL;
  nrom_ops.to_terminal_init = NULL;
  nrom_ops.to_terminal_inferior = NULL;
  nrom_ops.to_terminal_ours_for_output = NULL;
  nrom_ops.to_terminal_ours = NULL;
  nrom_ops.to_terminal_info = NULL;
  nrom_ops.to_kill = nrom_kill;
  nrom_ops.to_load = nrom_load;
  nrom_ops.to_lookup_symbol = NULL;
  nrom_ops.to_create_inferior = NULL;
  nrom_ops.to_post_startup_inferior = NULL;
  nrom_ops.to_acknowledge_created_inferior = NULL;
  nrom_ops.to_clone_and_follow_inferior = NULL;
  nrom_ops.to_post_follow_inferior_by_clone = NULL;
  nrom_ops.to_insert_fork_catchpoint = NULL;
  nrom_ops.to_remove_fork_catchpoint = NULL;
  nrom_ops.to_insert_vfork_catchpoint = NULL;
  nrom_ops.to_remove_vfork_catchpoint = NULL;
  nrom_ops.to_has_forked = NULL;
  nrom_ops.to_has_vforked = NULL;
  nrom_ops.to_can_follow_vfork_prior_to_exec = NULL;
  nrom_ops.to_post_follow_vfork = NULL;
  nrom_ops.to_insert_exec_catchpoint = NULL;
  nrom_ops.to_remove_exec_catchpoint = NULL;
  nrom_ops.to_has_execd = NULL;
  nrom_ops.to_reported_exec_events_per_exec_call = NULL;
  nrom_ops.to_has_exited = NULL;
  nrom_ops.to_mourn_inferior = nrom_mourn;
  nrom_ops.to_can_run = NULL;
  nrom_ops.to_notice_signals = 0;
  nrom_ops.to_thread_alive = 0;
  nrom_ops.to_stop = 0;
  nrom_ops.to_pid_to_exec_file = NULL;
  nrom_ops.to_core_file_to_sym_file = NULL;
  nrom_ops.to_stratum = download_stratum;
  nrom_ops.DONT_USE = NULL;
  nrom_ops.to_has_all_memory = 1;
  nrom_ops.to_has_memory = 1;
  nrom_ops.to_has_stack = 1;
  nrom_ops.to_has_registers = 1;
  nrom_ops.to_has_execution = 0;
  nrom_ops.to_sections = NULL;
  nrom_ops.to_sections_end = NULL;
  nrom_ops.to_magic = OPS_MAGIC;
};

void
_initialize_remote_nrom (void)
{
  init_nrom_ops ();
  add_target (&nrom_ops);

  add_show_from_set (
  add_set_cmd ("nrom_load_port", no_class, var_zinteger, (char *) &load_port,
	       "Set the port to use for NetROM downloads\n", &setlist),
		      &showlist);

  add_show_from_set (
		      add_set_cmd ("nrom_control_port", no_class, var_zinteger, (char *) &control_port,
	    "Set the port to use for NetROM debugger services\n", &setlist),
		      &showlist);

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