OSDN Git Service

Use one makefile for fixinc
[pf3gnuchains/gcc-fork.git] / gcc / fixinc / server.c
1
2 /*
3  *  server.c  Set up and handle communications with a server process.
4  *
5  *  Server Handling copyright 1992-1999 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  *             59 Temple Place - Suite 330,
21  *             Boston,  MA  02111-1307, 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 #include "auto-host.h"
49
50 #include "gansidecl.h"
51 #include "system.h"
52 #include <signal.h>
53
54 #include "server.h"
55
56 #if !defined(volatile) && !defined(HAVE_VOLATILE)
57 # define volatile
58 #endif
59
60 STATIC volatile t_bool read_pipe_timeout;
61 STATIC pid_t server_master_pid = NOPROCESS;
62
63 tSCC* def_args[] =
64 { (char *) NULL, (char *) NULL };
65 STATIC t_pf_pair server_pair =
66 { (FILE *) NULL, (FILE *) NULL };
67 STATIC pid_t server_id = NULLPROCESS;
68 /*
69  *  Arbitrary text that should not be found in the shell output.
70  *  It must be a single line and appear verbatim at the start of
71  *  the terminating output line.
72  */
73 tSCC z_done[] = "ShElL-OuTpUt-HaS-bEeN-cOmPlEtEd";
74 tSCC* p_cur_dir = (char *) NULL;
75
76 /*
77  *  load_data
78  *
79  *  Read data from a file pointer (a pipe to a process in this context)
80  *  until we either get EOF or we get a marker line back.
81  *  The read data are stored in a malloc-ed string that is truncated
82  *  to size at the end.  Input is assumed to be an ASCII string.
83  */
84 static char *load_data PARAMS ((FILE *));
85 static char *
86 load_data (fp)
87      FILE *fp;
88 {
89   char *pz_text;
90   size_t text_size;
91   char *pz_scan;
92   char z_line[1024];
93   t_bool got_done = BOOL_FALSE;
94
95   text_size = sizeof (z_line) * 2;
96   pz_scan = pz_text = malloc (text_size);
97
98   if (pz_text == (char *) NULL)
99     return (char *) NULL;
100
101   for (;;)
102     {
103       size_t used_ct;
104
105       alarm (10);
106       read_pipe_timeout = BOOL_FALSE;
107       if (fgets (z_line, sizeof (z_line), fp) == (char *) NULL)
108         break;
109
110       if (strncmp (z_line, z_done, sizeof (z_done) - 1) == 0)
111         {
112           got_done = BOOL_TRUE;
113           break;
114         }
115
116       strcpy (pz_scan, z_line);
117       pz_scan += strlen (z_line);
118       used_ct = (size_t) (pz_scan - pz_text);
119
120       if (text_size - used_ct < sizeof (z_line))
121         {
122           size_t off = (size_t) (pz_scan - pz_text);
123           void *p;
124           
125           text_size += 4096;
126           p = realloc ((void *) pz_text, text_size);
127           if (p == (void *) NULL)
128             {
129               fprintf (stderr, "Failed to get 0x%08lX bytes\n",
130                       (long) text_size);
131               free ((void *) pz_text);
132               return (char *) NULL;
133             }
134           pz_text = (char *) p;
135           pz_scan = pz_text + off;
136         }
137     }
138
139   alarm (0);
140   if (read_pipe_timeout || ! got_done)
141     {
142       free ((void *) pz_text);
143       return (char *) NULL;
144     }
145
146   while ((pz_scan > pz_text) && ISSPACE (pz_scan[-1]))
147     pz_scan--;
148   *pz_scan = NUL;
149   return realloc ((void *) pz_text, strlen (pz_text) + 1);
150 }
151
152
153 /*
154  *  close_server
155  *
156  *  Make certain the server process is dead, close the 
157  *  pipes to it and from it, finally NULL out the file pointers
158  */
159 void
160 close_server ()
161 {
162   if (  (server_id != NULLPROCESS)
163      && (server_master_pid == getpid ()))
164     {
165       kill ((pid_t) server_id, SIGKILL);
166       server_id = NULLPROCESS;
167       server_master_pid = NOPROCESS;
168       fclose (server_pair.pf_read);
169       fclose (server_pair.pf_write);
170       server_pair.pf_read = server_pair.pf_write = (FILE *) NULL;
171     }
172 }
173
174 /*
175  *  sig_handler really only handles the timeout and pipe signals.
176  *  This ensures that we do not wait forever on a request
177  *  to our server, and also that if the server dies, we do not
178  *  die from a sigpipe problem.
179  */
180 static void sig_handler PARAMS ((int));
181 static void
182 sig_handler (signo)
183      int signo ATTRIBUTE_UNUSED;
184 {
185 #ifdef DEBUG
186   /* FIXME: this is illegal to do in a signal handler.  */
187   fprintf (stderr,
188           "fixincl ERROR:  sig_handler: killed pid %ld due to %s\n",
189           (long) server_id, signo == SIGPIPE ? "SIGPIPE" : "SIGALRM");
190 #endif
191   close_server ();
192   read_pipe_timeout = BOOL_TRUE;
193 }
194
195
196 /*
197  *  server_setup  Establish the signal handler for PIPE and ALARM.
198  *  Also establishes the current directory to give to the
199  *  server process at the start of every server command.
200  */
201 static void server_setup PARAMS ((void));
202 static void
203 server_setup ()
204 {
205   static int atexit_done = 0;
206   
207   if (atexit_done++ == 0)
208     atexit (close_server);
209   else
210     fputs ("NOTE: server restarted\n", stderr);
211
212   server_master_pid = getpid ();
213
214   signal (SIGPIPE, sig_handler);
215   signal (SIGALRM, sig_handler);
216
217   fputs ("trap : 1\n", server_pair.pf_write);
218   fflush (server_pair.pf_write);
219   p_cur_dir = getcwd ((char *) NULL, MAXPATHLEN + 1);
220 }
221
222 /*
223  *  find_shell
224  *
225  *  Locate a shell suitable for use.  For various reasons
226  *  (like the use of "trap" in server_setup(), it must be a
227  *  Bourne-like shell.
228  *
229  *  Most of the time, /bin/sh is preferred, but sometimes
230  *  it's quite broken (like on Ultrix).  autoconf lets you
231  *  override with $CONFIG_SHELL, so we do the same.
232  */
233
234 static const char *find_shell PARAMS ((void));
235 static const char *
236 find_shell ()
237 {
238   char * shell = getenv ("CONFIG_SHELL");
239   if (shell)
240     return shell;
241
242   return "/bin/sh";
243 }
244
245
246 /*
247  *  run_shell
248  *
249  *  Run a shell command on the server.  The command string
250  *  passed in is wrapped inside the sequence:
251  *
252  *     cd <original directory>
253  *     <command string>
254  *     echo
255  *     echo <end-of-command-marker>
256  *
257  *  This ensures that all commands start at a known place in
258  *  the directory structure, that any incomplete output lines
259  *  are completed and that our special marker sequence appears on
260  *  a line by itself.  We have chosen a marker that is
261  *  excessively unlikely to be reproduced in normal output:
262  *
263  *     "ShElL-OuTpUt-HaS-bEeN-cOmPlEtEd"
264  */
265 char *
266 run_shell (pz_cmd)
267      const char *pz_cmd;
268 {
269   tSCC zNoServer[] = "Server not running, cannot run:\n%s\n\n";
270   t_bool retry = BOOL_TRUE;
271
272  do_retry:
273   /*  IF the shell server process is not running yet,
274       THEN try to start it.  */
275   if (server_id == NULLPROCESS)
276     {
277       def_args[0] = find_shell ();
278
279       server_id = proc2_fopen (&server_pair, def_args);
280       if (server_id > 0)
281         server_setup ();
282     }
283
284   /*  IF it is still not running, THEN return the nil string.  */
285   if (server_id <= 0)
286     {
287       char *pz = (char *) malloc (1);
288       fprintf (stderr, zNoServer, pz_cmd);
289       if (pz != (char *) NULL)
290         *pz = '\0';
291       return pz;
292     }
293
294   /*  Make sure the process will pay attention to us, send the
295      supplied command, and then have it output a special marker that
296      we can find.  */
297   fprintf (server_pair.pf_write, "cd %s\n%s\n\necho\necho %s\n",
298            p_cur_dir, pz_cmd, z_done);
299   fflush (server_pair.pf_write);
300
301   /*  IF the server died and we received a SIGPIPE,
302       THEN return an empty string.  */
303   if (server_id == NULLPROCESS)
304     {
305       char *pz = (char *) malloc (1);
306       fprintf (stderr, zNoServer, pz_cmd);
307       if (pz != (char *) NULL)
308         *pz = '\0';
309       return pz;
310     }
311
312   /*  Now try to read back all the data.  If we fail due to either a
313      sigpipe or sigalrm (timeout), we will return the nil string.  */
314   {
315     char *pz = load_data (server_pair.pf_read);
316     
317     if (pz == (char *) NULL)
318       {
319         close_server ();
320
321         if (retry)
322           {
323             retry = BOOL_FALSE;
324             goto do_retry;
325           }
326
327         fprintf (stderr, "CLOSING SHELL SERVER - command failure:\n\t%s\n",
328                  pz_cmd);
329         pz = (char *) malloc (1);
330         if (pz != (char *) NULL)
331           *pz = '\0';
332       }
333 #ifdef DEBUG
334     fprintf( stderr, "run_shell command success:  %s\n", pz );
335 #endif
336     return pz;
337   }
338 }