remote-cstms.c

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