← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gdb/quantal

« back to all changes in this revision

Viewing changes to .pc/linaro-gdb.patch/gdb/ser-pipe.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2011-03-15 16:14:08 UTC
  • Revision ID: james.westby@ubuntu.com-20110315161408-o3sk4typcfgzuiqb
Tags: 7.2-1ubuntu10
* Update with changes from the Linaro 7.2-2011.03-0 release (Ulrich Weigand).
* Configure with --with-pkgversion, don't run post-patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/linaro-gdb.patch/gdb/ser-pipe.c
 
1
/* Serial interface for a pipe to a separate program
 
2
   Copyright (C) 1999, 2000, 2001, 2007, 2008, 2009, 2010
 
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
 
 
35
#include <signal.h>
 
36
 
 
37
static int pipe_open (struct serial *scb, const char *name);
 
38
static void pipe_close (struct serial *scb);
 
39
 
 
40
extern void _initialize_ser_pipe (void);
 
41
 
 
42
struct pipe_state
 
43
  {
 
44
    int pid;
 
45
  };
 
46
 
 
47
/* Open up a raw pipe */
 
48
 
 
49
static int
 
50
pipe_open (struct serial *scb, const char *name)
 
51
{
 
52
#if !HAVE_SOCKETPAIR
 
53
  return -1;
 
54
#else
 
55
  struct pipe_state *state;
 
56
  /* This chunk: */
 
57
  /* Copyright (c) 1988, 1993
 
58
   *      The Regents of the University of California.  All rights reserved.
 
59
   *
 
60
   * This code is derived from software written by Ken Arnold and
 
61
   * published in UNIX Review, Vol. 6, No. 8.
 
62
   */
 
63
  int pdes[2];
 
64
  int err_pdes[2];
 
65
  int pid;
 
66
 
 
67
  if (socketpair (AF_UNIX, SOCK_STREAM, 0, pdes) < 0)
 
68
    return -1;
 
69
  if (socketpair (AF_UNIX, SOCK_STREAM, 0, err_pdes) < 0)
 
70
    {
 
71
      close (pdes[0]);
 
72
      close (pdes[1]);
 
73
      return -1;
 
74
    }
 
75
 
 
76
  /* Create the child process to run the command in.  Note that the
 
77
     apparent call to vfork() below *might* actually be a call to
 
78
     fork() due to the fact that autoconf will ``#define vfork fork''
 
79
     on certain platforms.  */
 
80
  pid = vfork ();
 
81
  
 
82
  /* Error. */
 
83
  if (pid == -1)
 
84
    {
 
85
      close (pdes[0]);
 
86
      close (pdes[1]);
 
87
      close (err_pdes[0]);
 
88
      close (err_pdes[1]);
 
89
      return -1;
 
90
    }
 
91
 
 
92
  if (fcntl (err_pdes[0], F_SETFL, O_NONBLOCK) == -1)
 
93
    {
 
94
      close (err_pdes[0]);
 
95
      close (err_pdes[1]);
 
96
      err_pdes[0] = err_pdes[1] = -1;
 
97
    }
 
98
 
 
99
  /* Child. */
 
100
  if (pid == 0)
 
101
    {
 
102
      /* We don't want ^c to kill the connection.  */
 
103
#ifdef HAVE_SETSID
 
104
      pid_t sid = setsid ();
 
105
      if (sid == -1)
 
106
        signal (SIGINT, SIG_IGN);
 
107
#else
 
108
      signal (SIGINT, SIG_IGN);
 
109
#endif
 
110
 
 
111
      /* re-wire pdes[1] to stdin/stdout */
 
112
      close (pdes[0]);
 
113
      if (pdes[1] != STDOUT_FILENO)
 
114
        {
 
115
          dup2 (pdes[1], STDOUT_FILENO);
 
116
          close (pdes[1]);
 
117
        }
 
118
      dup2 (STDOUT_FILENO, STDIN_FILENO);
 
119
 
 
120
      if (err_pdes[0] != -1)
 
121
        {
 
122
          close (err_pdes[0]);
 
123
          dup2 (err_pdes[1], STDERR_FILENO);
 
124
          close (err_pdes[1]);
 
125
        }
 
126
#if 0
 
127
      /* close any stray FD's - FIXME - how? */
 
128
      /* POSIX.2 B.3.2.2 "popen() shall ensure that any streams
 
129
         from previous popen() calls that remain open in the 
 
130
         parent process are closed in the new child process. */
 
131
      for (old = pidlist; old; old = old->next)
 
132
        close (fileno (old->fp));       /* don't allow a flush */
 
133
#endif
 
134
      execl ("/bin/sh", "sh", "-c", name, (char *) 0);
 
135
      _exit (127);
 
136
    }
 
137
 
 
138
  /* Parent. */
 
139
  close (pdes[1]);
 
140
  if (err_pdes[1] != -1)
 
141
    close (err_pdes[1]);
 
142
  /* :end chunk */
 
143
  state = XMALLOC (struct pipe_state);
 
144
  state->pid = pid;
 
145
  scb->fd = pdes[0];
 
146
  scb->error_fd = err_pdes[0];
 
147
  scb->state = state;
 
148
 
 
149
  /* If we don't do this, GDB simply exits when the remote side dies.  */
 
150
  signal (SIGPIPE, SIG_IGN);
 
151
  return 0;
 
152
#endif
 
153
}
 
154
 
 
155
static void
 
156
pipe_close (struct serial *scb)
 
157
{
 
158
  struct pipe_state *state = scb->state;
 
159
 
 
160
  if (state != NULL)
 
161
    {
 
162
      int pid = state->pid;
 
163
      close (scb->fd);
 
164
      scb->fd = -1;
 
165
      if (scb->error_fd != -1)
 
166
        close (scb->error_fd);
 
167
      scb->error_fd = -1;
 
168
      xfree (state);
 
169
      scb->state = NULL;
 
170
      kill (pid, SIGTERM);
 
171
      /* Might be useful to check that the child does die,
 
172
         and while we're waiting for it to die print any remaining
 
173
         stderr output.  */
 
174
    }
 
175
}
 
176
 
 
177
void
 
178
_initialize_ser_pipe (void)
 
179
{
 
180
  struct serial_ops *ops = XMALLOC (struct serial_ops);
 
181
 
 
182
  memset (ops, 0, sizeof (struct serial_ops));
 
183
  ops->name = "pipe";
 
184
  ops->next = 0;
 
185
  ops->open = pipe_open;
 
186
  ops->close = pipe_close;
 
187
  ops->readchar = ser_base_readchar;
 
188
  ops->write = ser_base_write;
 
189
  ops->flush_output = ser_base_flush_output;
 
190
  ops->flush_input = ser_base_flush_input;
 
191
  ops->send_break = ser_base_send_break;
 
192
  ops->go_raw = ser_base_raw;
 
193
  ops->get_tty_state = ser_base_get_tty_state;
 
194
  ops->set_tty_state = ser_base_set_tty_state;
 
195
  ops->print_tty_state = ser_base_print_tty_state;
 
196
  ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
 
197
  ops->setbaudrate = ser_base_setbaudrate;
 
198
  ops->setstopbits = ser_base_setstopbits;
 
199
  ops->drain_output = ser_base_drain_output;
 
200
  ops->async = ser_base_async;
 
201
  ops->read_prim = ser_unix_read_prim;
 
202
  ops->write_prim = ser_unix_write_prim;
 
203
  serial_add_interface (ops);
 
204
}