Example #1
0
void
tty_stop_tty(struct tty *tty)
{
	struct winsize	ws;

	/*
	 * Be flexible about error handling and try not kill the server just
	 * because the fd is invalid. Things like ssh -t can easily leave us
	 * with a dead tty.
	 */
	if (ioctl(tty->fd, TIOCGWINSZ, &ws) == -1)
		return;
	if (tcsetattr(tty->fd, TCSANOW, &tty->tio) == -1)
		return;

	tty_raw(tty, tty_term_string2(tty->term, TTYC_CSR, 0, ws.ws_row - 1));
	tty_raw(tty, tty_term_string(tty->term, TTYC_RMACS));
	tty_raw(tty, tty_term_string(tty->term, TTYC_SGR0));
	tty_raw(tty, tty_term_string(tty->term, TTYC_RMKX));
	tty_raw(tty, tty_term_string(tty->term, TTYC_RMCUP));
	tty_raw(tty, tty_term_string(tty->term, TTYC_CLEAR));

	tty_raw(tty, tty_term_string(tty->term, TTYC_CNORM));
	if (tty_term_has(tty->term, TTYC_KMOUS))
		tty_raw(tty, "\033[?1000l");
}
Example #2
0
int debutTerminalSansR()
{
    if (tty_raw() != 0)
        return 0;
    atexit(tty_reset);
    return 1;
}
Example #3
0
void init_tty(void)
/* Get terminal capabilities and set the tty to "editor" mode. */
{
	char *term;
	static char termbuf[1024];
	char *tp;

	if ((term= getenv("TERM")) == nil || tgetent(termbuf, term) != 1) {
		fprintf(stderr, "part: Can't get terminal capabilities\n");
		exit(1);
	}
	if (tgetstr("cd", (tp= t_cd, &tp)) == nil
				|| tgetstr("cm", (tp= t_cm, &tp)) == nil) {
		fprintf(stderr, "part: This terminal is too dumb\n");
		exit(1);
	}
	t_li= tgetnum("li");
	t_co= tgetnum("co");
	(void) tgetstr("so", (tp= t_so, &tp));
	(void) tgetstr("se", (tp= t_se, &tp));
	(void) tgetstr("md", (tp= t_md, &tp));
	(void) tgetstr("me", (tp= t_me, &tp));

	save_ttyflags();
	tty_raw();
}
Example #4
0
/*
 * Read a line from the user.  Call our buf_args() function to
 * break it into an argv-style array, and call userfunc() to
 * process the arguments.
 */
int
prompt_read(char *prompt, int (*userfunc)(int, char **))
{
	int		n;
	char	c, *ptr;

	tty_reset(STDIN_FILENO);	/* allow user's editing chars */

	n = strlen(prompt);
	if (write(STDOUT_FILENO, prompt, n) != n)
		err_sys("write error");

	ptr = cmdargs;
	for ( ; ; ) {
		if ((n = read(STDIN_FILENO, &c, 1)) < 0)
			err_sys("read error");
		else if (n == 0)
			break;
		if (c == '\n')
			break;
		if (ptr < &cmdargs[MAXLINE-2])
			*ptr++ = c;
	}
	*ptr = 0;		/* null terminate */

	tty_raw(STDIN_FILENO);		/* reset tty mode to raw */

	/*
	 * Return whatever userfunc() returns.
	 */
	return(buf_args(cmdargs, userfunc));
}
Example #5
0
/*
**	funkey_keys(test_list, status, ch)
**
**	Test function keys
*/
static void
funkey_keys(
	       TestList * t,
	       int *state,
	       int *ch)
{
    char keybuf[256];

    if (keypad_xmit) {
	tc_putp(keypad_xmit);
    }
    keys_tested(1, 1, hex_out);	/* also clears screen */
    keybuf[0] = '\0';
    end_state = 0;
    if (scan_mode) {
	fkmax = scan_max;
    }
    tty_raw(0, char_mask);
    while (end_state != 'd') {
	read_key(keybuf, sizeof(keybuf));
	fresh_line();
	if (found_match(keybuf, hex_out, 0)) {
	    continue;
	}
	if (found_exit(keybuf, hex_out, 0)) {
	    break;
	}
    }
    if (keypad_local) {
	tc_putp(keypad_local);
    }
    keys_tested(0, 0, hex_out);
    ptext("Function key test ");
    generic_done_message(t, state, ch);
}
Example #6
0
/* Called when window is resized. */
static void 
sigwinch()
{
  tty_restore();
  tty_raw();
  action(NULL);
}
Example #7
0
static int resizetty(void)
{
	/* 
	 * \e7        Save current state (cursor coordinates, attributes,
	 *                character sets pointed at by G0, G1).
	 * \e[r       Set scrolling region; parameters are top and bottom row.
	 * \e[32766E  Move cursor down 32766 (INT16_MAX - 1) rows.
	 * \e[32766C  Move cursor right 32766 columns.
	 * \e[6n      Report cursor position.
	 * \e8        Restore state most recently saved by \e7.
	 */
	static const char *getpos = "\e7\e[r\e[32766E\e[32766C\e[6n\e8";
	char retstr[32];
	int row, col;
	size_t pos;
	ssize_t rc;
	struct winsize ws;
	struct termios saved_attributes;
	int saved_fl;

	if (!isatty(STDIN_FILENO))
		errx(EXIT_FAILURE, _("stdin does not refer to a terminal"));

	tty_raw(&saved_attributes, &saved_fl);
	if (write_all(STDIN_FILENO, getpos, strlen(getpos)) < 0) {
		warn(_("write failed"));
		tty_restore(&saved_attributes, &saved_fl);
		return 1;
	}
	for (pos = 0; pos < sizeof(retstr) - 1;) {
		if (0 == select_wait())
			break;
		if ((rc =
		     read(STDIN_FILENO, retstr + pos,
			  sizeof(retstr) - 1 - pos)) < 0) {
			if (errno == EINTR)
				continue;
			warn(_("read failed"));
			tty_restore(&saved_attributes, &saved_fl);
			return 1;
		}
		pos += rc;
		if (retstr[pos - 1] == 'R')
			break;
	}
	retstr[pos] = 0;
	tty_restore(&saved_attributes, &saved_fl);
	rc = sscanf(retstr, "\033[%d;%dR", &row, &col);
	if (rc != 2) {
		warnx(_("invalid cursor position: %s"), retstr);
		return 1;
	}
	memset(&ws, 0, sizeof(struct winsize));
	ioctl(STDIN_FILENO, TIOCGWINSZ, &ws);
	ws.ws_row = row;
	ws.ws_col = col;
	ioctl(STDIN_FILENO, TIOCSWINSZ, &ws);
	return 0;
}
Example #8
0
/* Called when window is resized. */
static void
sigwinch(int dummy)
{
  UNUSED(dummy);
  tty_restore();
  tty_raw();
  action(NULL);
}
Example #9
0
int
main(int argc, char *argv[])
{
	int			c, remfd, debug;
	char		args[MAXLINE];

	args[0] = 0;	/* build arg list for conn server here */
	opterr = 0;		/* don't want getopt() writing to stderr */
	while ( (c = getopt(argc, argv, "des:o")) != EOF) {
		switch (c) {
		case 'd':		/* debug */
			debug = 1;
			strcat(args, "-d ");
			break;

		case 'e':		/* even parity */
			strcat(args, "-e ");
			break;

		case 'o':		/* odd parity */
			strcat(args, "-o ");
			break;

		case 's':		/* speed */
			strcat(args, "-s ");
			strcat(args, optarg);
			strcat(args, " ");
			break;

		case '?':
			usage("unrecognized option");
		}
	}
	if (optind < argc)
		strcat(args, argv[optind]);	/* name of host to call */
	else
		usage("missing <hostname> to call");

	if ( (remfd = call(args)) < 0)	/* place the call */
		exit(1);	/* call() prints reason for failure */
	printf("Connected\n");

	if (tty_raw(STDIN_FILENO) < 0)	/* user's tty to raw mode */
		err_sys("tty_raw error");
	if (atexit(tty_atexit) < 0)		/* reset user's tty on exit */
		err_sys("atexit error");

	loop(remfd);					/* and do it */

	printf("Disconnected\n\r");
	exit(0);
}
Example #10
0
/*
**	funkey_meta(test_list, status, ch)
**
**	Test meta key (km) (smm) (rmm)
*/
static void
funkey_meta(
	       TestList * t,
	       int *state,
	       int *ch)
{
    if (has_meta_key) {
	int i, j, k, len;
	char outbuf[256];

	put_crlf();
	if (char_mask != ALLOW_PARITY) {
	    if (tty_meta_prep()) {
		ptext("\nHit any key to continue > ");
		(void) wait_here();
		put_crlf();
	    }
	}
	ptext("Begin meta key test. (km) (smm) (rmm)  Hit any key");
	ptext(" with the meta key.  The character will be");
	ptext(" displayed in hex.  If the meta key is working");
	ptext(" then the most significant bit will be set.  Type");
	ptextln(" 'end' to exit.");
	tty_raw(1, ALLOW_PARITY);
	tc_putp(meta_on);

	for (i = j = k = len = 0; i != 'e' || j != 'n' || k != 'd';) {
	    i = j;
	    j = k;
	    k = getchp(ALLOW_PARITY);
	    if (k == EOF) {
		break;
	    }
	    if ((len += 3) >= columns) {
		put_crlf();
		len = 3;
	    }
	    sprintf(outbuf, "%02X ", k);
	    put_str(outbuf);
	    k &= STRIP_PARITY;
	}
	tc_putp(meta_off);
	put_crlf();
	tty_set();
	put_crlf();
    } else {
	ptext("(km) Has-meta-key is not set.  ");
    }
    generic_done_message(t, state, ch);
}
Example #11
0
int
recinput(char *arqinput, char *argv[])
{
int	fdm, c;
pid_t	pid;
struct termios	orig_termios;
struct winsize	size;

   if (! isatty(0) || ! isatty(1))
   {
	msg("stdin and stdout must be a terminal");
	return ERRO;
   }
   input = criarq("", arqinput, "");
   if (input == NULL)
      return ERRO;

   if (tty_save(STDIN_FILENO) == ERRO)
	return ERRO;

   pid = pty_fork2(&fdm, slave_name);

   if (pid < 0)
   {
	return ERRO;
   }
   else 
   if (pid == 0) 
   {		/* child */
	if (execv(argv[0], argv) < 0)
	{
	   msg("can't execv: %s");
	   return ERRO;
	}
    }

   if (tty_raw(STDIN_FILENO) < 0)	/* user's tty to raw mode */
   {
	msg("tty_raw error");
        return ERRO;
   }

   c = loop1(fdm);	/* copies stdin -> ptym, ptym -> stdout */
   waitpid(pid, NULL, 0);
   fclose(input);
   close(fdm); 
   tty_copy(STDIN_FILENO);
   return c;
}
Example #12
0
int main()
{
    /* check that input is from a tty */
    if (! isatty(ttyfd)) fatal("not on a tty");

    /* store current tty settings in orig_termios */
    if (tcgetattr(ttyfd,&orig_termios) < 0) fatal("can't get tty settings");

    /* register the tty reset with the exit handler */
    if (atexit(tty_atexit) != 0) fatal("atexit: can't register tty reset");

    tty_raw();      /* put tty in raw mode */
    screenio();     /* run application code */
    return 0;       /* tty_atexit will restore terminal */
}
Example #13
0
static void *watch_tty(struct watch_tty_data *wtd)
{
	struct tcp_spec ts;
	char buf[256];
	int nr;

	if (wtd->input_mode == INPUT_MODE_RAW)
		tty_raw(0, 1, 0);
	while ((nr = read(0, buf, sizeof(buf)))) {
		if (buf[0] == 29)	/* ^] */
			break;
		if (wtd->input_mode == INPUT_MODE_LINEECHO || 
		    wtd->input_mode == INPUT_MODE_LINEECHOR) {
			if (nr >= 3 && buf[0] == '^' && buf[1] == ']' && 
			    buf[2] == '\n')
				break;
			
			if (wtd->input_mode == INPUT_MODE_LINEECHOR && 
			    nr < sizeof(buf) && buf[nr - 1] == '\n') {
				buf[nr - 1] = '\r';
				buf[nr++] = '\n';
			}
		}
		memset(&ts, 0, sizeof(ts));
		ts.saddr = wtd->ci->src_addr;
		ts.daddr = wtd->ci->dst_addr;
		ts.sport = wtd->ci->src_port;
		ts.dport = wtd->ci->dst_port;
		ts.src_mac = wtd->src_fake_mac;
		ts.dst_mac = wtd->ci->dst.src_mac;
		ts.seq = wtd->ci->dst.next_d_seq;
		ts.ack_seq = wtd->ci->dst.next_seq;
		ts.window = wtd->ci->src.window ? wtd->ci->src.window : htons(242);
		ts.id = htons(ntohs(wtd->ci->src.id) + 1);
		ts.ack = 1;
		ts.psh = 1;
		ts.rst = 0;
		ts.data = buf;
		ts.data_len = nr;
		send_tcp_packet(&ts);
	}
	if (wtd->input_mode == INPUT_MODE_RAW)
		tty_reset(0);
	list_produce_done(&l_hijack_conn);
	return NULL;
}
Example #14
0
int main(int argc, char ** argv){
    int r;
    char c;

    printf("Type [s,n,p,e]: ");
    fflush(stdout);

    if(!isatty(ttyfd)) fatal("not on a tty");
    if(tcgetattr(ttyfd, &orig_termios) < 0) fatal("can't get tty settings");
    if(atexit(tty_reset) != 0) fatal("atexit: can't register tty reset");

    tty_raw();


    if(argc < 2) fatal("Missing fifo file path");

    mplayer_init(argv[1]);


    while(1){
        r = read(0, &c, 1);

        switch(c){
            case 's':
                mplayer_send(MPLAYER_START);
                break;
            case 'p':
                mplayer_send(MPLAYER_PREV);
                break;
            case 'n':
                mplayer_send(MPLAYER_NEXT);
                break;
            case 'e':
                exit(0);
            default:
                printf("Unknown command");
                break;
        }
    }

    return 0;
}
Example #15
0
File: tty.c Project: jnbek/tmux
void
tty_stop_tty(struct tty *tty)
{
    struct winsize	ws;
    int		mode;

    if (!(tty->flags & TTY_STARTED))
        return;
    tty->flags &= ~TTY_STARTED;

    bufferevent_disable(tty->event, EV_READ|EV_WRITE);

    /*
     * Be flexible about error handling and try not kill the server just
     * because the fd is invalid. Things like ssh -t can easily leave us
     * with a dead tty.
     */
    if (ioctl(tty->fd, TIOCGWINSZ, &ws) == -1)
        return;
    if (tcsetattr(tty->fd, TCSANOW, &tty->tio) == -1)
        return;

    tty_raw(tty, tty_term_string2(tty->term, TTYC_CSR, 0, ws.ws_row - 1));
    tty_raw(tty, tty_term_string(tty->term, TTYC_RMACS));
    tty_raw(tty, tty_term_string(tty->term, TTYC_SGR0));
    tty_raw(tty, tty_term_string(tty->term, TTYC_RMKX));
    tty_raw(tty, tty_term_string(tty->term, TTYC_CLEAR));

    tty_raw(tty, tty_term_string(tty->term, TTYC_CNORM));
    if (tty_term_has(tty->term, TTYC_KMOUS))
        tty_raw(tty, "\033[?1000l");

    tty_raw(tty, tty_term_string(tty->term, TTYC_RMCUP));

    if ((mode = fcntl(tty->fd, F_GETFL)) != -1)
        fcntl(tty->fd, F_SETFL, mode & ~O_NONBLOCK);
}
Example #16
0
File: t_raw.c Project: 4get/apue.2e
int
main(void)
{
	int		i;
	char	c;

	if (signal(SIGINT, sig_catch) == SIG_ERR)	/* catch signals */
		err_sys("signal(SIGINT) error");
	if (signal(SIGQUIT, sig_catch) == SIG_ERR)
		err_sys("signal(SIGQUIT) error");
	if (signal(SIGTERM, sig_catch) == SIG_ERR)
		err_sys("signal(SIGTERM) error");

	if (tty_raw(STDIN_FILENO) < 0)
		err_sys("tty_raw error");
	printf("Enter raw mode characters, terminate with DELETE\n");
	while ((i = read(STDIN_FILENO, &c, 1)) == 1) {
		if ((c &= 255) == 0177)		/* 0177 = ASCII DELETE */
			break;
		printf("%o\n", c);
	}
	if (tty_reset(STDIN_FILENO) < 0)
		err_sys("tty_reset error");
	if (i <= 0)
		err_sys("read error");
	if (tty_cbreak(STDIN_FILENO) < 0)
		err_sys("tty_cbreak error");
	printf("\nEnter cbreak mode characters, terminate with SIGINT\n");
	while ((i = read(STDIN_FILENO, &c, 1)) == 1) {
		c &= 255;
		printf("%o\n", c);
	}
	if (tty_reset(STDIN_FILENO) < 0)
		err_sys("tty_reset error");
	if (i <= 0)
		err_sys("read error");

	exit(0);
}
Example #17
0
int main(int argc, char *argv[])
{
	atexit(tty_atexit);
	int		i;
	char	c;
	Signal(SIGINT, sig_catch);
	Signal(SIGQUIT, sig_catch);
	Signal(SIGTERM, sig_catch);

	if(tty_raw(STDIN_FILENO) < 0)
		err_sys("tty_raw error");

	printf("Enter raw mode characters, terminate with DELETE\n");
	while ((i = read(STDIN_FILENO, &c, 1)) == 1)
	{
		if((c &= 255) == 0177)		/* 0177 = ASCII DELETE*/
			break;
		printf("%o\n", c );
	}
	if(tty_reset(STDIN_FILENO) < 0)
		err_sys("tty_reset error");
	if(i <= 0)
		err_sys("read error");
	if(tty_cbreak(STDIN_FILENO) < 0)
		err_sys("tty_raw error");
	printf("\n Enter cbreak mode characters, terminate with SIGINT\n");
	while ( (i = read(STDIN_FILENO, &c, 1)) == 1)
	{
		c &= 255;
		printf("%o\n", c);
	}
	tty_reset(STDIN_FILENO);
	if( i < 0)
		err_sys("read error");;

	return 0;
}
Example #18
0
int
main (void)
{
        char *term = getenv ("TERM");
        int status;

        setupterm (term, 1, &status);
        printf ("has_meta_key: ");
        puts (has_meta_key == TRUE ? "true" : "false");
        printf ("gnu_has_meta_key: ");
        puts (gnu_has_meta_key == TRUE ? "true" : "false");

        tty_raw (STDIN_FILENO);

        puts ("Normal");
        read_char (); new_line ();

        putp (meta_on);  puts ("Meta mode");
        read_char (); new_line ();

        tty_reset (STDIN_FILENO);

        return 0;
}
Example #19
0
/*
**	subtest_xenl(test_list, status, ch)
**
**	(xenl) eat newline glitch
*/
static void
subtest_xenl(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i, j, k;

	if (over_strike) {
		/* test (xenl) on overstrike terminals */
		if (!can_go_home || !can_clear_screen) {
			ptextln("(xenl) Newline-glitch not tested, can't home cursor and clear.");
			generic_done_message(t, state, ch);
			return;
		}
		put_clear();
		/*
		   this test must be done in raw mode.  Otherwise UNIX will
		   translate CR to CRLF.
		*/
		if (stty_query(TTY_OUT_TRANS))
			tty_raw(1, char_mask);
		ptext("\nreset (xenl). Does ");
		i = char_count;
		put_str("not ignore CR, does ");
		k = char_count;
		put_str("not ignore LF");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_cr();
		for (j = 0; j < i; j++)
			putchp(' ');
		put_str("@@@\n@@");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_lf();
		for (j = 0; j < k; j++)
			putchp(' ');
		put_str("@@@\r@@");
		tty_set();
		go_home();
		put_newlines(4);
		sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
			eat_newline_glitch ? "true" : "false");
		ptextln(temp);
	} else {
		/* test (xenl) when (os) is reset */
		if (!can_go_home) {
			ptextln("(xenl) Newline-glitch not tested, can't home cursor");
			generic_done_message(t, state, ch);
			return;
		}
		/* (xenl) test */
		put_clear();
		/*
		   this test must be done in raw mode.  Otherwise
		   UNIX will translate CR to CRLF.
		*/
		if (stty_query(TTY_OUT_TRANS))
			tty_raw(1, char_mask);
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_cr();
		ptext("(xenl) should be set. Does not ignore CR");
		go_home();
		put_crlf();
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_lf();	/* test (cud1) */
		ptext("(xenl) should be set. Ignores (cud1)");
		go_home();
		put_newlines(3);
		if (scroll_forward && cursor_down &&
			strcmp(scroll_forward, cursor_down)) {
			for (j = 0; j < columns; j++)
				put_this(' ');
			put_ind();	/* test (ind) */
			ptext("(xenl) should be set. Ignores (ind)");
			go_home();
			put_newlines(5);
		}
		tty_set();
		ptextln("If you don't see text above telling you to set it, (xenl) should be false");
		sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
			eat_newline_glitch ? "true" : "false");
		ptextln(temp);
	}
	generic_done_message(t, state, ch);
}
Example #20
0
int
main(int argc, char *argv[])
{
	int				fdm, c, ignoreeof, interactive, noecho, verbose;
	pid_t			pid;
	char			*driver, slave_name[20];
	struct termios	orig_termios;
	struct winsize	size;

	interactive = isatty(STDIN_FILENO);
	ignoreeof = 0;
	noecho = 0;
	verbose = 0;
	driver = NULL;

	opterr = 0;		/* don't want getopt() writing to stderr */
	while ( (c = getopt(argc, argv, "d:einv")) != EOF) {
		switch (c) {
		case 'd':		/* driver for stdin/stdout */
			driver = optarg;
			break;

		case 'e':		/* noecho for slave pty's line discipline */
			noecho = 1;
			break;

		case 'i':		/* ignore EOF on standard input */
			ignoreeof = 1;
			break;
		case 'n':		/* not interactive */
			interactive = 0;
			break;

		case 'v':		/* verbose */
			verbose = 1;
			break;

		case '?':
			err_quit("unrecognized option: -%c", optopt);
		}
	}
	if (optind >= argc)
		err_quit("usage: pty [ -d driver -einv ] program [ arg ... ]");

	if (interactive) {	/* fetch current termios and window size */
		if (tcgetattr(STDIN_FILENO, &orig_termios) < 0)
			err_sys("tcgetattr error on stdin");
		if (ioctl(STDIN_FILENO, TIOCGWINSZ, (char *) &size) < 0)
			err_sys("TIOCGWINSZ error");
		pid = pty_fork(&fdm, slave_name, &orig_termios, &size);

	} else
		pid = pty_fork(&fdm, slave_name, NULL, NULL);

	if (pid < 0)
		err_sys("fork error");

	else if (pid == 0) {		/* child */
		if (noecho)
			set_noecho(STDIN_FILENO);	/* stdin is slave pty */

		if (execvp(argv[optind], &argv[optind]) < 0)
			err_sys("can't execute: %s", argv[optind]);
	}

	if (verbose) {
		fprintf(stderr, "slave name = %s\n", slave_name);
		if (driver != NULL)
			fprintf(stderr, "driver = %s\n", driver);
	}

	if (interactive && driver == NULL) {
		if (tty_raw(STDIN_FILENO) < 0)	/* user's tty to raw mode */
			err_sys("tty_raw error");
		if (atexit(tty_atexit) < 0)		/* reset user's tty on exit */
			err_sys("atexit error");
	}

	if (driver)
		do_driver(driver);	/* changes our stdin/stdout */

	loop(fdm, ignoreeof);	/* copies stdin -> ptym, ptym -> stdout */

	exit(0);
}
int main()
{
	int i;
	int c;
	struct sigaction sigact;

	sigact.sa_handler = sig_catch;
	sigact.sa_flags = 0;
	sigemptyset(&sigact.sa_mask);
	if (-1 == sigaction(SIGINT, &sigact, NULL))
	{
		perror("sigaction");
		return -1;
	}
	if (-1 == sigaction(SIGQUIT, &sigact, NULL))
	{
		perror("sigaction");
		return -1;
	}
	if (-1 == sigaction(SIGTERM, &sigact, NULL))
	{
		perror("sigaction");
		return -1;
	}

	if (0 > tty_raw(STDIN_FILENO))
	{
		perror("tty_raw");
		return -1;
	}
	printf("Enter raw mode characters, terminate with DELETE\n");
	while (1 == (i = read(STDIN_FILENO, &c, 1)))
	{
		if ((c &= 255) == 0177)
		{
			break;
		}
		printf("%o\n", c);
	}
	if (0 > tty_reset(STDIN_FILENO))
	{
		perror("tty_reset");
		return -1;
	}
	if (i <= 0)
	{
		fprintf(stderr, "read error\n");
		return -1;
	}
	if (0 > tty_cbreak(STDIN_FILENO))
	{
		perror("tty_cbreak");
		return -1;
	}
	printf("\nEnter cbreak mode characters, terminate with SIGINT\n");
	while (1 == (i = read(STDIN_FILENO, &c, 1)))
	{
		c &= 255;
		printf("%o\n", c);
	}
	if (0 > tty_reset(STDIN_FILENO))
	{
		perror("tty_reset");
		return -1;
	}
	if (0 >= i)
	{
		fprintf(stderr, "read error\n");
	}
	exit(0);
}
Example #22
0
int main(void)
{
	if (tty_raw(STDIN_FILENO) < 0)
		err_sys("tty_raw() error");
	exit(0);
}
Example #23
0
void
tty_stop_tty(struct tty *tty)
{
	struct winsize	ws;

	if (!(tty->flags & TTY_STARTED))
		return;
	tty->flags &= ~TTY_STARTED;

	bufferevent_disable(tty->event, EV_READ|EV_WRITE);

	/*
	 * Be flexible about error handling and try not kill the server just
	 * because the fd is invalid. Things like ssh -t can easily leave us
	 * with a dead tty.
	 */
	if (ioctl(tty->fd, TIOCGWINSZ, &ws) == -1)
		return;
	if (tcsetattr(tty->fd, TCSANOW, &tty->tio) == -1)
		return;

	setblocking(tty->fd, 1);

	tty_raw(tty, tty_term_string2(tty->term, TTYC_CSR, 0, ws.ws_row - 1));
	if (tty_use_acs(tty))
		tty_raw(tty, tty_term_string(tty->term, TTYC_RMACS));
	tty_raw(tty, tty_term_string(tty->term, TTYC_SGR0));
	tty_raw(tty, tty_term_string(tty->term, TTYC_RMKX));
	tty_raw(tty, tty_term_string(tty->term, TTYC_CLEAR));
	if (tty_term_has(tty->term, TTYC_CS1) && tty->cstyle != 0) {
		if (tty_term_has(tty->term, TTYC_CSR1))
			tty_raw(tty, tty_term_string(tty->term, TTYC_CSR1));
		else
			tty_raw(tty, tty_term_string1(tty->term, TTYC_CS1, 0));
	}
	tty_raw(tty, tty_term_string(tty->term, TTYC_CR));

	tty_raw(tty, tty_term_string(tty->term, TTYC_CNORM));
	if (tty_term_has(tty->term, TTYC_KMOUS))
		tty_raw(tty, "\033[?1000l");

	tty_raw(tty, tty_term_string(tty->term, TTYC_RMCUP));
}
Example #24
0
int
main(int argc, char *argv[])
{    
  int  c, nostop=0;
  char *h;
  int  i_rc = 0;
  cd_operation_t cd_op = NO_OP; /* operation to do in non-interactive mode */
  
  
  psz_program = strrchr(argv[0],'/');
  psz_program = psz_program ? psz_program+1 : argv[0];

  memset(&cddb_opts, 0, sizeof(cddb_opts));
  
  cdio_loglevel_default = CDIO_LOG_WARN;
  /* parse options */
  while ( 1 ) {
    if (-1 == (c = getopt(argc, argv, "acCdehkplL:sSt:vx")))
      break;
    switch (c) {
    case 'v':
      b_verbose = true;
      if (cdio_loglevel_default > CDIO_LOG_INFO) 
        cdio_loglevel_default = CDIO_LOG_INFO;
      break;
    case 'd':
      debug = 1;
      if (cdio_loglevel_default > CDIO_LOG_DEBUG) 
      cdio_loglevel_default = CDIO_LOG_DEBUG;
      break;
    case 'a':
      auto_mode = 1;
      break;

    case 'L':
      i_volume_level = atoi(optarg);
      cd_op = SET_VOLUME;
      b_interactive = false;
      break;

    case 't':
      if (NULL != (h = strchr(optarg,'-'))) {
        *h = 0;
        start_track = atoi(optarg);
        stop_track = atoi(h+1)+1;
        if (0 == start_track) start_track = 1;
        if (1 == stop_track)  stop_track  = CDIO_CDROM_LEADOUT_TRACK;
      } else {
        start_track = atoi(optarg);
        stop_track = start_track+1;
        one_track = 1;
      }
      b_interactive = false;
      cd_op = PLAY_TRACK;
      break;
    case 'p':
      b_interactive = false;
      cd_op = PLAY_CD;
      break;
    case 'l':
      b_interactive = false;
      cd_op = LIST_TRACKS;
      break;
    case 'C':
      b_interactive = false;
      cd_op = CLOSE_CD;
      break;
    case 'c':
      b_interactive = false;
      cd_op = PS_LIST_TRACKS;
      break;
    case 's':
      b_interactive = false;
      cd_op = STOP_PLAYING;
      break;
    case 'S':
      b_interactive = false;
      cd_op = LIST_SUBCHANNEL;
      break;
    case 'e':
      b_interactive = false;
      cd_op = EJECT_CD;
      break;
    case 'k':
      print_keys();
      exit(1);
    case 'h':
      usage(psz_program);
      exit(1);
    default:
      usage(psz_program);
      exit(1);
    }
  }
  
  if (argc > optind) {
    psz_device = strdup(argv[optind]);
  } else {
    char **ppsz_cdda_drives=NULL;
    char **ppsz_all_cd_drives = cdio_get_devices_ret(&driver_id);

    if (!ppsz_all_cd_drives) {
      fprintf(stderr, "Can't find a CD-ROM drive\n");
      exit(2);
    }
    ppsz_cdda_drives = cdio_get_devices_with_cap(ppsz_all_cd_drives, 
                                                 CDIO_FS_AUDIO, false);
    if (!ppsz_cdda_drives || !ppsz_cdda_drives[0]) {
      fprintf(stderr, "Can't find a CD-ROM drive with a CD-DA in it\n");
      exit(3);
    }
    psz_device = strdup(ppsz_cdda_drives[0]);
    cdio_free_device_list(ppsz_all_cd_drives);
    cdio_free_device_list(ppsz_cdda_drives);
  }
  
  if (!b_interactive) {
    b_sig = true;
    nostop=1;
  }

  tty_raw();
  signal(SIGINT,ctrlc);
  signal(SIGQUIT,ctrlc);
  signal(SIGTERM,ctrlc);
  signal(SIGHUP,ctrlc);
  signal(SIGWINCH, sigwinch);

  if (CLOSE_CD != cd_op) {
    /* open device */
    if (b_verbose)
      fprintf(stderr, "open %s... ", psz_device);
    p_cdio = cdio_open (psz_device, driver_id);
    if (!p_cdio && cd_op != EJECT_CD) {
      cd_close(psz_device);
      p_cdio = cdio_open (psz_device, driver_id);
    }
    
    if (p_cdio && b_verbose)
      fprintf(stderr,"ok\n");
  }
  
  if (b_interactive) {
#ifdef HAVE_CDDB
    cddb_log_set_handler (cddb_log_handler);
#else
    ;
#endif
  }  else {
    b_sig = true;
    nostop=1;
    if (EJECT_CD == cd_op) {
      i_rc = cd_eject() ? 0 : 1;
    } else {
      switch (cd_op) {
      case PS_LIST_TRACKS:
      case LIST_TRACKS:
      case PLAY_TRACK:
        read_toc(p_cdio);
      default:
        break;
      }
      if (p_cdio)
        switch (cd_op) {
        case STOP_PLAYING:
          b_cd = true;
          i_rc = cd_stop(p_cdio) ? 0 : 1;
          break;
        case EJECT_CD:
          /* Should have been handled above. */
          cd_eject();
          break;
        case LIST_TRACKS:
          list_tracks();
          break;
        case PS_LIST_TRACKS:
          ps_list_tracks();
          break;

        case PLAY_TRACK:
          /* play just this one track */
          if (b_record) {
            printf("%s / %s\n", artist, title);
            if (one_track)
              printf("%s\n", cd_info[start_track].title);
          }
          i_rc = play_track(start_track, stop_track) ? 0 : 1;
          break;

        case PLAY_CD:
          if (b_record)
            printf("%s / %s\n", artist, title);
          play_track(1,CDIO_CDROM_LEADOUT_TRACK);
          break;

        case SET_VOLUME:
          i_rc = set_volume_level(p_cdio, i_volume_level);
          break;

        case LIST_SUBCHANNEL: 
          if (read_subchannel(p_cdio)) {
            if (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
                sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY) {
              {
                printf("track %2d - %02x:%02x (%02x:%02x abs) ",
                       sub.track, sub.rel_addr.m, sub.rel_addr.s,
                       sub.abs_addr.m, sub.abs_addr.s);
              }
            }
            printf("drive state: %s\n", 
                   mmc_audio_state2str(sub.audio_status));
          } else {
            i_rc = 1;
          }
          break;
        case CLOSE_CD: /* Handled below */
        case LIST_KEYS:
        case TOGGLE_PAUSE:
        case EXIT_PROGRAM:
        case NO_OP:
          break;
        }
      else if (CLOSE_CD == cd_op) {
        i_rc = (DRIVER_OP_SUCCESS == cdio_close_tray(psz_device, NULL))
                ? 0 : 1;
      } else {
        fprintf(stderr,"no CD in drive (%s)\n", psz_device);
      }
    }
  }

  /* Play all tracks *unless* we have a play or paused status
     already. */

  read_subchannel(p_cdio);
  if (sub.audio_status != CDIO_MMC_READ_SUB_ST_PAUSED &&
      sub.audio_status != CDIO_MMC_READ_SUB_ST_PLAY)
    play_track(1, CDIO_CDROM_LEADOUT_TRACK);

  while ( !b_sig ) {
    int key;
    if (!b_cd) read_toc(p_cdio);
    read_subchannel(p_cdio);
    display_status(false);
    
    if (1 == select_wait(b_cd ? 1 : 5)) {
      switch (key = getch()) {
      case '-':
        decrease_volume_level(p_cdio);
        break;
      case '+':
        increase_volume_level(p_cdio);
        break;
      case 'A':
      case 'a':
        auto_mode = !auto_mode;
        break;
      case 'X':
      case 'x':
        nostop=1;
        /* fall through */
      case 'Q':
      case 'q':
        b_sig = true;
        break;
      case 'E':
      case 'e':
        cd_eject();
        break;
      case 's':
        cd_stop(p_cdio);
        break;
      case 'C':
      case 'c':
        cd_close(psz_device);
        break;
      case 'L':
      case 'l':
        b_all_tracks = !b_all_tracks;
        if (b_all_tracks)
          display_tracks();
        else {
          i_last_display_track = CDIO_INVALID_TRACK;
          display_cdinfo(p_cdio, i_tracks, i_first_track);
        }
        
        break;
      case 'K':
      case 'k':
      case 'h':
      case 'H':
      case '?':
        list_keys();
        break;
      case ' ':
      case 'P':
      case 'p':
        toggle_pause();
        break;
      case KEY_RIGHT:
        if (b_cd &&
            (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
             sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)) 
          play_track(sub.track+1, CDIO_CDROM_LEADOUT_TRACK);
        else
          play_track(1,CDIO_CDROM_LEADOUT_TRACK);
        break;
      case KEY_LEFT:
        if (b_cd &&
            (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
             sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
          play_track(sub.track-1,CDIO_CDROM_LEADOUT_TRACK);
        break;
      case KEY_UP:
        if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
          skip(10);
        break;
      case KEY_DOWN:
        if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
          skip(-10);
        break;
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
        play_track(key - '0', CDIO_CDROM_LEADOUT_TRACK);
        break;
      case '0':
        play_track(10, CDIO_CDROM_LEADOUT_TRACK);
        break;
      case KEY_F(1):
      case KEY_F(2):
      case KEY_F(3):
      case KEY_F(4):
      case KEY_F(5):
      case KEY_F(6):
      case KEY_F(7):
      case KEY_F(8):
      case KEY_F(9):
      case KEY_F(10):
      case KEY_F(11):
      case KEY_F(12):
      case KEY_F(13):
      case KEY_F(14):
      case KEY_F(15):
      case KEY_F(16):
      case KEY_F(17):
      case KEY_F(18):
      case KEY_F(19):
      case KEY_F(20):
        play_track(key - KEY_F(1) + 11, CDIO_CDROM_LEADOUT_TRACK);
        break;
      }
    }
  }
  if (!nostop) cd_stop(p_cdio);
  tty_restore();
  finish("bye", i_rc);
  
  return 0; /* keep compiler happy */
}
Example #25
0
static int
found_exit(char *keybuf, int hx, int cc)
{				/* return true if the user wants to exit */
    int j;
    char *s;

    if (scan_mode) {
	if (*keybuf == '\0') {
	    return TRUE;
	}
    } else {
	int k;

	/* break is a special case */
	if (*keybuf == '\0') {
	    fresh_line();
	    tty_set();
	    ptext("Hit X to exit: ");
	    if (wait_here() == 'X') {
		return TRUE;
	    }
	    keys_tested(0, 1, hx);
	    tty_raw(cc, char_mask);
	    return FALSE;
	}
	/* is this the end? */
	for (k = 0; (j = (keybuf[k] & STRIP_PARITY)); k++) {
	    if (end_funky(j)) {
		return TRUE;
	    }
	}

	j = TRUE;		/* does he need an updated list? */
	for (k = 0; keybuf[k]; k++) {
	    j &= (keybuf[k] & STRIP_PARITY) == '?';
	}
	if (j || end_state == '?') {
	    keys_tested(0, 1, hx);
	    tty_raw(cc, char_mask);
	    end_state = 0;
	    return FALSE;
	}
    }

    put_cr();
    if (hx) {
	s = hex_expand_to(keybuf, 10);
    } else {
	s = expand_to(keybuf, 10);
    }
    sprintf(temp, "%s Unknown", s);
    put_str(temp);
    for (j = 0; j < MAX_FK_UNK; j++) {
	if (j == funk) {
	    fk_length[funk] = expand_chars;
	    if ((fk_unknown[funk] = (char *) malloc(strlen(s) + 1))) {
		strcpy(fk_unknown[funk++], s);
	    }
	    break;
	}
	if (fk_length[j] == expand_chars) {
	    if (!strcmp(fk_unknown[j], s)) {
		break;
	    }
	}
    }
    return FALSE;
}
Example #26
0
static int
found_match(char *s, int hx, int cc)
{				/* return true if this string is a match */
    int j, f;

    alloc_strings();
    if (!*s) {
	return 0;
    }
    if (scan_mode) {
	for (j = f = 0; scan_down[j]; j++) {
	    if (scan_length[j] == 0) {
		continue;
	    }
	    if (!strncmp(s, scan_down[j], scan_length[j])) {
		if (!f) {	/* first match */
		    put_cr();
		    if (hx) {
			put_str(hex_expand_to(s, 10));
		    } else {
			put_str(expand_to(s, 10));
		    }
		    f = 1;
		}
		(void) end_funky(scan_name[j][0]);
		put_str(" ");
		put_str(scan_name[j]);
		scan_tested[j] = 1;
		s += scan_length[j];
		if (strncmp(s, scan_up[j], scan_length[j])) {
		    put_str(" scan down");
		} else {
		    s += scan_length[j];
		}
		if (!*s) {
		    break;
		}
		j = -1;
	    }
	    if (!strncmp(s, scan_up[j], scan_length[j])) {
		if (!f) {	/* first match */
		    put_cr();
		    if (hx) {
			put_str(hex_expand_to(s, 10));
		    } else {
			put_str(expand_to(s, 10));
		    }
		    f = 1;
		}
		put_str(" ");
		put_str(scan_name[j]);
		put_str(" scan up");
		s += scan_length[j];
		if (!*s) {
		    break;
		}
		j = -1;
	    }
	}
    } else {
	for (j = f = 0; j < key_count; j++) {
	    if (fkval[j] && !strcmp(s, fkval[j])) {
		char outbuf[256];

		if (!f) {	/* first match */
		    put_cr();
		    if (hx) {
			put_str(hex_expand_to(s, 10));
		    } else {
			put_str(expand_to(s, 10));
		    }
		    f = 1;
		}
		sprintf(outbuf, " (%s)", fk_name[j]);
		put_str(outbuf);
		if (fk_label[j]) {
		    sprintf(outbuf, " <%s>", fk_label[j]);
		    put_str(outbuf);
		}
		fk_tested[j] = 1;
	    }
	}
    }
    if (end_state == '?') {
	keys_tested(0, 1, hx);
	tty_raw(cc, char_mask);
	end_state = 0;
    }
    return f;
}
Example #27
0
int main (int argc, char **argv)
{
	int master_fd;
	int c;
	int ignore_eof;
	int interactive;
	int quiet;
	int err_flag;
	pid_t pid;
	char *driver;
	struct termios old_termios;
	struct winsize tty_winsize;

	ignore_eof = 0;
	interactive = isatty (STDIN_FILENO);
	quiet = 0;
	driver = NULL;
	err_flag = 0;
	opterr = 0;

	while ((c = getopt (argc, argv, "d:eiq")) != EOF) {
		switch (c) {
			case 'd':
				driver = optarg;
				break;

			case 'e':
				ignore_eof++;
				break;

			case 'i':
				interactive = 0;
				break;

			case 'q':
				quiet++;
				break;

			default:
				err_flag++;
				break;
		}
	}

	if ((err_flag) || (optind >= argc))
		err_quit ("Usage: pty [-d driver] [eiq] command [arg ...]");

	if (interactive) {
		if (tcgetattr (STDIN_FILENO, &old_termios) == -1)
			err_msg ("tcgetattr failed");

		if (ioctl (STDIN_FILENO, TIOCGWINSZ, &tty_winsize) == -1)
			err_msg ("TIOCGWINSZ failed");

		pid = pty_fork (&master_fd, &old_termios, &tty_winsize);
	}
	else
		pid = pty_fork (&master_fd, NULL, NULL);

	if (pid == -1)
		err_msg ("pty_fork failed");

	if (pid == 0) {
		if (quiet)
			disable_echo (STDIN_FILENO);

		if (execvp (argv [optind], &argv [optind]) == -1)
			err_msg ("pty: %s", argv [optind]);
	}

	if ((interactive) && (driver == NULL)) {
		if (tty_raw (STDIN_FILENO) == -1)
			err_msg ("tty_raw failed");
		if (atexit (tty_atexit) == -1)
			err_msg ("tty_atexit failed");
	}

	if (driver)
		run_driver (driver);

	loop (master_fd, ignore_eof);

	return (0);
}
Example #28
0
int main(int argc, char* argv[])
{
	int fdm, c, ignoreeof, interactive, noecho, verbose;
	pid_t pid;
	char* config;
	char slave_name[20];
	struct termios orig_termios;
	struct winsize size;
	int flags;

	interactive = isatty(STDIN_FILENO);
	ignoreeof = 0;
	noecho = 0;
	verbose = 0;
	config = NULL;

	while ((c = getopt_long(argc, argv, "hVs:einv", long_options, NULL))
	       != EOF) {
		switch (c) {
		case 'h':
			printf("Usage: %s [options] config_file -- program [args ...]\n", argv[0]);
			printf("\t -h --help \t\tdisplay usage summary\n");
			printf("\t -V --version \t\tdisplay version\n");
			printf("\t -e --no-echo \t\tdisable echo\n");
			printf("\t -i --ignore-eof \tignore EOF\n");
			printf("\t -n --non-interactive \tforce non-interactive mode\n");
			printf("\t -v --verbose \t\tverbose mode\n");
			return EXIT_SUCCESS;
		case 'V':
			printf("irpty %s\n", VERSION);
			return EXIT_SUCCESS;

		case 'e':
			noecho = 1;
			break;

		case 'i':
			ignoreeof = 1;
			break;

		case 'n':
			interactive = 0;
			break;

		case 'v':
			verbose = 1;
			break;

		case '?':
			die("unrecognized option: -%c\n", optopt);
		}
	}
	if (optind + 1 >= argc)
		die("usage: irpty [ -s server -einv ] cfg program [ arg ... ]\n");

	config = argv[optind++];

	if ((lsock = lirc_init("irpty", 1)) == -1)
		exit(EXIT_FAILURE);
	flags = fcntl(lsock, F_GETFL, 0);
	if (flags != -1)
		fcntl(lsock, F_SETFL, flags | FASYNC | O_NONBLOCK);

	if (lirc_readconfig(config, &lconfig, NULL) != 0)
		exit(EXIT_FAILURE);

	if (interactive) {
		if (tcgetattr(STDIN_FILENO, &orig_termios) < 0)
			die("tcgetattr error on stdin\n");
		if (ioctl(STDIN_FILENO, TIOCGWINSZ, (char*)&size) < 0)
			die("TIOCGWINSZ error\n");
		pid = pty_fork(&fdm, slave_name, &orig_termios, &size);
	} else {
		pid = pty_fork(&fdm, slave_name, NULL, NULL);
	}

	if (pid < 0) {
		die("fork error\n");
	} else if (!pid) {                              /* child */
		if (noecho)
			set_noecho(STDIN_FILENO);       /* stdin is slave pty */
		if (execvp(argv[optind], &argv[optind]) < 0)
			die("can't execute: %s\n", argv[optind]);
	}
	if (verbose) {
		fprintf(stderr, "slave name = %s\n", slave_name);
		if (config)
			fprintf(stderr, "config file = %s\n", config);
	}
	if (interactive) {
		if (tty_raw(STDIN_FILENO) < 0)  /* user's tty to raw mode */
			die("tty_raw error");
		if (atexit(tty_atexit) < 0)     /* reset user's tty on exit */
			die("atexit error");
	}
	copy_loop(fdm, ignoreeof);

	exit(0);
}
Example #29
0
int main() {
    tty_raw(STDIN_FILENO);
    return EXIT_SUCCESS;
}