2014-10-24 Christophe Lyon <christophe.lyon@linaro.org>
[official-gcc.git] / fixincludes / server.c
blob1e50efc9faaf5686ec7bf29e6893f846fd471cec
2 /*
3 * server.c Set up and handle communications with a server process.
5 * Server Handling copyright 1992-1999, 2001 The Free Software Foundation
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.
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.
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.
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.
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.
33 * This exception does not however invalidate any other reasons why
34 * the executable file might be covered by the GNU General Public License.
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.
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.
49 #include "fixlib.h"
50 #include "server.h"
52 STATIC volatile enum t_bool read_pipe_timeout;
53 STATIC pid_t server_master_pid = NOPROCESS;
55 tSCC* def_args[] =
56 { (char *) NULL, (char *) NULL };
57 STATIC t_pf_pair server_pair =
58 { (FILE *) NULL, (FILE *) NULL };
59 STATIC pid_t server_id = NULLPROCESS;
61 * Arbitrary text that should not be found in the shell output.
62 * It must be a single line and appear verbatim at the start of
63 * the terminating output line.
65 tSCC z_done[] = "ShElL-OuTpUt-HaS-bEeN-cOmPlEtEd";
66 tSCC* p_cur_dir = (char *) NULL;
69 * load_data
71 * Read data from a file pointer (a pipe to a process in this context)
72 * until we either get EOF or we get a marker line back.
73 * The read data are stored in a malloc-ed string that is truncated
74 * to size at the end. Input is assumed to be an ASCII string.
76 static char *
77 load_data (FILE* fp)
79 char *pz_text;
80 size_t text_size;
81 char *pz_scan;
82 char z_line[1024];
83 t_bool got_done = BOOL_FALSE;
85 text_size = sizeof (z_line) * 2;
86 pz_scan = pz_text = XNEWVEC (char, text_size);
88 for (;;)
90 size_t used_ct;
92 alarm (10);
93 read_pipe_timeout = BOOL_FALSE;
94 if (fgets (z_line, sizeof (z_line), fp) == (char *) NULL)
95 break;
97 if (strncmp (z_line, z_done, sizeof (z_done) - 1) == 0)
99 got_done = BOOL_TRUE;
100 break;
103 strcpy (pz_scan, z_line);
104 pz_scan += strlen (z_line);
105 used_ct = (size_t) (pz_scan - pz_text);
107 if (text_size - used_ct < sizeof (z_line))
109 size_t off = (size_t) (pz_scan - pz_text);
111 text_size += 4096;
112 pz_text = XRESIZEVEC (char, pz_text, text_size);
113 pz_scan = pz_text + off;
117 alarm (0);
118 if (read_pipe_timeout || ! got_done)
120 free ((void *) pz_text);
121 return (char *) NULL;
124 while ((pz_scan > pz_text) && ISSPACE (pz_scan[-1]))
125 pz_scan--;
126 *pz_scan = NUL;
127 return XRESIZEVEC (char, pz_text, strlen (pz_text) + 1);
132 * close_server
134 * Make certain the server process is dead, close the
135 * pipes to it and from it, finally NULL out the file pointers
137 void
138 close_server (void)
140 if ( (server_id != NULLPROCESS)
141 && (server_master_pid == getpid ()))
143 kill ((pid_t) server_id, SIGKILL);
144 server_id = NULLPROCESS;
145 server_master_pid = NOPROCESS;
146 fclose (server_pair.pf_read);
147 fclose (server_pair.pf_write);
148 server_pair.pf_read = server_pair.pf_write = (FILE *) NULL;
153 * sig_handler really only handles the timeout and pipe signals.
154 * This ensures that we do not wait forever on a request
155 * to our server, and also that if the server dies, we do not
156 * die from a sigpipe problem.
158 static void
159 sig_handler (int signo ATTRIBUTE_UNUSED)
161 #ifdef DEBUG
162 /* FIXME: this is illegal to do in a signal handler. */
163 fprintf (stderr,
164 "fixincl ERROR: sig_handler: killed pid %ld due to %s\n",
165 (long) server_id, signo == SIGPIPE ? "SIGPIPE" : "SIGALRM");
166 #endif
167 close_server ();
168 read_pipe_timeout = BOOL_TRUE;
173 * server_setup Establish the signal handler for PIPE and ALARM.
174 * Also establishes the current directory to give to the
175 * server process at the start of every server command.
177 static void
178 server_setup (void)
180 static int atexit_done = 0;
181 char buff [MAXPATHLEN + 1];
183 if (atexit_done++ == 0)
184 atexit (close_server);
185 else
186 fputs ("NOTE: server restarted\n", stderr);
188 server_master_pid = getpid ();
190 signal (SIGPIPE, sig_handler);
191 signal (SIGALRM, sig_handler);
193 fputs ("trap : 1\n", server_pair.pf_write);
194 fflush (server_pair.pf_write);
195 getcwd (buff, MAXPATHLEN + 1);
196 p_cur_dir = xstrdup (buff);
200 * find_shell
202 * Locate a shell suitable for use. For various reasons
203 * (like the use of "trap" in server_setup(), it must be a
204 * Bourne-like shell.
206 * Most of the time, /bin/sh is preferred, but sometimes
207 * it's quite broken (like on Ultrix). autoconf lets you
208 * override with $CONFIG_SHELL, so we do the same.
211 static const char *
212 find_shell (void)
214 char * shell = getenv ("CONFIG_SHELL");
215 if (shell)
216 return shell;
218 return "/bin/sh";
223 * run_shell
225 * Run a shell command on the server. The command string
226 * passed in is wrapped inside the sequence:
228 * cd <original directory>
229 * <command string>
230 * echo
231 * echo <end-of-command-marker>
233 * This ensures that all commands start at a known place in
234 * the directory structure, that any incomplete output lines
235 * are completed and that our special marker sequence appears on
236 * a line by itself. We have chosen a marker that is
237 * excessively unlikely to be reproduced in normal output:
239 * "ShElL-OuTpUt-HaS-bEeN-cOmPlEtEd"
241 char *
242 run_shell (const char* pz_cmd)
244 tSCC zNoServer[] = "Server not running, cannot run:\n%s\n\n";
245 t_bool retry = BOOL_TRUE;
247 do_retry:
248 /* IF the shell server process is not running yet,
249 THEN try to start it. */
250 if (server_id == NULLPROCESS)
252 def_args[0] = find_shell ();
254 server_id = proc2_fopen (&server_pair, def_args);
255 if (server_id > 0)
256 server_setup ();
259 /* IF it is still not running, THEN return the nil string. */
260 if (server_id <= 0)
262 fprintf (stderr, zNoServer, pz_cmd);
263 return XCNEW (char);
266 /* Make sure the process will pay attention to us, send the
267 supplied command, and then have it output a special marker that
268 we can find. */
269 fprintf (server_pair.pf_write, "cd \"%s\"\n%s\n\necho\necho %s\n",
270 p_cur_dir, pz_cmd, z_done);
271 fflush (server_pair.pf_write);
273 /* IF the server died and we received a SIGPIPE,
274 THEN return an empty string. */
275 if (server_id == NULLPROCESS)
277 fprintf (stderr, zNoServer, pz_cmd);
278 return XCNEW (char);
281 /* Now try to read back all the data. If we fail due to either a
282 sigpipe or sigalrm (timeout), we will return the nil string. */
284 char *pz = load_data (server_pair.pf_read);
286 if (pz == (char *) NULL)
288 close_server ();
290 if (retry)
292 retry = BOOL_FALSE;
293 goto do_retry;
296 fprintf (stderr, "CLOSING SHELL SERVER - command failure:\n\t%s\n",
297 pz_cmd);
298 pz = XCNEW (char);
300 #ifdef DEBUG
301 fprintf( stderr, "run_shell command success: %s\n", pz );
302 #endif
303 return pz;