Create a new internal interface for defining new make functions.
[make.git] / remote-cstms.c
blobbbdf1c3a4fb5bb0c835bdb013f24e810de5147db
1 /* GNU Make remote job exportation interface to the Customs daemon.
2 THIS CODE IS NOT SUPPORTED BY THE GNU PROJECT.
3 Please do not send bug reports or questions about it to
4 the Make maintainers.
6 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
7 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
8 2012 Free Software Foundation, Inc.
9 This file is part of GNU Make.
11 GNU Make is free software; you can redistribute it and/or modify it under the
12 terms of the GNU General Public License as published by the Free Software
13 Foundation; either version 3 of the License, or (at your option) any later
14 version.
16 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
18 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License along with
21 this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "make.h"
24 #include "job.h"
25 #include "filedef.h"
26 #include "commands.h"
27 #include "job.h"
28 #include "debug.h"
30 #include <sys/time.h>
31 #include <netdb.h>
33 #include "customs.h"
35 char *remote_description = "Customs";
37 /* File name of the Customs `export' client command.
38 A full path name can be used to avoid some path-searching overhead. */
39 #define EXPORT_COMMAND "/usr/local/bin/export"
41 /* ExportPermit gotten by start_remote_job_p, and used by start_remote_job. */
42 static ExportPermit permit;
44 /* Normalized path name of the current directory. */
45 static char *normalized_cwd;
47 /* Call once at startup even if no commands are run. */
49 void
50 remote_setup (void)
54 /* Called before exit. */
56 void
57 remote_cleanup (void)
61 /* Return nonzero if the next job should be done remotely. */
63 int
64 start_remote_job_p (int first_p)
66 static int inited = 0;
67 int status;
68 int njobs;
70 if (!inited)
72 /* Allow the user to turn off job exportation (useful while he is
73 debugging Customs, for example). */
74 if (getenv ("GNU_MAKE_NO_CUSTOMS") != 0)
76 inited = -1;
77 return 0;
80 /* For secure Customs, make is installed setuid root and
81 Customs requires a privileged source port be used. */
82 make_access ();
84 if (ISDB (DB_JOBS))
85 Rpc_Debug(1);
87 /* Ping the daemon once to see if it is there. */
88 inited = Customs_Ping () == RPC_SUCCESS ? 1 : -1;
90 /* Return to normal user access. */
91 user_access ();
93 if (starting_directory == 0)
94 /* main couldn't figure it out. */
95 inited = -1;
96 else
98 /* Normalize the current directory path name to something
99 that should work on all machines exported to. */
101 normalized_cwd = xmalloc (GET_PATH_MAX);
102 strcpy (normalized_cwd, starting_directory);
103 if (Customs_NormPath (normalized_cwd, GET_PATH_MAX) < 0)
104 /* Path normalization failure means using Customs
105 won't work, but it's not really an error. */
106 inited = -1;
110 if (inited < 0)
111 return 0;
113 njobs = job_slots_used;
114 if (!first_p)
115 njobs -= 1; /* correction for being called from reap_children() */
117 /* the first job should run locally, or, if the -l flag is given, we use
118 that as clue as to how many local jobs should be scheduled locally */
119 if (max_load_average < 0 && njobs == 0 || njobs < max_load_average)
120 return 0;
122 status = Customs_Host (EXPORT_SAME, &permit);
123 if (status != RPC_SUCCESS)
125 DB (DB_JOBS, (_("Customs won't export: %s\n"),
126 Rpc_ErrorMessage (status)));
127 return 0;
130 return !CUSTOMS_FAIL (&permit.addr);
133 /* Start a remote job running the command in ARGV, with environment from
134 ENVP. It gets standard input from STDIN_FD. On failure, return
135 nonzero. On success, return zero, and set *USED_STDIN to nonzero if it
136 will actually use STDIN_FD, zero if not, set *ID_PTR to a unique
137 identification, and set *IS_REMOTE to nonzero if the job is remote, zero
138 if it is local (meaning *ID_PTR is a process ID). */
141 start_remote_job (char **argv, char **envp, int stdin_fd,
142 int *is_remote, int *id_ptr, int *used_stdin)
144 char waybill[MAX_DATA_SIZE], msg[128];
145 struct hostent *host;
146 struct timeval timeout;
147 struct sockaddr_in sin;
148 int len;
149 int retsock, retport, sock;
150 Rpc_Stat status;
151 int pid;
153 /* Create the return socket. */
154 retsock = Rpc_UdpCreate (True, 0);
155 if (retsock < 0)
157 error (NILF, "exporting: Couldn't create return socket.");
158 return 1;
161 /* Get the return socket's port number. */
162 len = sizeof (sin);
163 if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0)
165 (void) close (retsock);
166 perror_with_name ("exporting: ", "getsockname");
167 return 1;
169 retport = sin.sin_port;
171 /* Create the TCP socket for talking to the remote child. */
172 sock = Rpc_TcpCreate (False, 0);
174 /* Create a WayBill to give to the server. */
175 len = Customs_MakeWayBill (&permit, normalized_cwd, argv[0], argv,
176 envp, retport, waybill);
178 /* Modify the waybill as if the remote child had done `child_access ()'. */
180 WayBill *wb = (WayBill *) waybill;
181 wb->ruid = wb->euid;
182 wb->rgid = wb->egid;
185 /* Send the request to the server, timing out in 20 seconds. */
186 timeout.tv_usec = 0;
187 timeout.tv_sec = 20;
188 sin.sin_family = AF_INET;
189 sin.sin_port = htons (Customs_Port ());
190 sin.sin_addr = permit.addr;
191 status = Rpc_Call (sock, &sin, (Rpc_Proc) CUSTOMS_IMPORT,
192 len, (Rpc_Opaque) waybill,
193 sizeof(msg), (Rpc_Opaque) msg,
194 1, &timeout);
196 host = gethostbyaddr((char *)&permit.addr, sizeof(permit.addr), AF_INET);
198 if (status != RPC_SUCCESS)
200 (void) close (retsock);
201 (void) close (sock);
202 error (NILF, "exporting to %s: %s",
203 host ? host->h_name : inet_ntoa (permit.addr),
204 Rpc_ErrorMessage (status));
205 return 1;
207 else if (msg[0] != 'O' || msg[1] != 'k' || msg[2] != '\0')
209 (void) close (retsock);
210 (void) close (sock);
211 error (NILF, "exporting to %s: %s",
212 host ? host->h_name : inet_ntoa (permit.addr),
213 msg);
214 return 1;
216 else
218 error (NILF, "*** exported to %s (id %u)",
219 host ? host->h_name : inet_ntoa (permit.addr),
220 permit.id);
223 fflush (stdout);
224 fflush (stderr);
226 pid = vfork ();
227 if (pid < 0)
229 /* The fork failed! */
230 perror_with_name ("vfork", "");
231 return 1;
233 else if (pid == 0)
235 /* Child side. Run `export' to handle the connection. */
236 static char sock_buf[20], retsock_buf[20], id_buf[20];
237 static char *new_argv[6] =
238 { EXPORT_COMMAND, "-id", sock_buf, retsock_buf, id_buf, 0 };
240 /* Set up the arguments. */
241 (void) sprintf (sock_buf, "%d", sock);
242 (void) sprintf (retsock_buf, "%d", retsock);
243 (void) sprintf (id_buf, "%x", permit.id);
245 /* Get the right stdin. */
246 if (stdin_fd != 0)
247 (void) dup2 (stdin_fd, 0);
249 /* Unblock signals in the child. */
250 unblock_sigs ();
252 /* Run the command. */
253 exec_command (new_argv, envp);
256 /* Parent side. Return the `export' process's ID. */
257 (void) close (retsock);
258 (void) close (sock);
259 *is_remote = 0;
260 *id_ptr = pid;
261 *used_stdin = 1;
262 return 0;
265 /* Get the status of a dead remote child. Block waiting for one to die
266 if BLOCK is nonzero. Set *EXIT_CODE_PTR to the exit status, *SIGNAL_PTR
267 to the termination signal or zero if it exited normally, and *COREDUMP_PTR
268 nonzero if it dumped core. Return the ID of the child that died,
269 0 if we would have to block and !BLOCK, or < 0 if there were none. */
272 remote_status (int *exit_code_ptr, int *signal_ptr, int *coredump_ptr,
273 int block)
275 return -1;
278 /* Block asynchronous notification of remote child death.
279 If this notification is done by raising the child termination
280 signal, do not block that signal. */
281 void
282 block_remote_children (void)
284 return;
287 /* Restore asynchronous notification of remote child death.
288 If this is done by raising the child termination signal,
289 do not unblock that signal. */
290 void
291 unblock_remote_children (void)
293 return;
296 /* Send signal SIG to child ID. Return 0 if successful, -1 if not. */
298 remote_kill (int id, int sig)
300 return -1;