Пример #1
0
/* ls_startserver()
 */
int
ls_startserver (char *host, char **server, int options)
{
  int retsock;
  char official[MAXHOSTNAMELEN];
  struct timeval timeout;
  struct sockaddr_in sin;
  int s;
  int descriptor[2];
  struct resCmdBill cmdmsg;
  int resTimeout;
  socklen_t len;

  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);
	}
    }

  if (!isatty (0) && !isatty (1))
    options &= ~REXF_USEPTY;
  else if (options & REXF_USEPTY)
    {
      if (rstty_ (host) < 0)
	{
	  _lostconnection_ (host);
	  return (-1);
	}
    }

  if (mygetwd_ (cmdmsg.cwd) == 0)
    {
      closesocket (s);
      _lostconnection_ (host);
      lserrno = LSE_WDIR;
      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)
    {
      closesocket (retsock);
      closesocket (s);
      _lostconnection_ (host);
      lserrno = LSE_SOCK_SYS;
      return (-1);
    }

  cmdmsg.retport = sin.sin_port;

  cmdmsg.options = options & ~REXF_TASKPORT;
  cmdmsg.rpid = 0;
  cmdmsg.argv = server;

  timeout.tv_usec = 0;
  timeout.tv_sec = resTimeout;

  if (sendCmdBill_ (s, (resCmd) RES_SERVER, &cmdmsg, &retsock, &timeout)
      == -1)
    {
      closesocket (retsock);
      closesocket (s);
      _lostconnection_ (host);
      return (-1);
    }

  if (ackReturnCode_ (s) < 0)
    {
      closesocket (retsock);
      closesocket (s);
      _lostconnection_ (host);
      return (-1);
    }

  if (retsock <= 2 && (retsock = get_nonstd_desc_ (retsock)) < 0)
    {
      closesocket (s);
      _lostconnection_ (host);
      lserrno = LSE_SOCK_SYS;
      return (-1);
    }

  gethostbysock_ (s, official);
  (void) connected_ (official, -1, retsock, currentSN);

  return (retsock);

}				/* ls_startserver() */
Пример #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);
}
Пример #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);
}