diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-11 08:21:29 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-11 08:21:29 +0000 |
commit | 29cd838eab01ed7110f3ccb2e8c6a35c8a31dbcc (patch) | |
tree | 63ef546b10a81d461e5cf5ed9e98a68cd7dee1aa /src/kmk/remote-cstms.c | |
parent | Initial commit. (diff) | |
download | kbuild-29cd838eab01ed7110f3ccb2e8c6a35c8a31dbcc.tar.xz kbuild-29cd838eab01ed7110f3ccb2e8c6a35c8a31dbcc.zip |
Adding upstream version 1:0.1.9998svn3589+dfsg.upstream/1%0.1.9998svn3589+dfsg
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/kmk/remote-cstms.c')
-rw-r--r-- | src/kmk/remote-cstms.c | 300 |
1 files changed, 300 insertions, 0 deletions
diff --git a/src/kmk/remote-cstms.c b/src/kmk/remote-cstms.c new file mode 100644 index 0000000..7c36b9d --- /dev/null +++ b/src/kmk/remote-cstms.c @@ -0,0 +1,300 @@ +/* GNU Make remote job exportation interface to the Customs daemon. + THIS CODE IS NOT SUPPORTED BY THE GNU PROJECT. + Please do not send bug reports or questions about it to + the Make maintainers. + +Copyright (C) 1988-2016 Free Software Foundation, Inc. +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 3 of the License, 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 +this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "makeint.h" +#include "filedef.h" +#include "commands.h" +#include "job.h" +#include "debug.h" + +#include <sys/time.h> +#include <netdb.h> + +#include "customs.h" + +char *remote_description = "Customs"; + +/* 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" + +/* ExportPermit gotten by start_remote_job_p, and used by start_remote_job. */ +static ExportPermit permit; + +/* Normalized path name of the current directory. */ +static char *normalized_cwd; + +/* Call once at startup even if no commands are run. */ + +void +remote_setup (void) +{ +} + +/* Called before exit. */ + +void +remote_cleanup (void) +{ +} + +/* Return nonzero if the next job should be done remotely. */ + +int +start_remote_job_p (int first_p) +{ + static int inited = 0; + int status; + int njobs; + + if (!inited) + { + /* Allow the user to turn off job exportation (useful while he is + debugging Customs, for example). */ + if (getenv ("GNU_MAKE_NO_CUSTOMS") != 0) + { + inited = -1; + return 0; + } + + /* For secure Customs, make is installed setuid root and + Customs requires a privileged source port be used. */ + make_access (); + + if (ISDB (DB_JOBS)) + Rpc_Debug (1); + + /* Ping the daemon once to see if it is there. */ + inited = Customs_Ping () == RPC_SUCCESS ? 1 : -1; + + /* Return to normal user access. */ + user_access (); + + 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 = 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; + } + } + + if (inited < 0) + return 0; + + njobs = job_slots_used; + if (!first_p) + njobs -= 1; /* correction for being called from reap_children() */ + + /* the first job should run locally, or, if the -l flag is given, we use + that as clue as to how many local jobs should be scheduled locally */ + if (max_load_average < 0 && njobs == 0 || njobs < max_load_average) + return 0; + + status = Customs_Host (EXPORT_SAME, &permit); + if (status != RPC_SUCCESS) + { + DB (DB_JOBS, (_("Customs won't export: %s\n"), + Rpc_ErrorMessage (status))); + return 0; + } + + return !CUSTOMS_FAIL (&permit.addr); +} + +/* 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). */ + +int +start_remote_job (char **argv, char **envp, int stdin_fd, + int *is_remote, int *id_ptr, int *used_stdin) +{ + char waybill[MAX_DATA_SIZE], msg[128]; + struct hostent *host; + 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) + { + O (error, NILF, "exporting: Couldn't create return socket."); + return 1; + } + + /* Get the return socket's port number. */ + len = sizeof (sin); + 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. */ + len = Customs_MakeWayBill (&permit, normalized_cwd, argv[0], argv, + envp, retport, waybill); + + /* Modify the waybill as if the remote child had done 'child_access ()'. */ + { + WayBill *wb = (WayBill *) waybill; + wb->ruid = wb->euid; + wb->rgid = wb->egid; + } + + /* 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); + + host = gethostbyaddr ((char *)&permit.addr, sizeof(permit.addr), AF_INET); + + { + const char *hnm = host ? host->h_name : inet_ntoa (permit.addr); + size_t hlen = strlen (hnm); + + if (status != RPC_SUCCESS) + { + const char *err = Rpc_ErrorMessage (status); + (void) close (retsock); + (void) close (sock); + error (NILF, hlen + strlen (err), + "exporting to %s: %s", hnm, err); + return 1; + } + else if (msg[0] != 'O' || msg[1] != 'k' || msg[2] != '\0') + { + (void) close (retsock); + (void) close (sock); + error (NILF, hlen + strlen (msg), "exporting to %s: %s", hnm, msg); + return 1; + } + else + { + error (NILF, hlen + INTSTR_LENGTH, + "*** exported to %s (id %u)", hnm, permit.id); + } + + fflush (stdout); + fflush (stderr); + } + + pid = vfork (); + if (pid < 0) + { + /* The fork failed! */ + perror_with_name ("fork", ""); + 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] = + { EXPORT_COMMAND, "-id", sock_buf, retsock_buf, id_buf, 0 }; + + /* Set up the arguments. */ + (void) sprintf (sock_buf, "%d", sock); + (void) sprintf (retsock_buf, "%d", retsock); + (void) sprintf (id_buf, "%x", permit.id); + + /* Get the right stdin. */ + if (stdin_fd != 0) + (void) dup2 (stdin_fd, 0); + + /* Unblock signals in the child. */ + unblock_sigs (); + + /* Run the command. */ + exec_command (new_argv, envp); + } + + /* Parent side. Return the 'export' process's ID. */ + (void) close (retsock); + (void) close (sock); + *is_remote = 0; + *id_ptr = pid; + *used_stdin = 1; + 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 (int *exit_code_ptr, int *signal_ptr, int *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 (void) +{ + 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 (void) +{ + return; +} + +/* Send signal SIG to child ID. Return 0 if successful, -1 if not. */ +int +remote_kill (int id, int sig) +{ + return -1; +} |