make/remote-cstms.c

271 lines
7.5 KiB
C
Raw Normal View History

1994-03-23 14:12:55 +00:00
/* GNU Make remote job exportation interface to the Customs daemon.
1992-03-09 23:06:05 +00:00
THIS CODE IS NOT SUPPORTED BY THE GNU PROJECT.
Please do not send bug reports or questions about it to
the Make maintainers.
1993-02-01 23:58:39 +00:00
Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
1992-03-09 23:06:05 +00:00
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#include "commands.h"
1993-02-01 23:58:39 +00:00
#include "job.h"
1992-03-09 23:06:05 +00:00
#include <sys/time.h>
1993-02-01 23:58:39 +00:00
#include <netdb.h>
#define __STRICT_BSD__ /* Don't make conflicting declarations. */
#include "customs.h"
1992-03-09 23:06:05 +00:00
char *remote_description = "Customs";
1993-02-01 23:58:39 +00:00
/* File name of the Customs `export' client command.
A full path name can be used to avoid some path-searching overhead. */
#define EXPORT_COMMAND "/usr/local/bin/export"
1992-03-09 23:06:05 +00:00
/* ExportPermit gotten by start_remote_job_p, and used by start_remote_job. */
static ExportPermit permit;
1993-02-04 18:31:53 +00:00
/* Normalized path name of the current directory. */
static char *normalized_cwd;
1992-03-09 23:06:05 +00:00
/* Return nonzero if the next job should be done remotely. */
int
start_remote_job_p ()
{
1993-02-01 23:58:39 +00:00
static int inited = 0;
int status;
/* Allow the user to turn off job exportation
(useful while he is debugging Customs, for example). */
if (getenv ("GNU_MAKE_NO_CUSTOMS") != 0)
return 0;
if (!inited)
{
/* For secure Customs, make is installed setuid root and
Customs requires a privileged source port be used. */
make_access ();
/* Ping the daemon once to see if it is there. */
inited = Customs_Ping () == RPC_SUCCESS ? 1 : -1;
/* Return to normal user access. */
user_access ();
1993-02-04 18:31:53 +00:00
if (starting_directory == 0)
/* main couldn't figure it out. */
inited = -1;
else
{
/* Normalize the current directory path name to something
that should work on all machines exported to. */
normalized_cwd = (char *) xmalloc (GET_PATH_MAX);
strcpy (normalized_cwd, starting_directory);
if (Customs_NormPath (normalized_cwd, GET_PATH_MAX) < 0)
/* Path normalization failure means using Customs
won't work, but it's not really an error. */
inited = -1;
}
1993-02-01 23:58:39 +00:00
}
if (inited < 0)
1992-03-09 23:06:05 +00:00
return 0;
1993-02-01 23:58:39 +00:00
status = Customs_Host (EXPORT_SAME, &permit);
if (status != RPC_SUCCESS)
{
if (debug_flag)
printf ("Customs won't export: %s\n", Rpc_ErrorMessage (status));
return 0;
}
1992-03-09 23:06:05 +00:00
return !CUSTOMS_FAIL (&permit.addr);
}
1993-02-01 23:58:39 +00:00
/* Start a remote job running the command in ARGV, with environment from
ENVP. It gets standard input from STDIN_FD. On failure, return
nonzero. On success, return zero, and set *USED_STDIN to nonzero if it
will actually use STDIN_FD, zero if not, set *ID_PTR to a unique
identification, and set *IS_REMOTE to nonzero if the job is remote, zero
if it is local (meaning *ID_PTR is a process ID). */
1992-03-09 23:06:05 +00:00
int
1992-03-10 22:15:39 +00:00
start_remote_job (argv, envp, stdin_fd, is_remote, id_ptr, used_stdin)
char **argv, **envp;
1992-03-09 23:06:05 +00:00
int stdin_fd;
int *is_remote;
int *id_ptr;
int *used_stdin;
{
extern int vfork (), execve ();
char waybill[MAX_DATA_SIZE], msg[128];
struct timeval timeout;
struct sockaddr_in sin;
int len;
int retsock, retport, sock;
Rpc_Stat status;
int pid;
/* Create the return socket. */
retsock = Rpc_UdpCreate (True, 0);
if (retsock < 0)
{
error ("exporting: Couldn't create return socket.");
return 1;
}
/* Get the return socket's port number. */
1993-02-01 23:58:39 +00:00
len = sizeof (sin);
1992-03-09 23:06:05 +00:00
if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0)
{
(void) close (retsock);
perror_with_name ("exporting: ", "getsockname");
return 1;
}
retport = sin.sin_port;
/* Create the TCP socket for talking to the remote child. */
sock = Rpc_TcpCreate (False, 0);
/* Create a WayBill to give to the server. */
1993-02-04 18:31:53 +00:00
len = Customs_MakeWayBill (&permit, normalized_cwd, argv[0], argv,
1992-03-10 22:15:39 +00:00
envp, retport, waybill);
1992-03-09 23:06:05 +00:00
1993-02-01 23:58:39 +00:00
/* Modify the waybill as if the remote child had done `child_access ()'. */
{
WayBill *wb = (WayBill *) waybill;
1993-02-04 18:31:53 +00:00
wb->euid = wb->ruid;
wb->rgid = wb->rgid;
1993-02-01 23:58:39 +00:00
}
1992-03-09 23:06:05 +00:00
/* Send the request to the server, timing out in 20 seconds. */
timeout.tv_usec = 0;
timeout.tv_sec = 20;
sin.sin_family = AF_INET;
sin.sin_port = htons (Customs_Port ());
sin.sin_addr = permit.addr;
status = Rpc_Call (sock, &sin, (Rpc_Proc) CUSTOMS_IMPORT,
len, (Rpc_Opaque) waybill,
sizeof(msg), (Rpc_Opaque) msg,
1, &timeout);
if (status != RPC_SUCCESS)
{
(void) close (retsock);
(void) close (sock);
error ("exporting: %s", Rpc_ErrorMessage (status));
return 1;
}
else if (msg[0] != 'O' || msg[1] != 'k' || msg[2] != '\0')
{
(void) close (retsock);
(void) close (sock);
error ("CUSTOMS_IMPORT: %s", msg);
return 1;
}
1993-02-01 23:58:39 +00:00
else if (debug_flag)
{
struct hostent *host = gethostbyaddr (&permit.addr, sizeof (permit.addr),
AF_INET);
printf ("Job exported to %s ID %u\n",
host == 0 ? inet_ntoa (permit.addr) : host->h_name,
permit.id);
}
1992-03-09 23:06:05 +00:00
fflush (stdout);
fflush (stderr);
pid = vfork ();
if (pid < 0)
{
/* The fork failed! */
perror_with_name ("vfork", "");
return 1;
}
else if (pid == 0)
{
/* Child side. Run `export' to handle the connection. */
static char sock_buf[20], retsock_buf[20], id_buf[20];
static char *new_argv[6] =
1993-02-01 23:58:39 +00:00
{ EXPORT_COMMAND, "-id", sock_buf, retsock_buf, id_buf, 0 };
1992-03-09 23:06:05 +00:00
/* Set up the arguments. */
(void) sprintf (sock_buf, "%d", sock);
(void) sprintf (retsock_buf, "%d", retsock);
(void) sprintf (id_buf, "%x", permit.id);
1993-02-01 23:58:39 +00:00
/* Get the right stdin. */
if (stdin_fd != 0)
(void) dup2 (stdin_fd, 0);
/* Unblock signals in the child. */
unblock_sigs ();
1992-03-09 23:06:05 +00:00
/* Run the command. */
1993-02-01 23:58:39 +00:00
exec_command (new_argv, envp);
1992-03-09 23:06:05 +00:00
}
/* Parent side. Return the `export' process's ID. */
(void) close (retsock);
(void) close (sock);
*is_remote = 0;
*id_ptr = pid;
return 0;
}
/* Get the status of a dead remote child. Block waiting for one to die
if BLOCK is nonzero. Set *EXIT_CODE_PTR to the exit status, *SIGNAL_PTR
to the termination signal or zero if it exited normally, and *COREDUMP_PTR
nonzero if it dumped core. Return the ID of the child that died,
0 if we would have to block and !BLOCK, or < 0 if there were none. */
int
remote_status (exit_code_ptr, signal_ptr, coredump_ptr, block)
int *exit_code_ptr, *signal_ptr, *coredump_ptr;
int block;
{
return -1;
}
/* Block asynchronous notification of remote child death.
If this notification is done by raising the child termination
signal, do not block that signal. */
void
block_remote_children ()
{
return;
}
/* Restore asynchronous notification of remote child death.
If this is done by raising the child termination signal,
do not unblock that signal. */
void
unblock_remote_children ()
{
return;
}
/* Send signal SIG to child ID. Return 0 if successful, -1 if not. */
int
remote_kill (id, sig)
int id;
int sig;
{
return -1;
}