OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [ser-pipe.c] - Blame information for rev 827

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.