Ejemplo n.º 1
0
static void
output (char *fname, char *exHost, int fflag, char *execUsername, char **envp)
{
  char *disOut[MAX_PEEK_ARGS];
  int fidx;
  int pid = 0;
  struct stat buf;

  if (!fflag)
    {

      pid = fork ();
      if (pid < 0)
	{
	  perror ("fork");
	  exit (-1);
	}
    }

  if (pid > 0)
    {

      wait (NULL);
      return;
    }


  if (fflag)
    {
      disOut[0] = "tail";
      disOut[1] = "-f";
      fidx = 2;
    }
  else
    {
      disOut[0] = "cat";
      fidx = 1;
    }
  disOut[fidx + 1] = NULL;


  if (fname[0] != '/' || stat (fname, &buf) < 0)
    {
      remoteOutput (fidx, disOut, exHost, fname, execUsername, envp);
    }
  else
    {
      setuid (getuid ());

      disOut[fidx] = fname;
      lsfExecvp (disOut[0], disOut);
      fprintf (stderr, I18N_FUNC_S_S_FAIL_S, "execvp", disOut[0],
	       strerror (errno));
    }
  exit (-1);

}
Ejemplo n.º 2
0
int
ls_rexecve (char *host, char **argv, int options, char **envp)
{
  int d;
  int retsock;
  struct timeval timeout;
  socklen_t len;
  struct sockaddr_in sin;
  int max;
  char sock_buf[20];
  char *new_argv[5];
  char pathbuf[MAXPATHLEN];
  int s;
  int descriptor[2];
  struct resCmdBill cmdmsg;
  int resTimeout;

  if (genParams_[LSF_RES_TIMEOUT].paramValue)
    resTimeout = atoi (genParams_[LSF_RES_TIMEOUT].paramValue);
  else
    resTimeout = RES_TIMEOUT;

  if (_isconnected_ (host, descriptor))
    s = descriptor[0];
  else if ((s = ls_connect (host)) < 0)
    return (-1);

  if (!FD_ISSET (s, &connection_ok_))
    {
      FD_SET (s, &connection_ok_);
      if (ackReturnCode_ (s) < 0)
	{
	  closesocket (s);
	  _lostconnection_ (host);
	  return (-1);
	}
    }

  cmdmsg.options = options & ~REXF_TASKPORT;
  if (cmdmsg.options & REXF_SHMODE)
    cmdmsg.options |= REXF_USEPTY;

  if (!isatty (0) && !isatty (1))
    cmdmsg.options &= ~REXF_USEPTY;
  else if (cmdmsg.options & REXF_USEPTY)
    {
      if (rstty_ (host) < 0)
	{

	  _lostconnection_ (host);
	  return (-1);
	}
    }


  if ((genParams_[LSF_INTERACTIVE_STDERR].paramValue != NULL)
      && (strcasecmp (genParams_[LSF_INTERACTIVE_STDERR].paramValue,
		      "y") == 0))
    {
      cmdmsg.options |= REXF_STDERR;
    }

  if (mygetwd_ (cmdmsg.cwd) == 0)
    {
      closesocket (s);
      _lostconnection_ (host);
      lserrno = LSE_WDIR;
      return (-1);
    }

  if (envp)
    {
      if (ls_rsetenv (host, envp) < 0)
	{
	  _lostconnection_ (host);
	  return (-1);
	}
    }

  if ((retsock = TcpCreate_ (TRUE, 0)) < 0)
    {
      closesocket (s);
      _lostconnection_ (host);
      return (-1);
    }

  len = sizeof (sin);
  if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0)
    {
      (void) closesocket (retsock);
      closesocket (s);
      _lostconnection_ (host);
      lserrno = LSE_SOCK_SYS;
      return (-1);
    }

  cmdmsg.retport = sin.sin_port;

  cmdmsg.rpid = 0;
  cmdmsg.argv = argv;
  cmdmsg.priority = 0;

  timeout.tv_usec = 0;
  timeout.tv_sec = resTimeout;
  if (sendCmdBill_ (s, (resCmd) RES_EXEC, &cmdmsg, &retsock, &timeout) == -1)
    {
      closesocket (retsock);
      closesocket (s);
      _lostconnection_ (host);
      return (-1);
    }


  (void) sprintf (sock_buf, "%d", retsock);

  if (initenv_ (NULL, NULL) < 0)
    return (-1);
  strcpy (pathbuf, genParams_[LSF_SERVERDIR].paramValue);
  strcat (pathbuf, "/nios");
  new_argv[0] = pathbuf;
  new_argv[1] = "-n";
  new_argv[2] = sock_buf;

  if (cmdmsg.options & REXF_USEPTY)
    {
      if (cmdmsg.options & REXF_SHMODE)
	new_argv[3] = "2";
      else
	new_argv[3] = "1";
    }
  else
    new_argv[3] = "0";
  new_argv[4] = 0;

  max = sysconf (_SC_OPEN_MAX);
  for (d = 3; d < max; ++d)
    {
      if (d != retsock)
	(void) close (d);
    }

  (void) lsfExecvp (new_argv[0], new_argv);
  lserrno = LSE_EXECV_SYS;
  close (retsock);
  close (s);
  return (-1);
}
Ejemplo n.º 3
0
int
ls_rtaske(char *host, char **argv, int options, char **envp)
{
    static u_short          retport;
    static int              rpid;
    static int              reg_ls_donerex = FALSE;
    struct sockaddr_in      sin;
    int                     max;
    char                    c_chfd[8];
    char                    pathbuf[MAXPATHLEN];
    int                     d;
    int                     niosOptions = 0;
    char                    *new_argv[5];
    int                     pid;
    int                     s;
    int                     descriptor[2];
    struct resCmdBill       cmdmsg;
    struct lslibNiosRTask   taskReq;
    u_short                 taskPort = 0;
    sigset_t                newMask;
    sigset_t                oldMask;
    socklen_t               len;

    if (!reg_ls_donerex) {

        atexit( (void (*) ()) ls_donerex);   
 	reg_ls_donerex = TRUE;
    }

    if (_isconnected_(host, descriptor))
	s = descriptor[0];
    else if ((s = ls_connect(host)) < 0)
	return(-1);

    if (blockALL_SIGS_(&newMask, &oldMask) < 0)
        return (-1);

    if (!FD_ISSET(s,&connection_ok_)){
	FD_SET(s,&connection_ok_);
	if (ackReturnCode_(s) < 0){
	    closesocket(s);
	    _lostconnection_(host);
	    sigprocmask(SIG_SETMASK, &oldMask, NULL); 
	    return (-1);
	}
    }

    if (!nios_ok_) 
        niosOptions = options & REXF_SYNCNIOS;
    options &= ~REXF_SYNCNIOS;

    cmdmsg.options = options;
    if (cmdmsg.options & REXF_SHMODE)
	cmdmsg.options |= REXF_USEPTY;
    
    if (!isatty(0) && !isatty(1))
	cmdmsg.options &= ~REXF_USEPTY;
    else if (cmdmsg.options & REXF_USEPTY ){
        if (options & REXF_TTYASYNC){
            if (rstty_async_(host) < 0) {
                sigprocmask(SIG_SETMASK, &oldMask, NULL); 
                return (-1);
            }
        } else {
	    if (rstty_(host) < 0) { 
                sigprocmask(SIG_SETMASK, &oldMask, NULL); 
                return (-1);
            }
        }
    }
    
    if ( (genParams_[LSF_INTERACTIVE_STDERR].paramValue != NULL)
	 && (strcasecmp(genParams_[LSF_INTERACTIVE_STDERR].paramValue, 
			"y") == 0) ) {
	cmdmsg.options |= REXF_STDERR;
    }

    if (!nios_ok_) {
       
        initSigHandler(SIGTSTP);
        initSigHandler(SIGTTIN);
        initSigHandler(SIGTTOU);

       
        if (socketpair(AF_UNIX, SOCK_STREAM, 0, cli_nios_fd) < 0) {
            lserrno = LSE_SOCK_SYS;
            sigprocmask(SIG_SETMASK, &oldMask, NULL); 
            closesocket(s);
            return(-1);
        }

        if ((pid = fork()) != 0) { 
            int mypid;

            close(cli_nios_fd[1]);
            mypid = getpid();
            if (b_write_fix(cli_nios_fd[0], (char *) &mypid, sizeof (mypid)) !=
                sizeof (mypid)) {
                close(cli_nios_fd[0]);
                sigprocmask(SIG_SETMASK, &oldMask, NULL); 
                lserrno = LSE_MSG_SYS;
                return (-1);
            }

            if (b_read_fix(cli_nios_fd[0], (char *) &retport, sizeof (u_short))
                != sizeof(u_short) ) {
                close(cli_nios_fd[0]);
                sigprocmask(SIG_SETMASK, &oldMask, NULL); 
                lserrno = LSE_MSG_SYS;
                return (-1);
            }

            nios_ok_ = TRUE;

            if (waitpid(pid, 0, 0) <0) { 
                if (errno != ECHILD) {
                    close(cli_nios_fd[0]);
                    nios_ok_ = FALSE;
                    sigprocmask(SIG_SETMASK, &oldMask, NULL); 
                    lserrno = LSE_WAIT_SYS;
                    return (-1);
                }
            }
        } else {
            if (fork()) { 
                max = sysconf(_SC_OPEN_MAX);
                for (d = 3; d < max; ++d) { 
                    (void)close(d);
                }
                exit(0);
            }
          

            if (initenv_(NULL, NULL) <0)
                exit (-1);
            strcpy(pathbuf, genParams_[LSF_SERVERDIR].paramValue);
            strcat(pathbuf, "/nios");
            sprintf(c_chfd, "%d", cli_nios_fd[1]);  
            new_argv[0] = pathbuf;
            new_argv[1] = c_chfd;
            if (cmdmsg.options & REXF_USEPTY) {
                if (cmdmsg.options & REXF_SHMODE)
                    new_argv[2] = "2";
                else
                    new_argv[2] = "1";
            }
            else
                new_argv[2] = "0";
            new_argv[3] = NULL;

            max = sysconf(_SC_OPEN_MAX);
            for (d = 3; d < max; ++d) { 
                if (d != cli_nios_fd[1])
                    (void)close(d);
            }
          
            for (d = 1; d < NSIG; d++)     
                Signal_(d, SIG_DFL);

          
            sigprocmask(SIG_SETMASK, &oldMask, NULL); 
            (void)lsfExecvp(new_argv[0], new_argv);
            exit(-1);
        }
    }

    if (envp) {
        if (ls_rsetenv_async (host, envp) < 0) {
            sigprocmask(SIG_SETMASK, &oldMask, NULL); 
            return (-1);
        }
    }

    if (rexcwd_[0] != '\0')
        strcpy(cmdmsg.cwd, rexcwd_);
    else if (mygetwd_(cmdmsg.cwd) == 0) {
	closesocket(s);
	_lostconnection_(host);
        lserrno = LSE_WDIR;
        sigprocmask(SIG_SETMASK, &oldMask, NULL); 
        return (-1);
    }

    
    rpid++;

    cmdmsg.rpid = rpid;
    cmdmsg.retport = retport;

    cmdmsg.argv = argv;
    cmdmsg.priority = 0;   

    if (sendCmdBill_(s, (resCmd) RES_EXEC, &cmdmsg, NULL, NULL) == -1) {
	closesocket(s);
	_lostconnection_(host);
        sigprocmask(SIG_SETMASK, &oldMask, NULL); 
	return(-1);
    }

    if (cmdmsg.options & REXF_TASKPORT) {
	
	if ((taskPort = getTaskPort(s)) == 0) {
	    closesocket(s);
	    _lostconnection_(host);
            sigprocmask(SIG_SETMASK, &oldMask, NULL); 
	    return(-1);
	}
    }

    len = sizeof(sin);
    if (getpeername(s, (struct sockaddr *) &sin, &len) <0) {
	closesocket(s);
	_lostconnection_(host);
	lserrno = LSE_SOCK_SYS;
        sigprocmask(SIG_SETMASK, &oldMask, NULL); 
	return(-1);
    }

    SET_LSLIB_NIOS_HDR(taskReq.hdr, LIB_NIOS_RTASK, sizeof(taskReq.r));
    taskReq.r.pid = rpid;
    taskReq.r.peer = sin.sin_addr;
    
    taskReq.r.pid = (niosOptions & REXF_SYNCNIOS)? -rpid : rpid;

    if (b_write_fix(cli_nios_fd[0], (char *) &taskReq, sizeof(taskReq))
	!= sizeof(taskReq)) {
	closesocket(s);
	_lostconnection_(host);
	lserrno = LSE_MSG_SYS;
        sigprocmask(SIG_SETMASK, &oldMask, NULL); 
	return (-1);
    }

    if (tid_register(rpid, s, taskPort, host, options & REXF_TASKINFO) == -1) {
	closesocket(s);
	_lostconnection_(host);
	lserrno = LSE_MALLOC;
        sigprocmask(SIG_SETMASK, &oldMask, NULL); 
	return (-1);
    }

    sigprocmask(SIG_SETMASK, &oldMask, NULL);

    return (rpid);
} 
Ejemplo n.º 4
0
static void
remoteOutput (int fidx, char **disOut, char *exHost, char *fname,
	      char *execUsername, char **envp)
{
  char buf[MAXFILENAMELEN];
  char *args[MAX_PEEK_ARGS + 4];
  char lsfUserName[MAXLINELEN];

#   define RSHCMD "rsh"

  if ((getLSFUser_ (lsfUserName, MAXLINELEN) == 0)
      && strcmp (lsfUserName, execUsername))
    {


      if (useTmp (exHost, fname))
	{
	  sprintf (buf, "/tmp/.lsbtmp%d/%s", (int) getuid (), fname);
	  disOut[fidx] = buf;
	}
      else
	{
	  disOut[fidx] = fname;
	}

      args[0] = RSHCMD;
      args[1] = exHost;
      args[2] = "-l";
      args[3] = execUsername;
      if (fidx == 2)
	{
	  args[4] = disOut[0];
	  args[5] = disOut[1];
	  args[6] = disOut[2];
	  args[7] = NULL;
	}
      else
	{
	  args[4] = disOut[0];
	  args[5] = disOut[1];
	  args[6] = NULL;
	}


      lsfExecvp (RSHCMD, args);
      fprintf (stderr, I18N_FUNC_S_S_FAIL_S, "execvp", args[0],
	       strerror (errno));
      return;
    }

  if (useTmp (exHost, fname))
    {
      sprintf (buf, "/tmp/.lsbtmp%d/%s", (int) getuid (), fname);
      disOut[fidx] = buf;
    }
  else
    disOut[fidx] = fname;

  if (ls_initrex (1, 0) < 0)
    {
      ls_perror ("ls_initrex");
      return;
    }

  ls_rfcontrol (RF_CMD_RXFLAGS, REXF_CLNTDIR);
  ls_rexecve (exHost, disOut, REXF_CLNTDIR, envp);

  fprintf (stderr, I18N_FUNC_S_S_FAIL_S, "ls_rexecv", disOut[0],
	   ls_sysmsg ());

}