Example #1
0
static int
ptym_open(char *pts_name)
{
    char	*ptr;
    int		fdm;

    strcpy(pts_name, "/dev/ptmx");
    if ((fdm = open(pts_name, O_RDWR)) < 0)
	return(-1);
    if (grantpt(fdm) < 0) {
	close(fdm);
	return(-1);
    }
    if (unlockpt(fdm) < 0) {
	close(fdm);
	return(-1);
    }
    if ((ptr = ptsname(fdm)) == NULL) {
	close(fdm);
	return(-1);
    }

    strcpy(pts_name, ptr);
    return(fdm);
}
Example #2
0
int
ptym_open(char *pts_name, int pts_namesz)
{
    char    *ptr;
    int        fdm, err;

    if ((fdm = posix_openpt(O_RDWR)) < 0)
        return(-1);
    if (grantpt(fdm) < 0)        /* grant access to slave */
        goto errout;
    if (unlockpt(fdm) < 0)        /* clear slave's lock flag */
        goto errout;
    if ((ptr = ptsname(fdm)) == NULL)    /* get slave's name */
        goto errout;

    /*
     * Return name of slave.  Null terminate to handle
     * case where strlen(ptr) > pts_namesz.
     */
    strncpy(pts_name, ptr, pts_namesz);
    pts_name[pts_namesz - 1] = '\0';
    return(fdm);            /* return fd of master */
errout:
    err = errno;
    close(fdm);
    errno = err;
    return(-1);
}
Example #3
0
void handle_signals_resets_terminal(void)
{
	int status, masterfd;
	char* slavedevice = NULL;
	struct termios test_flags;
	pid_t child_pid;

	masterfd = posix_openpt(O_RDWR|O_NOCTTY);

	if (masterfd == -1
		|| grantpt (masterfd) == -1
		|| unlockpt (masterfd) == -1
		|| (slavedevice = ptsname (masterfd)) == NULL)
		CU_FAIL_FATAL("Could not create pty");

	terminal_fildes = open(slavedevice, O_RDWR|O_NOCTTY);
	tcgetattr(terminal_fildes, &orig_flags);
	new_flags = orig_flags;
	new_flags.c_lflag &= ~ECHO;
	tcsetattr(terminal_fildes, TCSANOW, &new_flags);
	terminal_needs_reset = 1;

	if((child_pid = fork()) == 0)
	{
		freerdp_handle_signals();
		raise(SIGINT);
	}
	while(wait(&status) != -1);
	tcgetattr(terminal_fildes, &test_flags);
	CU_ASSERT_EQUAL(orig_flags.c_lflag, test_flags.c_lflag);
	close(masterfd);
	close(terminal_fildes);
}
Example #4
0
int
ptym_open(char *pts_name, char *pts_name_s , int pts_namesz)
{
    char    *ptr;
    int     fdm;

    strncpy(pts_name, "/dev/ptmx", pts_namesz);
    pts_name[pts_namesz - 1] = '\0';

    fdm = posix_openpt(O_RDWR | O_NONBLOCK);
    if (fdm < 0)
        return(-1);
    if (grantpt(fdm) < 0) 
    {
        close(fdm);
        return(-2);
    }
    if (unlockpt(fdm) < 0) 
    {
        close(fdm);
        return(-3);
    }
    if ((ptr = ptsname(fdm)) == NULL) 
    {
        close(fdm);
        return(-4);
    }
    
    strncpy(pts_name_s, ptr, pts_namesz);
    pts_name[pts_namesz - 1] = '\0';

    return(fdm);        
}
Example #5
0
// We would like to use "openpty", but it isn't in libc on some systems.
static bool createPseudoTty(int& masterFd, int& slaveFd, char *ttyname)
{
    // try opening Unix98 pseudo tty
    if ((masterFd = ::open("/dev/ptmx", O_RDWR | O_NONBLOCK, 0)) >= 0) {
        if (grantpt(masterFd) == 0) {
            if (unlockpt(masterFd) == 0) {
                ptsname_r(masterFd, ttyname, BUFSIZ);
                if ((slaveFd = ::open(ttyname, O_RDWR | O_NOCTTY, 0)) >= 0)
                    return true;
            }
        }
        ::close(masterFd);
    }

    // opening Unix98 pseudo tty failed, fall back to BSD style pseudo tty
    static char const firstChars[]  = "pqrstuvwxyzabcde";
    static char const secondChars[] = "0123456789abcdef";
    const char *first;
    const char *second;
    char ptyname[16];
    for ( first = firstChars; *first != '\0'; ++first ) {
        for ( second = secondChars; *second != '\0'; ++second ) {
            sprintf( ptyname, "/dev/pty%c%c", *first, *second );
            sprintf( ttyname, "/dev/tty%c%c", *first, *second );
            if ( ( masterFd = ::open( ptyname, O_RDWR | O_NONBLOCK, 0 ) ) >= 0 ) {
                if ( ( slaveFd = ::open( ttyname, O_RDWR | O_NOCTTY, 0 ) )
                        >= 0 ) {
                    return true;
                }
                ::close( masterFd );
            }
        }
    }
    return false;
}
Example #6
0
int main(void) {
	int fdm;
	int rc;

	// initial
	system("ls -l /dev/pts");

	fdm = posix_openpt(O_RDWR);
	if (fdm < 0) {
		perror("posix_openpt");
		return 1;
	}

	rc = grantpt(fdm);
	if (rc != 0) {
		perror("grantpt");
		return 1;
	}

	rc = unlockpt(fdm);
	if (rc != 0) {
		perror("unlockpt");
		return 1;
	}

	// final
	system("ls -l /dev/pts");

	return 0;
}
Example #7
0
int
allocate_pty(int *master, int *slave) {
#if defined(HAVE_OPENPTY) || (defined(HAVE_DECL_OPENPTY) && HAVE_DECL_OPENPTY != 0)
  if(openpty(master, slave, NULL, NULL, NULL)) return -1;
#else
  /* STREAMS... sigh */
  char   *slavename;
  extern char *ptsname();

  *master = open("/dev/ptmx", O_RDWR);  /* open master */
  if(*master < 0) return -1;
  grantpt(*master);                     /* change permission of   slave */
  unlockpt(*master);                    /* unlock slave */
  slavename = ptsname(*master);         /* get name of slave */
  *slave = open(slavename, O_RDWR);    /* open slave */
  if(*slave < 0) {
    close(*master);
    *master = -1;
    return -1;
  }
  /* This is a bit backwards as we using the PTY backwards.
   * We want to make the master a tty instead of the slave... odd, I know.
   */
  ioctl(*master, I_PUSH, "ptem");       /* push ptem */
  ioctl(*master, I_PUSH, "ldterm");     /* push ldterm*/
#endif
  if(eventer_set_fd_nonblocking(*master)) return -1;
  noitL(noit_debug, "allocate_pty -> %d,%d\n", *master, *slave);
  return 0;
}
Example #8
0
static int
test_ebadf (void)
{
  int fd, ret, err;

  fd = posix_openpt (O_RDWR);
  if (fd == -1)
    {
      printf ("posix_openpt(O_RDWR) failed\nerrno %d (%s)\n",
	      errno, strerror (errno));
      /* We don't fail because of this; maybe the system does not have
	 SUS pseudo terminals.  */
      return 0;
    }
  unlockpt (fd);
  close (fd);

  ret = grantpt (fd);
  err = errno;
  if (ret != -1 || err != EBADF)
    {
      printf ("grantpt(): expected: return = %d, errno = %d\n", -1, EBADF);
      printf ("           got: return = %d, errno = %d\n", ret, err);
      return 1;
    }
  return 0;
}
Example #9
0
int ptym_open(char *pts_name)
{
    char *ptr;
    int  fdm;
#if defined(AIX43) || defined(AIX51)
    char default_pts_name[] = "/dev/ptc";
#else
    char default_pts_name[] = "/dev/ptmx";
#endif

    strcpy(pts_name, default_pts_name);   /* in case open fails */
    if ((fdm = open(pts_name, O_RDWR)) < 0) {
        return -1;
    }

    if (grantpt(fdm) < 0) {    /* grant access to slave */
        close(fdm);
        return -2;
    }
    if (unlockpt(fdm) < 0) {   /* clear slave's lock flag */
        close(fdm);
        return -3;
    }
    if ((ptr = ptsname(fdm)) == NULL) {   /* get slave's name */
        close(fdm);
        return -4;
    }

    strcpy(pts_name, ptr);  /* return name of slave */
    return fdm;             /* return fd of master */
}
Example #10
0
File: trytty.c Project: Zex/trytty
void try_tty()
{
	int master, slave;
	char name[128] = "123";
	struct termios *term;
	struct winsize *win;

	if ( ! openpty( &master, &slave, name, term, win ) )
	{
		printf( "name: %s\n", name );
		printf( "master: %d\n", master );
		printf( "slave: %d\n", slave );
		printf( "window row: %u\n", win->ws_row );
		printf( "window column: %u\n", win->ws_col );
		printf( "window xpixel: %u\n", win->ws_xpixel );
		printf( "window ypixel: %u\n", win->ws_ypixel );
//		getchar();
	} ELSE_PRINT_ERROR

	int fd_pt;
	char buf[128];
	if ( 0 < ( fd_pt = getpt() ) )
	{
		grantpt( fd_pt );
		printf( "ptsname==>name: %s\n", ptsname( fd_pt ) );
		ptsname_r( fd_pt, buf, sizeof(buf) );
		printf( "ptsname_r==>name: %s\n", buf );
		write( fd_pt, "Hello tty !!", 13 );
//		getchar();
	} ELSE_PRINT_ERROR
}
Example #11
0
static int
test_einval (void)
{
  int fd, ret, err;
  const char file[] = "./grantpt-einval";

  fd = open (file, O_RDWR | O_CREAT, 0600);
  if (fd == -1)
    {
      printf ("open(\"%s\", O_RDWR) failed\nerrno %d (%s)\n",
	      file, errno, strerror (errno));
      return 0;
    }
  unlink (file);

  ret = grantpt (fd);
  err = errno;
  if (ret != -1 || err != EINVAL)
    {
      printf ("grantpt(): expected: return = %d, errno = %d\n", -1, EINVAL);
      printf ("           got: return = %d, errno = %d\n", ret, err);
      ret = 1;
    }
  else
    ret = 0;

  close (fd);

  return ret;
}
Example #12
0
/***
Grant access to a slave pseudoterminal
@function grantpt
@int fd descriptor returned by openpt
@treturn[1] int `0`, if successful
@return[2] nil
@treturn[2] string error message
@treturn[2] int errnum
@see grantpt(3)
@see openpt
@see ptsname
@see unlockpt
*/
static int
Pgrantpt(lua_State *L)
{
	int fd=checkint(L, 1);
	checknargs(L, 1);
	return pushresult(L, grantpt(fd), "grantpt");
}
Example #13
0
int
ptym_open(char * pts_name)
{
	int fdm;
	char *ptr;

	strcpy(pts_name, "/dev/ptmx");
	fdm = posix_openpt(O_RDWR);
	if (fdm < 0)
		return -1;
	if (grantpt(fdm) < 0) { /* grant access to slave */
		close(fdm);
		return -2;
	}
	if (unlockpt(fdm) < 0) { /* clear slave's lock flag */
		close(fdm);
		return -3;
	}
	ptr = ptsname(fdm);
	if (ptr == NULL) { /* get slave's name */
		close (fdm);
		return -4;
	}
	strcpy(pts_name, ptr); /* return name of slave */
	return fdm;            /* return fd of master */
}
int ptym_open(char *pts_name, int pts_namesz)
{
    char *ptr;
    int fdm;

    /*
     * Return the name of the master device so that on failure
     * the caller can print an error message. Null terminate
     * to handle case where string length > pts_namesz.
     */
    strncpy(pts_name, "/dev/ptyXY", pts_namesz);
    pts_name[pts_namesz - 1] = '\0';
    if ((fdm = posix_openpt(O_RDWR)) < 0)
        return(-1);
    if (grantpt(fdm) < 0) {     /* grant access to slave */
        close(fdm);
        return(-2);
    }
    if (unlockpt(fdm) < 0) {    /* clear slave's lock flag */
        close(fdm);
        return(-3);
    }
    if ((ptr = ptsname(fdm)) == NULL) {     /* get slave's name */
        close(fdm);
        return(-4);
    }

    /*
     * Return name of slave. Null terminate to handle
     * case where strlen(ptr) > pts_namesz.
     */
    strncpy(pts_name, ptr, pts_namesz);
    pts_name[pts_namesz - 1] = '\0';
    return(fdm);    /* return fd of master */
}
Example #15
0
int open_master(char *name, int sz) {
  char *sname;
  int fd;

  strncpy(name, DEV_PTMX, sz);
  name[sz - 1] = '\0';

  fd = open(name, O_RDWR);
  if (fd < 0)
    return EPTMX_OPEN;

  if (grantpt(fd) < 0) {
    close(fd);
    return EPTMX_GRANT;
  }

  if (unlockpt(fd) < 0) {
    close(fd);
    return EPTMX_UNLOCK;
  }

  sname = ptsname(fd);
  if (sname == NULL) {
    close(fd);
    return EPTMX_NAME;
  }

  strncpy(name, sname, sz);
  name[sz - 1] = '\0';
  return fd;
}
Example #16
0
int open_pty() {
  int fd = check("posix_openpt", posix_openpt(O_RDWR | O_NOCTTY));
  check("grantpt",  grantpt(fd));
  check("unlockpt", unlockpt(fd));

  return fd;
}
Example #17
0
gint
ide_vte_pty_create_slave (VtePty *pty)
{
  gint master_fd;
#ifdef HAVE_PTSNAME_R
  char name[PATH_MAX + 1];
#else
  const char *name;
#endif

  g_assert (VTE_IS_PTY (pty));

  if (-1 == (master_fd = vte_pty_get_fd (pty)))
    return -1;

  if (grantpt (master_fd) != 0)
    return -1;

  if (unlockpt (master_fd) != 0)
    return -1;

#ifdef HAVE_PTSNAME_R
  if (ptsname_r (master_fd, name, sizeof name - 1) != 0)
    return -1;
  name[sizeof name - 1] = '\0';
#else
  if (NULL == (name = ptsname (master_fd)))
    return -1;
#endif

  return open (name, O_RDWR | O_CLOEXEC);
}
Example #18
0
int open_pty_pair(int *masterp, int *slavep)
{
	int master, slave;
	char name[1024];

	master = getpt();
	if (master < 0) {
		return 0;
	}

	if (grantpt(master) < 0 || unlockpt(master) < 0) {
		close(master);
		return 0;
	}

	if (ptsname_r(master, name, sizeof(name)) < 0) {
		close(master);
		return 0;
	}

	slave = open(name, O_RDWR);
	if (slave < 0) {
		close(master);
		return 0;
	}

	*masterp = master;
	*slavep = slave;
	return 1;
}
Example #19
0
File: pts.c Project: bobot/extunix
CAMLprim value caml_extunix_grantpt(value fd)
{
	CAMLparam1(fd);
	if(grantpt(Int_val(fd)) == -1)
		uerror("grantpt", Nothing);
	CAMLreturn(Val_unit); 
}
Example #20
0
int openpty(int* master, int* slave, char* name, const termios* t, const winsize* ws) {
  *master = getpt();
  if (*master == -1) {
    return -1;
  }

  if (grantpt(*master) == -1 || unlockpt(*master) == -1) {
    close(*master);
    return -1;
  }

  char buf[32];
  if (name == NULL) {
    name = buf;
  }
  if (ptsname_r(*master, name, sizeof(buf)) != 0) {
    close(*master);
    return -1;
  }

  *slave = open(name, O_RDWR|O_NOCTTY);
  if (*slave == -1) {
    close(*master);
    return -1;
  }

  if (t != NULL) {
    tcsetattr(*slave, TCSAFLUSH, t);
  }
  if (ws != NULL) {
    ioctl(*slave, TIOCSWINSZ, ws);
  }

  return 0;
}
Example #21
0
/*
 * main test driver
 */
int main(int argc, char **argv)
{
	int masterfd;		/* master pty fd */
	char *slavename;
	pid_t childpid;

/*--------------------------------------------------------------------*/
	masterfd = open(MASTERCLONE, O_RDWR);
	if (masterfd < 0)
		tst_brkm(TBROK | TERRNO, NULL, "open %s", MASTERCLONE);

	slavename = ptsname(masterfd);
	if (slavename == NULL)
		tst_brkm(TBROK | TERRNO, NULL, "ptsname");

	if (grantpt(masterfd) != 0)
		tst_brkm(TBROK | TERRNO, NULL, "grantpt");

	if (unlockpt(masterfd) != 0)
		tst_brkm(TBROK | TERRNO, NULL, "unlockpt");

	childpid = fork();
	if (childpid == -1)
		tst_brkm(TBROK | TERRNO, NULL, "fork");
	else if (childpid == 0)
		exit(child(masterfd));
	else
		parent(masterfd, childpid);
/*--------------------------------------------------------------------*/
	cleanup();

	tst_exit();
}
Example #22
0
/*
 * ptym_open --
 *	This function opens a master pty and returns the file descriptor
 *	to it.  pts_name is also returned which is the name of the slave.
 */
static int
ptym_open(char *pts_name)
{
	int fdm;
	char *ptr;

	strcpy(pts_name, _PATH_SYSV_PTY);
	if ((fdm = open(pts_name, O_RDWR)) < 0 )
		return (-1);

	if (grantpt(fdm) < 0) {
		close(fdm);
		return (-2);
	}

	if (unlockpt(fdm) < 0) {
		close(fdm);
		return (-3);
	}

	if (unlockpt(fdm) < 0) {
		close(fdm);
		return (-3);
	}

	/* get slave's name */
	if ((ptr = ptsname(fdm)) == NULL) {
		close(fdm);
		return (-3);
	}
	strcpy(pts_name, ptr);
	return (fdm);
}
Example #23
0
/* To open and start new
 * python shell process
 */
gboolean
ptyFork (ChildProcessData *python_shell_data, GError **error)
{
    int mfd, slaveFd, savedErrno;

    mfd = posix_openpt (O_RDWR | O_NOCTTY | O_NONBLOCK);     
    grantpt (mfd);
    unlockpt (mfd);

    python_shell_data->master_fd = mfd;
    python_shell_data->slave_name = g_strdup (ptsname (mfd));
    python_shell_data->sh_argv = g_malloc0 (sizeof (gchar *));
    python_shell_data->sh_argv[0] = g_strdup ("/bin/sh");

    /*if (!g_spawn_async (python_shell_data->current_dir, python_shell_data->argv, NULL, 0, 
                       child_func, (gpointer)python_shell_data, 
                       &(python_shell_data->pid), error))

        return FALSE;*/

    pid_t childPid = fork ();
    if (childPid == 0)
    {
        child_func ((gpointer)python_shell_data);
        execv (python_shell_data->sh_argv [0], python_shell_data->sh_argv);
    }
    python_shell_data->pid = childPid;
    return TRUE;
}
Example #24
0
int
ptym_open(char *pts_name)
{
	char	*ptr;
	int		fdm;

	strcpy(pts_name, "/dev/ptmx");	/* in case open fails */
	if ( (fdm = open(pts_name, O_RDWR)) < 0)
		return(-1);

	if (grantpt(fdm) < 0) {		/* grant access to slave */
		close(fdm);
		return(-2);
	}
	if (unlockpt(fdm) < 0) {	/* clear slave's lock flag */
		close(fdm);
		return(-3);
	}
	if ( (ptr = ptsname(fdm)) == NULL) {	/* get slave's name */
		close(fdm);
		return(-4);
	}

	strcpy(pts_name, ptr);	/* return name of slave */
	return(fdm);			/* return fd of master */
}
Example #25
0
static int
pty_open_master (char *pty_name)
{
    char *slave_name;
    int pty_master;

#ifdef HAVE_POSIX_OPENPT
    pty_master = posix_openpt (O_RDWR);
#elif HAVE_GETPT
    /* getpt () is a GNU extension (glibc 2.1.x) */
    pty_master = getpt ();
#elif IS_AIX
    strcpy (pty_name, "/dev/ptc");
    pty_master = open (pty_name, O_RDWR);
#else
    strcpy (pty_name, "/dev/ptmx");
    pty_master = open (pty_name, O_RDWR);
#endif

    if (pty_master == -1)
        return -1;

    if (grantpt (pty_master) == -1      /* Grant access to slave */
            || unlockpt (pty_master) == -1  /* Clear slave's lock flag */
            || !(slave_name = ptsname (pty_master)))        /* Get slave's name */
    {
        close (pty_master);
        return -1;
    }
    strcpy (pty_name, slave_name);
    return pty_master;
}
Example #26
0
/*
 * Allocate pty master (APUE, p. 638).
 */
int
ptym_open(char *pts_name, size_t namsz)
{
	char *ptr;
	int fdm;

	strcpy(pts_name, "/dev/ptmx");
	if ((fdm = open(pts_name, O_RDWR)) < 0)
		return -1;
	if (grantpt(fdm) < 0) {
		close(fdm);
		return -2;
	}
	if (unlockpt(fdm) < 0) {
		close(fdm);
		return -3;
	}
	if ((ptr = ptsname(fdm)) == NULL) {
		close(fdm);
		return -4;
	}
	strncpy(pts_name, ptr, namsz);
#ifndef	__linux__
	if (ioctl(fdm, I_PUSH, "pckt") < 0) {
		close(fdm);
		return -5;
	}
#endif	/* !__linux__ */
	return fdm;
}
Example #27
0
int right_side::create_ps_term() {
    int master;
    if ((master = posix_openpt(O_RDWR)) == -1) { throw_error("posix_openpt()"); }
    if (grantpt(master) == -1) { throw_error("grantpt()"); }
    if (unlockpt(master) == -1) { throw_error("inlockpt()"); }

    int slave = open(ptsname(master), O_RDWR);
    if (slave == -1) { throw_error("open(ptsname(master)..."); }

    child = fork();
    if (child == -1) { throw_error("fork()"); }

    if (!child) {
        struct termios settings;
        tcgetattr(slave, &settings);
        cfmakeraw(&settings);
        tcsetattr(slave, TCSANOW, &settings);

        close(master);
        if (dup2(slave, STDIN_FILENO) == -1) {throw_error("dup2(slave, STDIN_FILENO)");}
        if (dup2(slave, STDOUT_FILENO) == -1) {throw_error("dup2(slave, STDOUT_FILENO)");}
        if (dup2(slave, STDERR_FILENO) == -1) {throw_error("dup2(slave, STDERR_FILENO)");}
        close(slave);

        setsid();
        ioctl(0, TIOCSCTTY, 1);

        if (execlp("/bin/sh", "sh", NULL) == -1) {throw_error("execlp()");}
    } else {
        close(slave);
    }

    return master;
}
Example #28
0
/*
 * test hangup semantics
 */
int
test6(void)
{
	static int masterfd;
	static int slavefd;
	char *slavename;
	struct termios termios;

	masterfd = open(MASTERCLONE, O_RDWR);
	if (masterfd < 0) {
		tst_resm(TBROK,"%s",MASTERCLONE);
		tst_exit();
	}

	slavename = ptsname(masterfd);
	if (slavename == NULL) {
		tst_resm(TBROK|TERRNO, "ptsname() call failed");
		tst_exit();
	}

	if (grantpt(masterfd) != 0) {
		tst_resm(TBROK|TERRNO, "grantpt() call failed");
		tst_exit();
	}

	if (unlockpt(masterfd) != 0) {
		tst_resm(TBROK,"unlockpt() call failed");
		tst_exit();
	}

	if ((slavefd = open(slavename, O_RDWR)) < 0) {
		tst_resm(TBROK,"Could not open %s",slavename);
		tst_exit();
	}

	if (ioctl(slavefd, TCGETS, &termios) != 0) {
		tst_resm(TFAIL,"TCGETS");
		tst_exit();
	}

	termios.c_cflag &= ~CBAUD;
	termios.c_cflag |= B0&CBAUD;
	if (ioctl(slavefd, TCSETS, &termios) != 0) {
		tst_resm(TFAIL,"TCGETS");
		tst_exit();
	}

	if (close(slavefd) != 0) {
		tst_resm(TBROK,"close");
		tst_exit();
	}
	if (close(masterfd) != 0) {
		tst_resm(TBROK,"close");
		tst_exit();
	}
	tst_resm(TPASS,"test6");

	/** NOT REACHED **/
	return 0;
}
Example #29
0
bool
get_pty(int *master, int *slave, char *name, size_t namesz, uid_t ttyuid)
{
    char *line;
    bool rval = false;
    debug_decl(get_pty, SUDO_DEBUG_PTY)

    *master = posix_openpt(O_RDWR|O_NOCTTY);
    if (*master != -1) {
	(void) grantpt(*master); /* may fork */
	if (unlockpt(*master) != 0) {
	    close(*master);
	    goto done;
	}
	line = ptsname(*master);
	if (line == NULL) {
	    close(*master);
	    goto done;
	}
	*slave = open(line, O_RDWR|O_NOCTTY, 0);
	if (*slave == -1) {
	    close(*master);
	    goto done;
	}
# if defined(I_PUSH) && !defined(_AIX)
	ioctl(*slave, I_PUSH, "ptem");	/* pseudo tty emulation module */
	ioctl(*slave, I_PUSH, "ldterm");	/* line discipline module */
# endif
	(void) chown(line, ttyuid, -1);
	strlcpy(name, line, namesz);
	rval = true;
    }
done:
    debug_return_bool(rval);
}
Example #30
0
int
GUCEF_pty_open( int* fdm, int* fds )
{
    int masterfd, slavefd;
    char *slavedevice;

    /*
     *  O_RDWR = Open the device for both reading and writing. It is usual to specify this flag.
     *  O_NOCTTY = Do not make this device the controlling terminal for the process.
     */
    masterfd = posix_openpt( O_RDWR | O_NOCTTY );

    if ( masterfd == -1 ||
         grantpt (masterfd) == -1 ||
         unlockpt (masterfd) == -1 ||
         (slavedevice = ptsname (masterfd)) == NULL)
        return 1;

    slavefd = open(slavedevice, O_RDWR|O_NOCTTY);
    if (slavefd < 0)
        return 1;

    /* success */
    *fdm = masterfd;
    *fds = slavefd;
    return 0;
}