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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [fixincludes/] [procopen.c] - Blame information for rev 724

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 724 jeremybenn
 
2
/*
3
 *  server.c  Set up and handle communications with a server process.
4
 *
5
 *  Server Handling copyright 1992-1999, 2004 The Free Software Foundation
6
 *
7
 *  Server Handling is free software.
8
 *  You may redistribute it and/or modify it under the terms of the
9
 *  GNU General Public License, as published by the Free Software
10
 *  Foundation; either version 2, or (at your option) any later version.
11
 *
12
 *  Server Handling is distributed in the hope that it will be useful,
13
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 *  GNU General Public License for more details.
16
 *
17
 *  You should have received a copy of the GNU General Public License
18
 *  along with Server Handling.  See the file "COPYING".  If not,
19
 *  write to:  The Free Software Foundation, Inc.,
20
 *             51 Franklin Street, Fifth Floor,
21
 *             Boston,  MA  02110-1301, USA.
22
 *
23
 * As a special exception, The Free Software Foundation gives
24
 * permission for additional uses of the text contained in his release
25
 * of ServerHandler.
26
 *
27
 * The exception is that, if you link the ServerHandler library with other
28
 * files to produce an executable, this does not by itself cause the
29
 * resulting executable to be covered by the GNU General Public License.
30
 * Your use of that executable is in no way restricted on account of
31
 * linking the ServerHandler library code into it.
32
 *
33
 * This exception does not however invalidate any other reasons why
34
 * the executable file might be covered by the GNU General Public License.
35
 *
36
 * This exception applies only to the code released by The Free
37
 * Software Foundation under the name ServerHandler.  If you copy code
38
 * from other sources under the General Public License into a copy of
39
 * ServerHandler, as the General Public License permits, the exception
40
 * does not apply to the code that you add in this way.  To avoid
41
 * misleading anyone as to the status of such modified files, you must
42
 * delete this exception notice from them.
43
 *
44
 * If you write modifications of your own for ServerHandler, it is your
45
 * choice whether to permit this exception to apply to your modifications.
46
 * If you do not wish that, delete this exception notice.
47
 */
48
 
49
#include "fixlib.h"
50
#include "server.h"
51
 
52
STATIC const char* def_args[] =
53
{ (char *) NULL, (char *) NULL };
54
 
55
/*
56
 *  chain_open
57
 *
58
 *  Given an FD for an inferior process to use as stdin,
59
 *  start that process and return a NEW FD that that process
60
 *  will use for its stdout.  Requires the argument vector
61
 *  for the new process and, optionally, a pointer to a place
62
 *  to store the child's process id.
63
 */
64
int
65
chain_open (int stdin_fd, tCC** pp_args, pid_t* p_child)
66
{
67
  t_fd_pair stdout_pair;
68
  pid_t ch_id;
69
  tCC *pz_cmd;
70
 
71
  stdout_pair.read_fd = stdout_pair.write_fd = -1;
72
 
73
  /*
74
   *  Create a pipe it will be the child process' stdout,
75
   *  and the parent will read from it.
76
   */
77
  if (pipe ((int *) &stdout_pair) < 0)
78
    {
79
      if (p_child != (pid_t *) NULL)
80
        *p_child = NOPROCESS;
81
      return -1;
82
    }
83
 
84
  /*
85
   *  If we did not get an arg list, use the default
86
   */
87
  if (pp_args == (tCC **) NULL)
88
    pp_args = def_args;
89
 
90
  /*
91
   *  If the arg list does not have a program,
92
   *  assume the "SHELL" from the environment, or, failing
93
   *  that, then sh.  Set argv[0] to whatever we decided on.
94
   */
95
  if (pz_cmd = *pp_args,
96
      (pz_cmd == (char *) NULL) || (*pz_cmd == '\0'))
97
    {
98
 
99
      pz_cmd = getenv ("SHELL");
100
      if (pz_cmd == (char *) NULL)
101
        pz_cmd = "sh";
102
    }
103
 
104
#ifdef DEBUG_PRINT
105
  printf ("START:  %s\n", pz_cmd);
106
  {
107
    int idx = 0;
108
 
109
    while (pp_args[++idx] != (char *) NULL)
110
      printf ("  ARG %2d:  %s\n", idx, pp_args[idx]);
111
  }
112
#endif
113
 
114
  /*
115
   *  Call fork() and see which process we become
116
   */
117
  ch_id = fork ();
118
  switch (ch_id)
119
    {
120
    case NOPROCESS:             /* parent - error in call */
121
      close (stdout_pair.read_fd);
122
      close (stdout_pair.write_fd);
123
      if (p_child != (pid_t *) NULL)
124
        *p_child = NOPROCESS;
125
      return -1;
126
 
127
    default:                    /* parent - return opposite FD's */
128
      if (p_child != (pid_t *) NULL)
129
        *p_child = ch_id;
130
#ifdef DEBUG_PRINT
131
      printf ("for pid %d:  stdin from %d, stdout to %d\n"
132
              "for parent:  read from %d\n",
133
              ch_id, stdin_fd, stdout_pair.write_fd, stdout_pair.read_fd);
134
#endif
135
      close (stdin_fd);
136
      close (stdout_pair.write_fd);
137
      return stdout_pair.read_fd;
138
 
139
    case NULLPROCESS:           /* child - continue processing */
140
      break;
141
    }
142
 
143
  /*
144
   *  Close the pipe end handed back to the parent process
145
   */
146
  close (stdout_pair.read_fd);
147
 
148
  /*
149
   *  Close our current stdin and stdout
150
   */
151
  close (STDIN_FILENO);
152
  close (STDOUT_FILENO);
153
 
154
  /*
155
   *  Make the fd passed in the stdin, and the write end of
156
   *  the new pipe become the stdout.
157
   */
158
  dup2 (stdout_pair.write_fd, STDOUT_FILENO);
159
  dup2 (stdin_fd, STDIN_FILENO);
160
 
161
  if (*pp_args == (char *) NULL)
162
    *pp_args = pz_cmd;
163
 
164
  execvp (pz_cmd, (char**)pp_args);
165
  fprintf (stderr, "Error %d:  Could not execvp( '%s', ... ):  %s\n",
166
           errno, pz_cmd, xstrerror (errno));
167
  exit (EXIT_PANIC);
168
}
169
 
170
 
171
/*
172
 *  proc2_open
173
 *
174
 *  Given a pointer to an argument vector, start a process and
175
 *  place its stdin and stdout file descriptors into an fd pair
176
 *  structure.  The "write_fd" connects to the inferior process
177
 *  stdin, and the "read_fd" connects to its stdout.  The calling
178
 *  process should write to "write_fd" and read from "read_fd".
179
 *  The return value is the process id of the created process.
180
 */
181
pid_t
182
proc2_open (t_fd_pair* p_pair, tCC** pp_args)
183
{
184
  pid_t ch_id;
185
 
186
  /*  Create a bi-directional pipe.  Writes on 0 arrive on 1 and vice
187
     versa, so the parent and child processes will read and write to
188
     opposite FD's.  */
189
  if (pipe ((int *) p_pair) < 0)
190
    return NOPROCESS;
191
 
192
  p_pair->read_fd = chain_open (p_pair->read_fd, pp_args, &ch_id);
193
  if (ch_id == NOPROCESS)
194
    close (p_pair->write_fd);
195
 
196
  return ch_id;
197
}
198
 
199
 
200
/*
201
 *  proc2_fopen
202
 *
203
 *  Identical to "proc2_open()", except that the "fd"'s are
204
 *  "fdopen(3)"-ed into file pointers instead.
205
 */
206
pid_t
207
proc2_fopen (t_pf_pair* pf_pair, tCC** pp_args)
208
{
209
  t_fd_pair fd_pair;
210
  pid_t ch_id = proc2_open (&fd_pair, pp_args);
211
 
212
  if (ch_id == NOPROCESS)
213
    return ch_id;
214
 
215
  pf_pair->pf_read = fdopen (fd_pair.read_fd, "r");
216
  pf_pair->pf_write = fdopen (fd_pair.write_fd, "w");
217
  return ch_id;
218
}

powered by: WebSVN 2.1.0

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