Merge GDB 7.5.1

gdb/gdbserver/remote-utils.c

 /* Remote utility routines for the remote server for GDB.
    Copyright (C) 1986, 1989, 1993-2012 Free Software Foundation, Inc.
 
    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 3 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, see <http://www.gnu.org/licenses/>.  */
 
 #include "server.h"
 #include "terminal.h"
 #include "target.h"
+#include "gdbthread.h"
 #include <stdio.h>
 #include <string.h>
 #if HAVE_SYS_IOCTL_H
 #include <sys/ioctl.h>
 #endif
 #if HAVE_SYS_FILE_H
 #include <sys/file.h>
 #endif
 #if HAVE_NETINET_IN_H
 #include <netinet/in.h>
@@ skipping 66 matching lines @@
 struct sym_cache
 {
   char *name;
   CORE_ADDR addr;
   struct sym_cache *next;
 };
 
 int remote_debug = 0;
 struct ui_file *gdb_stdlog;
 
+static int remote_is_stdio = 0;
+
 static gdb_fildes_t remote_desc = INVALID_DESCRIPTOR;
 static gdb_fildes_t listen_desc = INVALID_DESCRIPTOR;
 
 /* FIXME headerize? */
 extern int using_threads;
 extern int debug_threads;
 
 /* If true, then GDB has requested noack mode.  */
 int noack_mode = 0;
 /* If true, then we tell GDB to use noack mode by default.  */
 int transport_is_reliable = 0;
 
 #ifdef USE_WIN32API
 # define read(fd, buf, len) recv (fd, (char *) buf, len, 0)
 # define write(fd, buf, len) send (fd, (char *) buf, len, 0)
 #endif
 
 int
 gdb_connected (void)
 {
   return remote_desc != INVALID_DESCRIPTOR;
 }
 
+/* Return true if the remote connection is over stdio.  */
+
+int
+remote_connection_is_stdio (void)
+{
+  return remote_is_stdio;
+}
+
 static void
 enable_async_notification (int fd)
 {
 #if defined(F_SETFL) && defined (FASYNC)
   int save_fcntl_flags;
 
   save_fcntl_flags = fcntl (fd, F_GETFL, 0);
   fcntl (fd, F_SETFL, save_fcntl_flags | FASYNC);
 #if defined (F_SETOWN)
   fcntl (fd, F_SETOWN, getpid ());
@@ skipping 72 matching lines @@
 {
   char *port_str;
 #ifdef USE_WIN32API
   static int winsock_initialized;
 #endif
   int port;
   struct sockaddr_in sockaddr;
   socklen_t tmp;
   char *port_end;
 
+  remote_is_stdio = 0;
+  if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
+    {
+      /* We need to record fact that we're using stdio sooner than the
+         call to remote_open so start_inferior knows the connection is
+         via stdio.  */
+      remote_is_stdio = 1;
+      transport_is_reliable = 1;
+      return;
+    }
+
   port_str = strchr (name, ':');
   if (port_str == NULL)
     {
       transport_is_reliable = 0;
       return;
     }
 
   port = strtoul (port_str + 1, &port_end, 10);
   if (port_str[1] == '\0' || *port_end != '\0')
     fatal ("Bad port argument: %s", name);
@@ skipping 30 matching lines @@
 
 /* Open a connection to a remote debugger.
    NAME is the filename used for communication.  */
 
 void
 remote_open (char *name)
 {
   char *port_str;
 
   port_str = strchr (name, ':');
+#ifdef USE_WIN32API
   if (port_str == NULL)
+    error ("Only <host>:<port> is supported on this platform.");
+#endif
+
+  if (strcmp (name, STDIO_CONNECTION_NAME) == 0)
     {
-#ifdef USE_WIN32API
-      error ("Only <host>:<port> is supported on this platform.");
-#else
+      fprintf (stderr, "Remote debugging using stdio\n");
+
+      /* Use stdin as the handle of the connection.
+         We only select on reads, for example.  */
+      remote_desc = fileno (stdin);
+
+      enable_async_notification (remote_desc);
+
+      /* Register the event loop handler.  */
+      add_file_handler (remote_desc, handle_serial_event, NULL);
+    }
+#ifndef USE_WIN32API
+  else if (port_str == NULL)
+    {
       struct stat statbuf;
 
       if (stat (name, &statbuf) == 0
           && (S_ISCHR (statbuf.st_mode) || S_ISFIFO (statbuf.st_mode)))
         remote_desc = open (name, O_RDWR);
       else
         {
           errno = EINVAL;
           remote_desc = -1;
         }
@@ skipping 44 matching lines @@
         ioctl (remote_desc, TIOCSETP, &sg);
       }
 #endif
 
       fprintf (stderr, "Remote debugging using %s\n", name);
 
       enable_async_notification (remote_desc);
 
       /* Register the event loop handler.  */
       add_file_handler (remote_desc, handle_serial_event, NULL);
+    }
 #endif /* USE_WIN32API */
-    }
   else
     {
       int port;
       socklen_t len;
       struct sockaddr_in sockaddr;
 
       len = sizeof (sockaddr);
       if (getsockname (listen_desc,
                        (struct sockaddr *) &sockaddr, &len) < 0
           || len < sizeof (sockaddr))
         perror_with_name ("Can't determine port");
       port = ntohs (sockaddr.sin_port);
 
       fprintf (stderr, "Listening on port %d\n", port);
       fflush (stderr);
 
       /* Register the event loop handler.  */
       add_file_handler (listen_desc, handle_accept_event, NULL);
     }
 }
 
 void
 remote_close (void)
 {
   delete_file_handler (remote_desc);
 
 #ifdef USE_WIN32API
   closesocket (remote_desc);
 #else
-  close (remote_desc);
+  if (! remote_connection_is_stdio ())
+    close (remote_desc);
 #endif
   remote_desc = INVALID_DESCRIPTOR;
 
   reset_readchar ();
 }
 
 /* Convert hex digit A to a number.  */
 
 static int
 fromhex (int a)
@@ skipping 338 matching lines @@
 
   /* Since the stub is not sending a process id, then default to
      what's in the current inferior.  */
   pid = ptid_get_pid (((struct inferior_list_entry *) current_inferior)->id);
 
   if (obuf)
     *obuf = pp;
   return ptid_build (pid, tid, 0);
 }
 
+/* Write COUNT bytes in BUF to the client.
+   The result is the number of bytes written or -1 if error.
+   This may return less than COUNT.  */
+
+static int
+write_prim (const void *buf, int count)
+{
+  if (remote_connection_is_stdio ())
+    return write (fileno (stdout), buf, count);
+  else
+    return write (remote_desc, buf, count);
+}
+
+/* Read COUNT bytes from the client and store in BUF.
+   The result is the number of bytes read or -1 if error.
+   This may return less than COUNT.  */
+
+static int
+read_prim (void *buf, int count)
+{
+  if (remote_connection_is_stdio ())
+    return read (fileno (stdin), buf, count);
+  else
+    return read (remote_desc, buf, count);
+}
+
 /* Send a packet to the remote machine, with error checking.
    The data of the packet is in BUF, and the length of the
    packet is in CNT.  Returns >= 0 on success, -1 otherwise.  */
 
 static int
 putpkt_binary_1 (char *buf, int cnt, int is_notif)
 {
   int i;
   unsigned char csum = 0;
   char *buf2;
@@ skipping 17 matching lines @@
   *p++ = '#';
   *p++ = tohex ((csum >> 4) & 0xf);
   *p++ = tohex (csum & 0xf);
 
   *p = '\0';
 
   /* Send it over and over until we get a positive ack.  */
 
   do
     {
-      if (write (remote_desc, buf2, p - buf2) != p - buf2)
+      if (write_prim (buf2, p - buf2) != p - buf2)
         {
           perror ("putpkt(write)");
           free (buf2);
           return -1;
         }
 
       if (noack_mode || is_notif)
         {
           /* Don't expect an ack then.  */
           if (remote_debug)
@@ skipping 74 matching lines @@
   /* Protect against spurious interrupts.  This has been observed to
      be a problem under NetBSD 1.4 and 1.5.  */
 
   FD_ZERO (&readset);
   FD_SET (remote_desc, &readset);
   if (select (remote_desc + 1, &readset, 0, 0, &immediate) > 0)
     {
       int cc;
       char c = 0;
 
-      cc = read (remote_desc, &c, 1);
+      cc = read_prim (&c, 1);
 
       if (cc != 1 || c != '\003' || current_inferior == NULL)
         {
           fprintf (stderr, "input_interrupt, count = %d c = %d ('%c')\n",
                    cc, c, c);
           return;
         }
 
       (*the_target->request_interrupt) ();
     }
@@ skipping 107 matching lines @@
 
 /* Returns next char from remote GDB.  -1 if error.  */
 
 static int
 readchar (void)
 {
   int ch;
 
   if (readchar_bufcnt == 0)
     {
-      readchar_bufcnt = read (remote_desc, readchar_buf,
-                              sizeof (readchar_buf));
+      readchar_bufcnt = read_prim (readchar_buf, sizeof (readchar_buf));
 
       if (readchar_bufcnt <= 0)
         {
           if (readchar_bufcnt == 0)
             fprintf (stderr, "readchar: Got EOF\n");
           else
             perror ("readchar");
 
           return -1;
         }
@@ skipping 101 matching lines @@
           fprintf (stderr,
                    "Bad checksum, sentsum=0x%x, csum=0x%x, "
                    "buf=%s [no-ack-mode, Bad medium?]\n",
                    (c1 << 4) + c2, csum, buf);
           /* Not much we can do, GDB wasn't expecting an ack/nac.  */
           break;
         }
 
       fprintf (stderr, "Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
                (c1 << 4) + c2, csum, buf);
-      if (write (remote_desc, "-", 1) != 1)
+      if (write_prim ("-", 1) != 1)
         return -1;
     }
 
   if (!noack_mode)
     {
       if (remote_debug)
         {
           fprintf (stderr, "getpkt (\"%s\");  [sending ack] \n", buf);
           fflush (stderr);
         }
 
-      if (write (remote_desc, "+", 1) != 1)
+      if (write_prim ("+", 1) != 1)
         return -1;
 
       if (remote_debug)
         {
           fprintf (stderr, "[sent ack]\n");
           fflush (stderr);
         }
     }
   else
     {
@@ skipping 105 matching lines @@
   disable_async_io ();
   putpkt (own_buf);
   enable_async_io ();
 }
 
 void
 prepare_resume_reply (char *buf, ptid_t ptid,
                       struct target_waitstatus *status)
 {
   if (debug_threads)
-    fprintf (stderr, "Writing resume reply for %s:%d\n\n",
+    fprintf (stderr, "Writing resume reply for %s:%d\n",
              target_pid_to_str (ptid), status->kind);
 
   switch (status->kind)
     {
     case TARGET_WAITKIND_STOPPED:
       {
         struct thread_info *saved_inferior;
         const char **regp;
         struct regcache *regcache;
 
@@ skipping 56 matching lines @@
                 /* In non-stop, don't change the general thread behind
                    GDB's back.  */
                 if (!non_stop)
                   general_thread = ptid;
                 sprintf (buf, "thread:");
                 buf += strlen (buf);
                 buf = write_ptid (buf, ptid);
                 strcat (buf, ";");
                 buf += strlen (buf);
 
-                if (the_target->core_of_thread)
-                  core = (*the_target->core_of_thread) (ptid);
+                core = target_core_of_thread (ptid);
+
                 if (core != -1)
                   {
                     sprintf (buf, "core:");
                     buf += strlen (buf);
                     sprintf (buf, "%x", core);
                     strcat (buf, ";");
                     buf += strlen (buf);
                   }
               }
           }
@@ skipping 364 matching lines @@
   char *buf = xmalloc (strlen (msg) * 2 + 2);
 
   buf[0] = 'O';
   hexify (buf + 1, msg, 0);
 
   putpkt (buf);
   free (buf);
 }
 
 #endif