gdb/ser-pipe.c

   1 /* Serial interface for a pipe to a separate program
   2    Copyright (C) 1999, 2000, 2001, 2007, 2008, 2009, 2010, 2011
   3    Free Software Foundation, Inc.
   4
   5    Contributed by Cygnus Solutions.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "serial.h"
  24 #include "ser-base.h"
  25 #include "ser-unix.h"
  26
  27 #include "gdb_vfork.h"
  28
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/time.h>
  32 #include <fcntl.h>
  33 #include "gdb_string.h"
  34 #include "gdb_wait.h"
  35
  36 #include <signal.h>
  37
  38 static int pipe_open (struct serial *scb, const char *name);
  39 static void pipe_close (struct serial *scb);
  40
  41 extern void _initialize_ser_pipe (void);
  42
  43 struct pipe_state
  44   {
  45     int pid;
  46   };
  47
  48 /* Open up a raw pipe.  */
  49
  50 static int
  51 pipe_open (struct serial *scb, const char *name)
  52 {
  53 #if !HAVE_SOCKETPAIR
  54   return -1;
  55 #else
  56   struct pipe_state *state;
  57   /* This chunk: */
  58   /* Copyright (c) 1988, 1993
  59    *      The Regents of the University of California.  All rights reserved.
  60    *
  61    * This code is derived from software written by Ken Arnold and
  62    * published in UNIX Review, Vol. 6, No. 8.
  63    */
  64   int pdes[2];
  65   int err_pdes[2];
  66   int pid;
  67
  68   if (socketpair (AF_UNIX, SOCK_STREAM, 0, pdes) < 0)
  69     return -1;
  70   if (socketpair (AF_UNIX, SOCK_STREAM, 0, err_pdes) < 0)
  71     {
  72       close (pdes[0]);
  73       close (pdes[1]);
  74       return -1;
  75     }
  76
  77   /* Create the child process to run the command in.  Note that the
  78      apparent call to vfork() below *might* actually be a call to
  79      fork() due to the fact that autoconf will ``#define vfork fork''
  80      on certain platforms.  */
  81   pid = vfork ();
  82
  83   /* Error.  */
  84   if (pid == -1)
  85     {
  86       close (pdes[0]);
  87       close (pdes[1]);
  88       close (err_pdes[0]);
  89       close (err_pdes[1]);
  90       return -1;
  91     }
  92
  93   if (fcntl (err_pdes[0], F_SETFL, O_NONBLOCK) == -1)
  94     {
  95       close (err_pdes[0]);
  96       close (err_pdes[1]);
  97       err_pdes[0] = err_pdes[1] = -1;
  98     }
  99
 100   /* Child.  */
 101   if (pid == 0)
 102     {
 103       /* We don't want ^c to kill the connection.  */
 104 #ifdef HAVE_SETSID
 105       pid_t sid = setsid ();
 106       if (sid == -1)
 107         signal (SIGINT, SIG_IGN);
 108 #else
 109       signal (SIGINT, SIG_IGN);
 110 #endif
 111
 112       /* Re-wire pdes[1] to stdin/stdout.  */
 113       close (pdes[0]);
 114       if (pdes[1] != STDOUT_FILENO)
 115         {
 116           dup2 (pdes[1], STDOUT_FILENO);
 117           close (pdes[1]);
 118         }
 119       dup2 (STDOUT_FILENO, STDIN_FILENO);
 120
 121       if (err_pdes[0] != -1)
 122         {
 123           close (err_pdes[0]);
 124           dup2 (err_pdes[1], STDERR_FILENO);
 125           close (err_pdes[1]);
 126         }
 127 #if 0
 128       /* close any stray FD's - FIXME - how?  */
 129       /* POSIX.2 B.3.2.2 "popen() shall ensure that any streams
 130          from previous popen() calls that remain open in the
 131          parent process are closed in the new child process.  */
 132       for (old = pidlist; old; old = old->next)
 133         close (fileno (old->fp));       /* Don't allow a flush.  */
 134 #endif
 135       execl ("/bin/sh", "sh", "-c", name, (char *) 0);
 136       _exit (127);
 137     }
 138
 139   /* Parent.  */
 140   close (pdes[1]);
 141   if (err_pdes[1] != -1)
 142     close (err_pdes[1]);
 143   /* :end chunk */
 144   state = XMALLOC (struct pipe_state);
 145   state->pid = pid;
 146   scb->fd = pdes[0];
 147   scb->error_fd = err_pdes[0];
 148   scb->state = state;
 149
 150   /* If we don't do this, GDB simply exits when the remote side dies.  */
 151   signal (SIGPIPE, SIG_IGN);
 152   return 0;
 153 #endif
 154 }
 155
 156 static void
 157 pipe_close (struct serial *scb)
 158 {
 159   struct pipe_state *state = scb->state;
 160
 161   close (scb->fd);
 162   scb->fd = -1;
 163
 164   if (state != NULL)
 165     {
 166       int status;
 167       kill (state->pid, SIGTERM);
 168 #ifdef HAVE_WAITPID
 169       /* Assume the program will exit after SIGTERM.  Might be
 170          useful to print any remaining stderr output from
 171          scb->error_fd while waiting.  */
 172       waitpid (state->pid, &status, 0);
 173 #endif
 174       if (scb->error_fd != -1)
 175         close (scb->error_fd);
 176       scb->error_fd = -1;
 177       xfree (state);
 178       scb->state = NULL;
 179     }
 180 }
 181
 182 int
 183 gdb_pipe (int pdes[2])
 184 {
 185 #if !HAVE_SOCKETPAIR
 186   errno = ENOSYS;
 187   return -1;
 188 #else
 189
 190   if (socketpair (AF_UNIX, SOCK_STREAM, 0, pdes) < 0)
 191     return -1;
 192
 193   /* If we don't do this, GDB simply exits when the remote side
 194      dies.  */
 195   signal (SIGPIPE, SIG_IGN);
 196   return 0;
 197 #endif
 198 }
 199
 200 void
 201 _initialize_ser_pipe (void)
 202 {
 203   struct serial_ops *ops = XMALLOC (struct serial_ops);
 204
 205   memset (ops, 0, sizeof (struct serial_ops));
 206   ops->name = "pipe";
 207   ops->next = 0;
 208   ops->open = pipe_open;
 209   ops->close = pipe_close;
 210   ops->readchar = ser_base_readchar;
 211   ops->write = ser_base_write;
 212   ops->flush_output = ser_base_flush_output;
 213   ops->flush_input = ser_base_flush_input;
 214   ops->send_break = ser_base_send_break;
 215   ops->go_raw = ser_base_raw;
 216   ops->get_tty_state = ser_base_get_tty_state;
 217   ops->copy_tty_state = ser_base_copy_tty_state;
 218   ops->set_tty_state = ser_base_set_tty_state;
 219   ops->print_tty_state = ser_base_print_tty_state;
 220   ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
 221   ops->setbaudrate = ser_base_setbaudrate;
 222   ops->setstopbits = ser_base_setstopbits;
 223   ops->drain_output = ser_base_drain_output;
 224   ops->async = ser_base_async;
 225   ops->read_prim = ser_unix_read_prim;
 226   ops->write_prim = ser_unix_write_prim;
 227   serial_add_interface (ops);
 228 }