Exemplo n.º 1
0
static pid_t frkpty(int *masterin, char *slavename) {
	int master, slave;
	pid_t chldp;

	if (openpty(&master, &slave, slavename, NULL, NULL) < 0) {
		_exit(1);
	}

	chldp=fork();
	if (chldp == -1) {
		_exit(1);
	}
	else if (chldp == 0) {
		close(master);
		setsid();
		if (ioctl(slave, TIOCSCTTY) < 0) {
			/*_exit(1);*/
		}
		/* dont really care what fails here */
		dup2(slave, 0);
		dup2(slave, 1);
		dup2(slave, 2);
		return 0;
	}
	else {
		*masterin=master;
		close(slave);
		return chldp;
	}
	exit(1);
}
Exemplo n.º 2
0
static int open_device(uart_ctx_t* ctx, char* name)
{
    int flags;
    int fd;

#ifdef HAVE_PTY
    if (strcmp(name, "pty") == 0) {
	int fd1;
	char slave_name[UART_MAX_DEVICE_NAME];

	if (openpty(&fd,&fd1,slave_name,NULL,NULL) < 0)
	    return -1;
	INFOF("slave name = %s", slave_name);
	strcpy(name, slave_name);
	// close(fd1); // ???
    } else
#endif
    {
	if ((fd = open(name, O_RDWR|O_NDELAY|O_NOCTTY)) < 0)
	    return -1;
    }
    flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);   // non-blocking!!!

    tcflush(fd, TCOFLUSH);
    tcflush(fd, TCIFLUSH);
    ctx->fd = fd;
    DEBUGF("open_device: %d", ctx->fd);
    return fd;
}
Exemplo n.º 3
0
/*
 * Get device node names for the master and slave end of a free pseudo
 * terminal.  We don't want to replicate the entire openpty(3) logic here, so
 * start by letting openpty(3) do the work for us.  We make the assumption that
 * nobody snatches the pair while we are running.
 */
static void
get_names(char pname[PATH_MAX], char tname[PATH_MAX])
{
	int len, masterfd, slavefd;

	if (openpty(&masterfd, &slavefd, tname, NULL, NULL) < 0) e(300);

	/*
	 * openpty(3) gives us only the slave name, but we also need the master
	 * name.
	 */
	strlcpy(pname, tname, PATH_MAX);
	len = strlen(_PATH_DEV);

	if (strncmp(pname, _PATH_DEV, len)) e(301);

	/* If this fails, this test needs to be updated. */
	if (pname[len] != 't') e(302);

	pname[len] = 'p';

	test_comm(masterfd, slavefd);

	if (close(masterfd) < 0) e(303);
	if (close(slavefd) < 0) e(304);
}
Exemplo n.º 4
0
Arquivo: pty.c Projeto: 2asoft/freebsd
int
forkpty(int *amaster, char *name, struct termios *termp, struct winsize *winp)
{
	int master, slave, pid;

	if (openpty(&master, &slave, name, termp, winp) == -1)
		return (-1);
	switch (pid = fork()) {
	case -1:
		return (-1);
	case 0:
		/*
		 * child
		 */
		(void) close(master);
		login_tty(slave);
		return (0);
	}
	/*
	 * parent
	 */
	*amaster = master;
	(void) close(slave);
	return (pid);
}
Exemplo n.º 5
0
int
forkpty (int *amaster, char *name,
         const struct termios *termp, const struct winsize *winp)
{
  int master, slave, pid;

  if (openpty (&master, &slave, name, termp, winp) == -1)
    return -1;

  switch (pid = fork ())
    {
    case -1:
      close (master);
      close (slave);
      return -1;

    case 0:
      /* Child.  */
      close (master);
      if (login_tty (slave))
        _exit (1);
      return 0;

    default:
      /* Parent.  */
      *amaster = master;
      close (slave);
      return pid;
    }
}
Exemplo n.º 6
0
/*
 *	For some reason, openpty() in glibc sometimes doesn't
 *	work at boot-time. It must be a bug with old-style pty
 *	names, as new-style (/dev/pts) is not available at that
 *	point. So, we find a pty/tty pair ourself if openpty()
 *	fails for whatever reason.
 */
int findpty(int *master, int *slave, char *name)
{
	char	pty[16];
	char	tty[16];
	int	i, j;
	int	found;

	if (openpty(master, slave, name, NULL, NULL) >= 0)
		return 0;

	found = 0;

	for (i = 'p'; i <= 'z'; i++) {
		for (j = '0'; j <= 'f'; j++) {
			if (j == '9' + 1) j = 'a';
			sprintf(pty, "/dev/pty%c%c", i, j);
			sprintf(tty, "/dev/tty%c%c", i, j);
			if ((*master = open(pty, O_RDWR|O_NOCTTY)) >= 0) {
				*slave = open(tty, O_RDWR|O_NOCTTY);
				if (*slave >= 0) {
					found = 1;
					break;
				}
			}
		}
		if (found) break;
	}
	if (!found) return -1;

	if (name) strcpy(name, tty);

	return 0;
}
Exemplo n.º 7
0
static gboolean create_tty(const char *modem_path)
{
	int master, slave;
	char pty_name[256];
	GIOChannel *server_io;

	if (modem_path == NULL)
		return FALSE;

	if (openpty(&master, &slave, pty_name, NULL, NULL) < 0)
		return FALSE;

	set_raw_mode(slave);

	g_print("new pty is created at %s\n", pty_name);

	server_io = g_io_channel_unix_new(master);

	server = g_at_server_new(server_io);
	if (server == NULL) {
		g_io_channel_shutdown(server_io, FALSE, NULL);
		g_io_channel_unref(server_io);

		return FALSE;
	}

	g_io_channel_unref(server_io);

	return TRUE;
}
Exemplo n.º 8
0
PRIVATE static
bool
Pic::prepare_irq(int sockets[2])
{
  struct termios tt;

  if (openpty(&sockets[0], &sockets[1], NULL, NULL, NULL))
    {
      perror("openpty");
      return false;
    }

  if (tcgetattr(sockets[0], &tt) < 0)
    {
      perror("tcgetattr");
      return false;
    }

  cfmakeraw(&tt);

  if (tcsetattr(sockets[0], TCSADRAIN, &tt) < 0)
    {
      perror("tcsetattr");
      return false;
    }

  fflush(NULL);

  return true;
}
Exemplo n.º 9
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;
}
Exemplo n.º 10
0
	explicit GnuplotPty(bool debug_messages) :
					pty_fn(), pty_fh(NULL), master_fd(-1), slave_fd(-1)
	{
	// adapted from http://www.gnuplot.info/files/gpReadMouseTest.c
		if(0 > openpty(&master_fd, &slave_fd, NULL, NULL, NULL)) {
			perror("openpty");
			throw std::runtime_error("openpty failed");
		}
		char pty_fn_buf[1024];
		if(ttyname_r(slave_fd, pty_fn_buf, 1024)) {
			perror("ttyname_r");
			throw std::runtime_error("ttyname failed");
		}
		pty_fn = std::string(pty_fn_buf);
		if(debug_messages) {
			std::cerr << "fn=" << pty_fn << std::endl;
		}

		// disable echo
		struct termios tios;
		if(tcgetattr(slave_fd, &tios) < 0) {
			perror("tcgetattr");
			throw std::runtime_error("tcgetattr failed");
		}
		tios.c_lflag &= ~(ECHO | ECHONL);
		if(tcsetattr(slave_fd, TCSAFLUSH, &tios) < 0) {
			perror("tcsetattr");
			throw std::runtime_error("tcsetattr failed");
		}

		pty_fh = fdopen(master_fd, "r");
		if(!pty_fh)
			throw std::runtime_error("fdopen failed");
	}
Exemplo n.º 11
0
int qemu_openpty_raw(int *aslave, char *pty_name)
{
#ifndef __ANDROID__
    int amaster;
    struct termios tty;
#endif
#if defined(__OpenBSD__) || defined(__DragonFly__)
    char pty_buf[PATH_MAX];
#define q_ptsname(x) pty_buf
#elif defined(__ANDROID__)
#else
    char *pty_buf = NULL;
#define q_ptsname(x) ptsname(x)
#endif

#ifdef __ANDROID__
    return -1;
#else
    if (openpty(&amaster, aslave, pty_buf, NULL, NULL) < 0) {
        return -1;
    }

    /* Set raw attributes on the pty. */
    tcgetattr(*aslave, &tty);
    cfmakeraw(&tty);
    tcsetattr(*aslave, TCSAFLUSH, &tty);

    if (pty_name) {
        strcpy(pty_name, q_ptsname(amaster));
    }

    return amaster;
#endif //__ANDROID__
}
Exemplo n.º 12
0
static UInt OpenPty( int *pty, int *tty )
{
#if HAVE_OPENPTY
    /* openpty is available on OpenBSD, NetBSD and FreeBSD, Mac OS X,
       Cygwin, Interix, OSF/1 4 and 5, and glibc (since 1998), and hence
       on most modern Linux systems. See also:
       http://www.gnu.org/software/gnulib/manual/html_node/openpty.html */
    return (openpty(pty, tty, NULL, NULL, NULL) < 0);
#else
    Char ttyname[32];
    Char ptyname[32];

    /* construct the name of the pseudo terminal */
    strcpy( ttyname, SYS_TTYDEV );
    strcpy( ptyname, SYS_PTYDEV );

    if ( GetMasterPty(pty, ttyname, ptyname) ) {
        Pr( "open master failed\n", 0L, 0L );
        return 1;
    }
    *tty = open( ttyname, O_RDWR, 0 );
    if ( *tty < 0 ) {
        Pr( "open slave failed\n", 0L, 0L );
        close(*pty);
        return 1;
    }
    return 0;
#endif
}
Exemplo n.º 13
0
int make_new_session(int new_sock_fd)
{
    int ret, sv[2], use_socket_pair=1;
    set_useful_sock_opt(new_sock_fd);
    snd_iac(new_sock_fd,DONT, TELOPT_ECHO);
    snd_iac(new_sock_fd,DO, TELOPT_LFLOW);
    snd_iac(new_sock_fd,WILL, TELOPT_ECHO);
    snd_iac(new_sock_fd,WILL, TELOPT_SGA);

    if (use_socket_pair)
    {
        ret=socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
    }
    else
    {
        ret=openpty(&(sv[0]), &(sv[1]), NULL, NULL, NULL);
        tty_cfg(fd_pty_slave);
    }


    if (ret<0)
    {
        return ret;
    }

    fd_conn = new_sock_fd;
    set_fd_nonblock(fd_conn);
    fd_pty_master = sv[0];
    fd_pty_slave  = sv[1];

    shell_thread_should_exit = 0;
    pthread_create(&the_shell_thread, NULL, the_shell_thread_func, NULL);
    return 0;
}
Exemplo n.º 14
0
wxString wxTerminal::StartTTY()
{
    m_process = NULL;

    char __name[128];
    memset(__name, 0, sizeof(__name));

    int master(-1);
    m_slave = -1;
    if(openpty(&master, &m_slave, __name, NULL, NULL) != 0)
        return wxT("");

    // disable ECHO
    struct termios termio;
    tcgetattr(master, &termio);
    termio.c_lflag = ICANON;
    termio.c_oflag = ONOCR | ONLRET;
    tcsetattr(master, TCSANOW, &termio);

    m_tty = wxString(__name, wxConvUTF8);
    m_tty = ptsname(master);
    
    // Start a listener on the tty
    m_dummyProcess = new UnixProcessImpl(this);
    static_cast<UnixProcessImpl*>(m_dummyProcess)->SetReadHandle  (master);
    static_cast<UnixProcessImpl*>(m_dummyProcess)->SetWriteHandler(master);
    static_cast<UnixProcessImpl*>(m_dummyProcess)->SetPid(wxNOT_FOUND);
    static_cast<UnixProcessImpl*>(m_dummyProcess)->StartReaderThread();
    return m_tty;
}
Exemplo n.º 15
0
/* Create a pseudo terminal for other process to use (as this program is using up the actual TTY) */
int create_pseudo_tty()
{
	int amaster, aslave;
	int flags;

	if (openpty(&amaster, &aslave, NULL, NULL, NULL) == -1) {
		errlog("Error: Openpty failed - %m\n");
		return -1;
	}

	/* Set to non blocking mode */
	flags = fcntl(amaster, F_GETFL);
	flags |= O_NONBLOCK;
	fcntl(amaster, F_SETFL, flags);

	FILE *pseudo_save_file = fopen(pseudo_tty_save_file, "w+");
	if (!pseudo_save_file) {
		errlog("Error: Unable to open the pseudo info file - %m\n");
		return -1;
	}
	/* Save the name of the created pseudo tty in a text file for other processes to use */
	if (fprintf(pseudo_save_file, "%s\n", ttyname(aslave)) == -1) {
		errlog("Error writing to the pseudo info file\n");
		fclose(pseudo_save_file);
		return -1;
	}
	fclose(pseudo_save_file);

	if (set_tty(aslave) == -1) {
		errlog("Error: Slave TTY not set properly\n");
		return -1;
	}

	return amaster;
}
Exemplo n.º 16
0
//------------pseudoPTY()--------------------------//
//Create a psuedo terminal			   //
//Return the path and name of the PTY port         //
//Returns a file descriptor for the pseudo terminal//
//-------------------------------------------------//
int pseudoTY(char** PTY)
{
	//char *letters;
	int master;
	int slave;
	
	pid_t pid = openpty(&master,&slave,NULL,NULL,NULL);//Create a pseudo terminal
	//Use ttyname() on the file descriptor to find the name of the terminal
	//That is:  slave name = ttyname(slave);

	if(pid == -1){//Openpty() failed
		perror("Openpty() Failed!  :");
		return pid;
	} 
	if(pid == 0){//Openpty() successful
		(*PTY) = ttyname(slave);
		// Ensure that the echo is switched off 
		struct termios orig_termios;
		if (tcgetattr (master, &orig_termios) < 0) {
			perror ("ERROR getting current terminal's attributes");
			return -1;
		}
		
		orig_termios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
		orig_termios.c_oflag &= ~(ONLCR);
		
		if (tcsetattr (master, TCSANOW, &orig_termios) < 0) {
			perror ("ERROR setting current terminal's attributes");
			return -1;
		}
		return master; //Return the file descriptor
	}
}
Exemplo n.º 17
0
int open_master(

  char **rtn_name) /* RETURN name of slave pts */

  {
  int master;
  int slave;
  static char slave_name[PTY_SIZE];

  int status = openpty(&master, &slave, slave_name, 0, 0);

  if (status < 0)
    {
    log_err(errno, "open_master",
            "failed in openpty()");

    return(-1);
    }

  close(slave);

  /* open_master has no way to return this, must return slave_name instead */

  *rtn_name = slave_name;

  return(master);
  }  /* END open_master() */
Exemplo n.º 18
0
Arquivo: trytty.c Projeto: 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
}
Exemplo n.º 19
0
int forkpty(int* master, char* name, const termios* t, const winsize* ws) {
  int slave;
  if (openpty(master, &slave, name, t, ws) == -1) {
    return -1;
  }

  pid_t pid = fork();
  if (pid == -1) {
    close(*master);
    close(slave);
    return -1;
  }

  if (pid == 0) {
    // Child.
    close(*master);
    if (login_tty(slave) == -1) {
      _exit(1);
    }
    return 0;
  }

  // Parent.
  close(slave);
  return pid;
}
Exemplo n.º 20
0
int
do_pty(void)
{
	struct kevent ev[4];
	struct termios tt;
	int kq, massa, slave;
	char buf[1024];

	tcgetattr(STDIN_FILENO, &tt);
	cfmakeraw(&tt);
	tt.c_lflag &= ~ECHO;
	if (openpty(&massa, &slave, NULL, &tt, NULL) < 0)
		err(1, "openpty");
	if (fcntl(massa, F_SETFL, O_NONBLOCK) < 0)
		err(1, "massa: fcntl");
	if (fcntl(slave, F_SETFL, O_NONBLOCK) < 0)
		err(1, "massa: fcntl");
	if ((kq = kqueue()) == -1)
		err(1, "kqueue");

	/* test the read from the slave works */
	EV_SET(&ev[0], massa, EVFILT_READ,  EV_ADD|EV_ENABLE, 0, 0, NULL);
	EV_SET(&ev[1], massa, EVFILT_WRITE, EV_ADD|EV_ENABLE, 0, 0, NULL);
	EV_SET(&ev[2], slave, EVFILT_READ,  EV_ADD|EV_ENABLE, 0, 0, NULL);
	EV_SET(&ev[3], slave, EVFILT_WRITE, EV_ADD|EV_ENABLE, 0, 0, NULL);
	if (kevent(kq, ev, 4, NULL, 0, NULL) < 0)
		err(1, "slave: kevent add");

	memset(buf, 0, sizeof buf);

	if (write(massa, " ", 1) != 1)
		err(1, "massa: write");

	if (pty_check(kq, ev, 4, -massa, slave, massa, slave))
		return (1);

	read(slave, buf, sizeof(buf));

	if (pty_check(kq, ev, 4, -massa, -slave, massa, slave))
		return (1);

	while (write(massa, buf, sizeof(buf)) > 0)
		continue;

	if (pty_check(kq, ev, 4, -massa, slave, -massa, slave))
		return (1);

	read(slave, buf, 1);

	if (pty_check(kq, ev, 4, -massa, slave, massa, slave))
		return (1);

	while (read(slave, buf, sizeof(buf)) > 0)
		continue;

	if (pty_check(kq, ev, 4, -massa, -slave, massa, slave))
		return (1);

	return (0);
}
Exemplo n.º 21
0
int
rpl_openpty (int *amaster, int *aslave, char *name,
             struct termios const *termp, struct winsize const *winp)
{
  /* Cast away const, for implementations with weaker prototypes.  */
  return openpty (amaster, aslave, name, (struct termios *) termp,
                  (struct winsize *) winp);
}
Exemplo n.º 22
0
int getpty(void) {
    int masterfd;

    if (openpty(&masterfd, &ptyslavefd, line, NULL, NULL)) {
	return -1;
    }
    return masterfd;
}
Exemplo n.º 23
0
static char *openmaster(int *master, int *slave)
{
    int m, s;
    static char path[1024];
    if (openpty(&m, &s, path, NULL, NULL) < 0) return NULL;
    *master = m;
    *slave = s;
    return path;
}
Exemplo n.º 24
0
static ERL_NIF_TERM allocate_pty_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    int master;
    int slave;
    char* name;
    openpty(&master, &slave, NULL, NULL, NULL);
    name = ttyname(slave);
    return enif_make_tuple2(env, enif_make_int(env, master), enif_make_string(env, name, ERL_NIF_LATIN1));
}
Exemplo n.º 25
0
TEST(pty, bug_28979140) {
  // This test is to test a kernel bug, which uses a lock free ring-buffer to
  // pass data through a raw pty, but missing necessary memory barriers.
  cpu_set_t cpus;
  ASSERT_EQ(0, sched_getaffinity(0, sizeof(cpu_set_t), &cpus));
  if (CPU_COUNT(&cpus) < 2) {
    GTEST_LOG_(INFO) << "This test tests bug happens only on multiprocessors.";
    return;
  }
  constexpr uint32_t TEST_DATA_COUNT = 200000;

  // 1. Open raw pty.
  int master;
  int slave;
  ASSERT_EQ(0, openpty(&master, &slave, nullptr, nullptr, nullptr));
  termios tattr;
  ASSERT_EQ(0, tcgetattr(slave, &tattr));
  cfmakeraw(&tattr);
  ASSERT_EQ(0, tcsetattr(slave, TCSADRAIN, &tattr));

  // 2. Make master thread and slave thread running on different cpus:
  // master thread uses first available cpu, and slave thread uses other cpus.
  PtyReader_28979140_Arg arg;
  arg.main_cpu_id = -1;
  for (int i = 0; i < CPU_SETSIZE; i++) {
    if (CPU_ISSET(i, &cpus)) {
      arg.main_cpu_id = i;
      break;
    }
  }
  ASSERT_GE(arg.main_cpu_id, 0);

  // 3. Create thread for slave reader.
  pthread_t thread;
  arg.slave_fd = slave;
  arg.data_count = TEST_DATA_COUNT;
  arg.matched = true;
  ASSERT_EQ(0, pthread_create(&thread, nullptr,
                              reinterpret_cast<void*(*)(void*)>(PtyReader_28979140),
                              &arg));

  CPU_ZERO(&cpus);
  CPU_SET(arg.main_cpu_id, &cpus);
  ASSERT_EQ(0, sched_setaffinity(0, sizeof(cpu_set_t), &cpus));

  // 4. Send data to slave.
  uint32_t counter = 0;
  while (counter <= TEST_DATA_COUNT) {
    ASSERT_TRUE(android::base::WriteFully(master, &counter, sizeof(counter)));
    ASSERT_TRUE(arg.matched) << "failed at count = " << counter;
    counter++;
  }
  ASSERT_EQ(0, pthread_join(thread, nullptr));
  ASSERT_TRUE(arg.finished);
  ASSERT_TRUE(arg.matched);
  close(master);
}
Exemplo n.º 26
0
int run_console (void)
{
	int slave;
	int rc;
    rc = openpty (&master, &slave, pty_name, 0,0);
	printf ("pty name: %s\n", pty_name);
	close (slave);
	return master;
}
Exemplo n.º 27
0
/* c_openpty: unit -> (int * Unix.file_descr) */
CAMLprim value c_openpty() {
  int master,slave;
  value pair;
  if (openpty(&master,&slave,NULL,NULL,NULL) < 0)
    uerror("openpty", (value) 0);
  pair = alloc_tuple(2);
  Store_field(pair,0,Val_int(master));
  Store_field(pair,1,Val_int(slave));
  return pair;
}
Exemplo n.º 28
0
int
GUCEF_pty_open(int *fdm, int *fds)
{
    if ( -1 == openpty( fdm, fds, NULL, NULL, NULL ) )
    {
        /* something went wrong, no pseudo terminals available? */
        return 1;
    }
    return 0;
}
Exemplo n.º 29
0
Arquivo: tty.c Projeto: Distrotech/joe
static unsigned char *getpty(int *ptyfd)
{
	static unsigned char name[32];
	int ttyfd;

        if (openpty(ptyfd, &ttyfd, (char *)name, NULL, NULL) == 0)
           return(name);
        else
	   return (NULL);
}
Exemplo n.º 30
0
void ezioDevice300::CreatePort(int &fd_master, int &fd_slave)
{
#if 0
	struct termios tio;
	switch (baud_rate) {
	case 2400:
		cfsetospeed(&tio, B2400);
		cfsetispeed(&tio, B2400);
		break;
	default:
		throw ezioException(EZIOEX_INVALID_BAUD);
	}

	// Set input modes 
	tio.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | INPCK | ISTRIP |
		INLCR | IGNCR | ICRNL | IUCLC | IXON | IXANY | IXOFF |
		IMAXBEL);
	tio.c_iflag |= IGNPAR;

	// Set output modes 
	tio.c_oflag &= ~(OPOST | OLCUC | ONLCR | OCRNL | ONOCR | ONLRET |
		OFILL | OFDEL | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY |
		FFDLY);
	tio.c_oflag |= NL0 | CR0 | TAB0 | BS0 | VT0 | FF0;

	// Set control modes
	tio.c_cflag &= ~(CSIZE | PARENB | CRTSCTS | PARODD | HUPCL);
	tio.c_cflag |= CREAD | CS8 | CSTOPB | CLOCAL;

	// Set local modes 
	tio.c_lflag &= ~(ISIG | ICANON | IEXTEN | ECHO | FLUSHO | PENDIN);
	tio.c_lflag |= NOFLSH;

	if (openpty(&fd_master, &fd_slave, tty, &tio, NULL) < 0)
#endif
	char tty[1024];

	if (openpty(&fd_master, &fd_slave, tty, NULL, NULL) < 0)
		throw ezioException(EZIOEX_EMUL_OPENPTY);

	printf("%s: created port: %s\n", name.c_str(), tty);
}