Beispiel #1
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;
}
Beispiel #2
0
/* Called when window is resized. */
static void 
sigwinch()
{
  tty_restore();
  tty_raw();
  action(NULL);
}
/* Called when window is resized. */
static void
sigwinch(int dummy)
{
  UNUSED(dummy);
  tty_restore();
  tty_raw();
  action(NULL);
}
/* Close down a terminal line. */
static int tty_close(void)
{
	/*
	 * Set the old discipline and restore the
	 * previous line mode.
	 */
	(void) tty_set_ldisc(ldisc_before);
	(void) tty_restore();
	(void) tty_lock(NULL, 0);

	return 0;
}
Beispiel #5
0
static int tty_esc_type_esc(tty_t t, char c, int pos)
{
	switch(c)
	{
		case '[': /* CSI START */
			t->escape_type = ESC_TYPE_CSI;
			cprintf("Started CSI sequence");
			return ESC_RES_CNT;
		case '(': /* Define G0 character set */
		case ')': /* Define G1 character set */
		case ']': /* OS command (change colors) */
			return ESC_RES_CNT;
		case 'D': /* Line feed */
		case 'E': /* New line */
			tty_new_line(t);
			return ESC_RES_DNE;

		case 'H': /* Set tab stop at curr pos */
			cprintf("Old tab stop: %d", t->tab_stop);
			t->tab_stop = t->cursor_pos % CONSOLE_COLS;
			cprintf("New tab stop: %d", t->tab_stop);
			return ESC_RES_DNE;
		case '7': /* Save tty state */
			tty_save(t);
			return ESC_RES_DNE;
		case '8': /* restore tty state */
			tty_restore(t);
			return ESC_RES_DNE;
		case 'Z': /* Identify self */
			tty_handle_raw(0x1B, t);
			tty_handle_raw('/', t);
			tty_handle_raw('Z', t);
			return ESC_RES_DNE;
			/* Unimplemented escape sequences */
		case '#': /* Possible alignment test */

		case 'c': /* Reset the terminal properties */


		case 'M': /* Reverse line feed */

		case '>': /* Set numeric keyboard mode */

		case '=': /* Set application keyboard mode */

		default:
			/* Unhandled */
			return ESC_RES_ERR;
	}
}
Beispiel #6
0
static void 
finish(const char *psz_msg, int rc)
{
  if (b_interactive) {
    attron(A_STANDOUT);
    mvprintw(LINE_ACTION, 0, (char *) "%s, exiting...\n", psz_msg);
    attroff(A_STANDOUT);
    clrtoeol();
    refresh();
  }
  tty_restore();
#ifdef HAVE_CDDB
  if (p_conn) cddb_destroy(p_conn);
  cddb_disc_destroy(p_cddb_disc);
  libcddb_shutdown();
#endif /*HAVE_CDDB*/
  cdio_destroy (p_cdio);
  free (psz_device);
  exit (rc);
}
Beispiel #7
0
int tty_init(struct lt_config_app *cfg, int master)
{
	int i, slave, num_files = getdtablesize();
	char *sname;
	jmp_buf env;

	if (setjmp(env)) {
		tty_restore(cfg);
		return -1;
	}

	sname = (char*) ptsname(master);
	if (!sname)
		longjmp(env, 1);

	PRINT_VERBOSE(cfg, 1, "closing all opened descriptors\n");
	for(i = 0; i < num_files; i++)
		close(i);

	/* get new session before we open new controling tty */
	if (-1 == setsid()) {
		perror("setsid failed");
		return -1;
	}

	slave = open(sname, O_RDWR);
	if (slave != 0)
		longjmp(env, 1);

	/* set controling tty */
	if (ioctl(0, TIOCSCTTY, 1))
		longjmp(env, 1);

	if (setup_slave(0))
		longjmp(env, 1);

	dup(0);
	dup(0);
	return 0;
}
Beispiel #8
0
static void sigpipe(int s)
{
    tty_restore();
    fprintf(stderr, "Broken pipe.  Disk full?\n");
    exit(0);
}
Beispiel #9
0
/*------------------------------------------------------------------------------
	main()
		Main
	Preconditions:
	Postconditions:
 *----------------------------------------------------------------------------*/
int  main(
	int argc,
	char **argv )
/*----------------------------------------------------------------------------*/
{
	int user_input;
	char user_str[128];

	ws_init();
	tty_init();
	// rmcpd_init_listener();

	printf("\nIPMI Exerciser -- %s\n", __DATE__); // say Hi

	process_command_line( argc, argv ); // process command line arguments
	// Get user keyboard input
	while( 1 )
	{
		main_menu();
		scanf( "%d", &user_input );
		fflush( stdin );

		switch ( user_input )
		{
			case KBD_APP_CMDS:
				kbd_app_cmds();
				break;
			case KBD_CHASSIS_CMDS:
				break;
			case KBD_EVENT_CMDS:
				break;
			case KBD_FIRMWARE_COMMANDS:
				break;
			case KBD_NVSTORE_CMDS:
				break;
			case KBD_MEDIA_SPECIFIC_CMDS:
				break;
			case KBD_PICMG_CMDS:
				kbd_atca_cmds();
				break;
			case KBD_RUN_UNIX:
				printf( "Enter command : " );
				scanf( "%s", user_str );
				//gets( user_str );
				fflush( stdin );
				if( system( user_str ) == -1 )
					printf( "\nError in command\n" );
				printf( "\n Press any key to continue\n" );
				getchar();
				fflush( stdin );
				break;
			case KBD_SETTINGS:
				kbd_settings();
				break;
			case KBD_QUIT:
				tty_restore();
				exit( EXIT_SUCCESS );
				break;
			default:
				printf( "Unknown option %d ignored.\n", user_input );
				break;
		} // end switch
		printf( "Press any key to continue\n" );
		getchar();
		fflush( stdin );

	}
}
Beispiel #10
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 */
}
Beispiel #11
0
int main(int argc, char *argv[])
{
	int ret;
	const char *cid;
	char cmd[CMD_SIZE];
	GError *err = NULL;
	_cleanup_free_ char *contents;
	int cpid = -1;
	int status;
	pid_t pid;
	_cleanup_close_ int mfd = -1;
	_cleanup_close_ int epfd = -1;
	char slname[BUF_SIZE];
	char buf[BUF_SIZE];
	int num_read;
	struct termios t;
	struct epoll_event ev;
	struct epoll_event evlist[MAX_EVENTS];

	if (argc < 2) {
		nexit("Run as: conmon <id>");
	}

	/* Get the container id */
	cid = argv[1];

	/*
	 * Set self as subreaper so we can wait for container process
	 * and return its exit code.
	 */
	ret = prctl(PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0);
	if (ret != 0) {
		pexit("Failed to set as subreaper");
	}

	/* Open the master pty */
	mfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
	if (mfd < 0)
		pexit("Failed to open console master pty");

	/* Grant access to the slave pty */
	if (grantpt(mfd) == -1)
		pexit("Failed to grant access to slave pty");

	/* Unlock the slave pty */
	if (unlockpt(mfd) == -1) {             /* Unlock slave pty */
		pexit("Failed to unlock the slave pty");
	}

	/* Get the slave pty name */
	ret = ptsname_r(mfd, slname, BUF_SIZE);
	if (ret != 0) {
		pexit("Failed to get the slave pty name");
	}

	/* Create the container */
	snprintf(cmd, CMD_SIZE, "runc create %s --pid-file pidfile --console %s", cid, slname);
	ret = system(cmd);
	if (ret != 0) {
		nexit("Failed to create container");
	}

	/* Read the pid so we can wait for the process to exit */
	g_file_get_contents("pidfile", &contents, NULL, &err);
	if (err) {
		fprintf(stderr, "Failed to read pidfile: %s\n", err->message);
		g_error_free(err);
		exit(1);
	}

	cpid = atoi(contents);
	printf("container PID: %d\n", cpid);

	/* Save exiting termios settings */
	if (tcgetattr(STDIN_FILENO, &tty_orig) == -1)
		pexit("tcegetattr");

	/* Settings for raw mode */
	t.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL | IEXTEN);
	t.c_iflag &= ~(BRKINT | ICRNL | IGNBRK | IGNCR | INLCR | INPCK |
		       ISTRIP | IXON | IXOFF | IGNPAR | PARMRK);
	t.c_oflag &= ~OPOST;
	t.c_cc[VMIN] = 1;
	t.c_cc[VTIME] = 0;

	/* Set terminal to raw mode */
	if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t) == -1)
		pexit("tcsetattr");

	/* Setup terminal restore on exit */
	if (atexit(tty_restore) != 0)
		pexit("atexit");

	epfd = epoll_create(5);
	if (epfd < 0)
		pexit("epoll_create");
	ev.events = EPOLLIN;
	ev.data.fd = STDIN_FILENO;
	if (epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) < 0) {
		pexit("Failed to add stdin to epoll");
	}
	ev.data.fd = mfd;
	if (epoll_ctl(epfd, EPOLL_CTL_ADD, mfd, &ev) < 0) {
		pexit("Failed to add console master fd to epoll");
	}

	/* Copy data back and forth between STDIN and master fd */
	while (true) {
		int ready = epoll_wait(epfd, evlist, MAX_EVENTS, -1);
		for (int i = 0; i < ready; i++) {
			if (evlist[i].events & EPOLLIN) {
				if (evlist[i].data.fd == STDIN_FILENO) {
					num_read = read(STDIN_FILENO, buf, BUF_SIZE);
					if (num_read <= 0)
						goto out;

					if (write(mfd, buf, num_read) != num_read) {
						nwarn("partial/failed write (masterFd)");
						goto out;
					}
				} else if (evlist[i].data.fd == mfd) {
					num_read = read(mfd, buf, BUF_SIZE);
					if (num_read <= 0)
						goto out;

					if (write(STDOUT_FILENO, buf, num_read) != num_read) {
						nwarn("partial/failed write (STDOUT_FILENO)");
						goto out;
					}
				}
			} else if (evlist[i].events & (EPOLLHUP | EPOLLERR)) {
				printf("closing fd %d\n", evlist[i].data.fd);
				if (close(evlist[i].data.fd) < 0)
					pexit("close");
				goto out;
			}
		}
	}
out:
	tty_restore();

	/* Wait for the container process and record its exit code */
	while ((pid = waitpid(-1, &status, 0)) > 0) {
		printf("PID %d exited\n", pid);
		if (pid == cpid) {
			_cleanup_free_ char *status_str = NULL;
			ret = asprintf(&status_str, "%d", status);
			if (ret < 0) {
				pexit("Failed to allocate memory for status");
			}
			g_file_set_contents("exit", status_str, strlen(status_str), &err);
			if (err) {
				fprintf(stderr, "Failed to write %s to exit file: %s\n", status_str, err->message);
				g_error_free(err);
				exit(1);
			}
			break;
		}
	}

	return EXIT_SUCCESS;
}
Beispiel #12
0
int
main(int argc, char *argv[])
{
    char *p;
    char *host = 0, *term = 0;
    int port = LIRCD_UDP_PORT;
    int foreground = 0;
    int wait_term = 0;
    int tcp = 0;
    int speed = B38400;
    int tty;
    int c;

    prog = argv[0];
    p = strrchr(argv[0], '/');
    if (p) prog = p + 1;

    while ((c = getopt(argc, argv, "HdDTfw:t:h:p:")) != EOF) {
	switch (c) {
	case 'H':
	    speed = B115200;
	    break;
	case 'd':
	    debug = DEBUG_AND_CONNECT;
	    break;
	case 'D':
	    debug = DEBUG_ONLY;
	    break;
	case 'f':
	    foreground = 1;
	    break;
	case 't':
	    term = optarg;
	    break;
	case 'w':
	    wait_term = atoi(optarg);
	    if (wait_term == 0)
		usage();
	    break;
	case 'h':
	    host = optarg;
	    break;
	case 'T':
	    tcp = 1;
	    break;
	case 'p':   /*	or microseconds */
	    port = atoi(optarg);
	    break;
	default:
	    usage();
	    break;
	}
    }

    if ((debug != DEBUG_ONLY && !host) || !term || optind != argc) {
	usage();
    }

    while (1) {

	tty = tty_init(term, wait_term, speed);

	if (!daemonized && !foreground && !debug) {
	    if (daemon(0, 0) < 0)
		die("daemon");
	    daemonized = 1;
	}

	data_loop(tty, tcp, host, port);

	/* we'll only ever return from data_loop() if our read()
	 * returns 0, which usually means our (USB-based) tty has
	 * gone away.  loop if we were told to wait (-w) for it.
	 */
	if (!wait_term)
	    die("end-of-dataloop");

	tty_restore();
	close(tty);
    }

    return 0;
}
Beispiel #13
0
void
sighandler(int sig)
{
    tty_restore();
    die("signal");
}