1
0
mirror of https://github.com/UzixLS/picocom.git synced 2025-07-19 07:21:18 +03:00
Files
picocom/picocom.c
Nick Patavalis ee23af0cb9 Disable custom baudrate support at runtime (Linux)
If picocom is compiled *with* custom-baudrate support (USE_CUSTOM_BAUD)
for Linux, then it uses a new set of ioctl's (TCGETS2 vs TCGETS, etc) to
access the serial ports. This patch allows the custom baudrate support
to be disabled at runtime (without recompiling), and picocom to switch
to using the old ioctl's.

To disable custom baudrate support (and switch back to the "old" ioctls)
simply define the environment variable NO_CUSTOM_BAUD, before starting
picocom.

This applies only to Linux and, obviously, only when picocom has been
compiled with custom baudrate support (USE_CUSTOM_BAUD).
2018-02-20 10:29:45 +02:00

2206 lines
60 KiB
C

/* vi: set sw=4 ts=4:
*
* picocom.c
*
* simple dumb-terminal program. Helps you manually configure and test
* stuff like modems, devices w. serial ports, etc.
*
* by Nick Patavalis (npat@efault.net)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
* USA
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <assert.h>
#include <stdarg.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <limits.h>
#ifdef USE_FLOCK
#include <sys/file.h>
#endif
#ifdef LINENOISE
#include <dirent.h>
#include <libgen.h>
#endif
#define _GNU_SOURCE
#include <getopt.h>
#include "fdio.h"
#include "split.h"
#include "term.h"
#ifdef LINENOISE
#include "linenoise-1.0/linenoise.h"
#endif
#include "custbaud.h"
/**********************************************************************/
/* parity modes names */
const char *parity_str[] = {
[P_NONE] = "none",
[P_EVEN] = "even",
[P_ODD] = "odd",
[P_MARK] = "mark",
[P_SPACE] = "space",
[P_ERROR] = "invalid parity mode",
};
/* flow control modes names */
const char *flow_str[] = {
[FC_NONE] = "none",
[FC_RTSCTS] = "RTS/CTS",
[FC_XONXOFF] = "xon/xoff",
[FC_OTHER] = "other",
[FC_ERROR] = "invalid flow control mode",
};
/**********************************************************************/
/* control-key to printable character (lowcase) */
#define KEYC(k) ((k) | 0x60)
/* printable character to control-key */
#define CKEY(c) ((c) & 0x1f)
#define KEY_EXIT CKEY('x') /* exit picocom */
#define KEY_QUIT CKEY('q') /* exit picocom without reseting port */
#define KEY_PULSE CKEY('p') /* pulse DTR */
#define KEY_TOG_DTR CKEY('t') /* toggle DTR */
#define KEY_TOG_RTS CKEY('g') /* toggle RTS */
#define KEY_BAUD CKEY('b') /* set baudrate */
#define KEY_BAUD_UP CKEY('u') /* increase baudrate (up) */
#define KEY_BAUD_DN CKEY('d') /* decrase baudrate (down) */
#define KEY_FLOW CKEY('f') /* change flowcntrl mode */
#define KEY_PARITY CKEY('y') /* change parity mode */
#define KEY_BITS CKEY('i') /* change number of databits */
#define KEY_STOP CKEY('j') /* change number of stopbits */
#define KEY_LECHO CKEY('c') /* toggle local echo */
#define KEY_STATUS CKEY('v') /* show program options */
#define KEY_HELP CKEY('h') /* show help (same as [C-k]) */
#define KEY_KEYS CKEY('k') /* show available command keys */
#define KEY_SEND CKEY('s') /* send file */
#define KEY_RECEIVE CKEY('r') /* receive file */
#define KEY_HEX CKEY('w') /* write hex */
#define KEY_BREAK CKEY('\\') /* break */
/**********************************************************************/
/* implemented caracter mappings */
#define M_CRLF (1 << 0) /* map CR --> LF */
#define M_CRCRLF (1 << 1) /* map CR --> CR + LF */
#define M_IGNCR (1 << 2) /* map CR --> <nothing> */
#define M_LFCR (1 << 3) /* map LF --> CR */
#define M_LFCRLF (1 << 4) /* map LF --> CR + LF */
#define M_IGNLF (1 << 5) /* map LF --> <nothing> */
#define M_DELBS (1 << 6) /* map DEL --> BS */
#define M_BSDEL (1 << 7) /* map BS --> DEL */
#define M_SPCHEX (1 << 8) /* map special chars --> hex */
#define M_TABHEX (1 << 9) /* map TAB --> hex */
#define M_CRHEX (1 << 10) /* map CR --> hex */
#define M_LFHEX (1 << 11) /* map LF --> hex */
#define M_8BITHEX (1 << 12) /* map 8-bit chars --> hex */
#define M_NRMHEX (1 << 13) /* map normal ascii chars --> hex */
#define M_NFLAGS 14
/* default character mappings */
#define M_I_DFL 0
#define M_O_DFL 0
#define M_E_DFL (M_DELBS | M_CRCRLF)
/* character mapping names */
struct map_names_s {
const char *name;
int flag;
} map_names[] = {
{ "crlf", M_CRLF },
{ "crcrlf", M_CRCRLF },
{ "igncr", M_IGNCR },
{ "lfcr", M_LFCR },
{ "lfcrlf", M_LFCRLF },
{ "ignlf", M_IGNLF },
{ "delbs", M_DELBS },
{ "bsdel", M_BSDEL },
{ "spchex", M_SPCHEX },
{ "tabhex", M_TABHEX },
{ "crhex", M_CRHEX },
{ "lfhex", M_LFHEX },
{ "8bithex", M_8BITHEX },
{ "nrmhex", M_NRMHEX },
/* Sentinel */
{ NULL, 0 }
};
int
parse_map (char *s)
{
const char *m;
char *t;
int f, flags, i;
flags = 0;
while ( (t = strtok(s, ", \t")) ) {
for (i=0; (m = map_names[i].name); i++) {
if ( ! strcmp(t, m) ) {
f = map_names[i].flag;
break;
}
}
if ( m ) flags |= f;
else { flags = -1; break; }
s = NULL;
}
return flags;
}
void
print_map (int flags)
{
int i;
for (i = 0; i < M_NFLAGS; i++)
if ( flags & (1 << i) )
printf("%s,", map_names[i].name);
printf("\n");
}
/**********************************************************************/
struct {
char *port;
int baud;
enum flowcntrl_e flow;
enum parity_e parity;
int databits;
int stopbits;
int lecho;
int noinit;
int noreset;
int hangup;
#if defined (UUCP_LOCK_DIR) || defined (USE_FLOCK)
int nolock;
#endif
unsigned char escape;
int noescape;
char send_cmd[128];
char receive_cmd[128];
int imap;
int omap;
int emap;
char *log_filename;
char *initstring;
int exit_after;
int exit;
int lower_rts;
int lower_dtr;
int raise_rts;
int raise_dtr;
int quiet;
} opts = {
.port = NULL,
.baud = 9600,
.flow = FC_NONE,
.parity = P_NONE,
.databits = 8,
.stopbits = 1,
.lecho = 0,
.noinit = 0,
.noreset = 0,
.hangup = 0,
#if defined (UUCP_LOCK_DIR) || defined (USE_FLOCK)
.nolock = 0,
#endif
.escape = CKEY('a'),
.noescape = 0,
.send_cmd = "sz -vv",
.receive_cmd = "rz -vv -E",
.imap = M_I_DFL,
.omap = M_O_DFL,
.emap = M_E_DFL,
.log_filename = NULL,
.initstring = NULL,
.exit_after = -1,
.exit = 0,
.lower_rts = 0,
.lower_dtr = 0,
.raise_rts = 0,
.raise_dtr = 0,
.quiet = 0
};
int sig_exit = 0;
#define STI STDIN_FILENO
#define STO STDOUT_FILENO
#define STE STDERR_FILENO
int tty_fd = -1;
int log_fd = -1;
/* RTS and DTR are usually raised upon opening the serial port (at least
as tested on Linux, OpenBSD and macOS, but FreeBSD behave different) */
int rts_up = 1;
int dtr_up = 1;
#define TTY_Q_SZ_MIN 256
#ifndef TTY_Q_SZ
#define TTY_Q_SZ 32768
#endif
struct tty_q {
int sz;
int len;
unsigned char *buff;
} tty_q = {
.sz = 0,
.len = 0,
.buff = NULL
};
#define STI_RD_SZ 16
#define TTY_RD_SZ 128
int tty_write_sz;
#define TTY_WRITE_SZ_DIV 10
#define TTY_WRITE_SZ_MIN 8
#define set_tty_write_sz(baud) \
do { \
tty_write_sz = (baud) / TTY_WRITE_SZ_DIV; \
if ( tty_write_sz < TTY_WRITE_SZ_MIN ) \
tty_write_sz = TTY_WRITE_SZ_MIN; \
} while (0)
/**********************************************************************/
#ifdef UUCP_LOCK_DIR
/* use HDB UUCP locks .. see
* <http://www.faqs.org/faqs/uucp-internals> for details
*/
char lockname[_POSIX_PATH_MAX] = "";
int
uucp_lockname(const char *dir, const char *file)
{
char *p, *cp;
struct stat sb;
if ( ! dir || *dir == '\0' || stat(dir, &sb) != 0 )
return -1;
/* cut-off initial "/dev/" from file-name */
p = strchr(file + 1, '/');
p = p ? p + 1 : (char *)file;
/* replace '/'s with '_'s in what remains (after making a copy) */
p = cp = strdup(p);
do { if ( *p == '/' ) *p = '_'; } while(*p++);
/* build lockname */
snprintf(lockname, sizeof(lockname), "%s/LCK..%s", dir, cp);
/* destroy the copy */
free(cp);
return 0;
}
int
uucp_lock(void)
{
int r, fd, pid;
char buf[16];
mode_t m;
if ( lockname[0] == '\0' ) return 0;
fd = open(lockname, O_RDONLY);
if ( fd >= 0 ) {
r = read(fd, buf, sizeof(buf));
close(fd);
/* if r == 4, lock file is binary (old-style) */
pid = (r == 4) ? *(int *)buf : strtol(buf, NULL, 10);
if ( pid > 0
&& kill((pid_t)pid, 0) < 0
&& errno == ESRCH ) {
/* stale lock file */
pinfo("\r\nRemoving stale lock: %s\r\n", lockname);
sleep(1);
unlink(lockname);
} else {
lockname[0] = '\0';
errno = EEXIST;
return -1;
}
}
/* lock it */
m = umask(022);
fd = open(lockname, O_WRONLY|O_CREAT|O_EXCL, 0666);
if ( fd < 0 ) { lockname[0] = '\0'; return -1; }
umask(m);
snprintf(buf, sizeof(buf), "%04d\n", getpid());
write(fd, buf, strlen(buf));
close(fd);
return 0;
}
int
uucp_unlock(void)
{
if ( lockname[0] ) unlink(lockname);
return 0;
}
#endif /* of UUCP_LOCK_DIR */
/**********************************************************************/
#define HEXBUF_SZ 128
#define HEXDELIM " \r;:-_.,/"
#define hexisdelim(c) ( strchr(HEXDELIM, (c)) != NULL )
static inline int
hex2byte (char c)
{
int r;
if ( c >= '0' && c <= '9' )
r = c - '0';
else if ( c >= 'A' && c <= 'F')
r = c - 'A' + 10;
else if ( c >= 'a' && c <= 'f' )
r = c - 'a' + 10;
else
r = -1;
return r;
}
int
hex2bin(unsigned char *buf, int sz, const char *str)
{
char c;
int b0, b1;
int i;
i = 0;
while (i < sz) {
/* delimiter, end of string, or high nibble */
c = *str++;
if ( c == '\0' ) break;
if ( hexisdelim(c) ) continue;
b0 = hex2byte(c);
if ( b0 < 0 ) return -1;
/* low nibble */
c = *str++;
if ( c == '\0' ) return -1;
b1 = hex2byte(c);
if ( b1 < 0 ) return -1;
/* pack byte */
buf[i++] = (unsigned char)b0 << 4 | (unsigned char)b1;
}
return i;
}
/**********************************************************************/
#ifndef LINENOISE
char *
read_filename (void)
{
char fname[_POSIX_PATH_MAX];
int r;
fd_printf(STO, "\r\n*** file: ");
r = fd_readline(STI, STO, fname, sizeof(fname));
fd_printf(STO, "\r\n");
if ( r < 0 )
return NULL;
else
return strdup(fname);
}
int
read_baud (void)
{
char baudstr[9], *ep;
int baud = -1, r;
do {
fd_printf(STO, "\r\n*** baud: ");
r = fd_readline(STI, STO, baudstr, sizeof(baudstr));
fd_printf(STO, "\r\n");
if ( r < 0 )
break;
baud = strtol(baudstr, &ep, 0);
if ( ! ep || *ep != '\0' || ! term_baud_ok(baud) || baud == 0 ) {
fd_printf(STO, "*** Invalid baudrate!");
baud = -1;
}
} while (baud < 0);
return baud;
}
int
read_hex (unsigned char *buff, int sz)
{
char hexstr[256];
int r, n;
do {
fd_printf(STO, "\r\n*** hex: ");
r = fd_readline(STI, STO, hexstr, sizeof(hexstr));
fd_printf(STO, "\r\n");
if ( r < 0 ) {
n = 0;
break;
}
n = hex2bin(buff, sz, hexstr);
if ( n < 0 )
fd_printf(STO, "*** Invalid hex!");
} while (n < 0);
return n;
}
#else /* LINENOISE defined */
void
file_completion_cb (const char *buf, linenoiseCompletions *lc)
{
DIR *dirp;
struct dirent *dp;
char *basec, *basen, *dirc, *dirn;
int baselen, dirlen, namelen;
char *fullpath;
struct stat filestat;
basec = strdup(buf);
dirc = strdup(buf);
dirn = dirname(dirc);
dirlen = strlen(dirn);
basen = basename(basec);
baselen = strlen(basen);
dirp = opendir(dirn);
if (dirp) {
while ((dp = readdir(dirp)) != NULL) {
namelen = strlen(dp->d_name);
if (strncmp(basen, dp->d_name, baselen) == 0) {
/* add 2 extra bytes for possible / in middle & at end */
fullpath = (char *) malloc(namelen + dirlen + 3);
memcpy(fullpath, dirn, dirlen + 1);
if (fullpath[dirlen-1] != '/')
strcat(fullpath, "/");
strncat(fullpath, dp->d_name, namelen);
if (stat(fullpath, &filestat) == 0) {
if (S_ISDIR(filestat.st_mode)) {
strcat(fullpath, "/");
}
linenoiseAddCompletion(lc,fullpath);
}
free(fullpath);
}
}
closedir(dirp);
}
free(basec);
free(dirc);
}
static char *history_file_path = NULL;
void
init_history (void)
{
char *home_directory;
int home_directory_len;
home_directory = getenv("HOME");
if (home_directory) {
home_directory_len = strlen(home_directory);
history_file_path = malloc(home_directory_len + 2 + strlen(HISTFILE));
memcpy(history_file_path, home_directory, home_directory_len + 1);
if (home_directory[home_directory_len - 1] != '/') {
strcat(history_file_path, "/");
}
strcat(history_file_path, HISTFILE);
linenoiseHistoryLoad(history_file_path);
}
}
void
cleanup_history (void)
{
if (history_file_path)
free(history_file_path);
}
void
add_history (char *fname)
{
linenoiseHistoryAdd(fname);
if (history_file_path)
linenoiseHistorySave(history_file_path);
}
char *
read_filename (void)
{
char *fname;
linenoiseSetCompletionCallback(file_completion_cb);
fd_printf(STO, "\r\n");
fname = linenoise("*** file: ");
fd_printf(STO, "\r");
linenoiseSetCompletionCallback(NULL);
if (fname != NULL)
add_history(fname);
return fname;
}
int
read_baud (void)
{
char *baudstr, *ep;
int baud = -1;
do {
fd_printf(STO, "\r\n");
baudstr = linenoise("*** baud: ");
fd_printf(STO, "\r");
if ( baudstr == NULL )
break;
baud = strtol(baudstr, &ep, 0);
if ( ! ep || *ep != '\0' || ! term_baud_ok(baud) || baud == 0 ) {
fd_printf(STO, "*** Invalid baudrate!");
baud = -1;
}
free(baudstr);
} while (baud < 0);
if (baudstr != NULL)
add_history(baudstr);
return baud;
}
int
read_hex (unsigned char *buff, int sz)
{
char *hexstr;
int n;
do {
fd_printf(STO, "\r\n");
hexstr = linenoise("*** hex: ");
fd_printf(STO, "\r");
if ( hexstr == NULL ) {
n = 0;
break;
}
n = hex2bin(buff, sz, hexstr);
if ( n < 0 )
fd_printf(STO, "*** Invalid hex!");
free(hexstr);
} while (n < 0);
return n;
}
#endif /* of ifndef LINENOISE */
/**********************************************************************/
int
pinfo(const char *format, ...)
{
va_list args;
int len;
if ( opts.quiet ) {
return 0;
}
va_start(args, format);
len = fd_vprintf(STO, format, args);
va_end(args);
return len;
}
void
cleanup (int drain, int noreset, int hup)
{
if ( tty_fd >= 0 ) {
/* Print msg if they fail? Can't do anything, anyway... */
if ( drain )
term_drain(tty_fd);
term_flush(tty_fd);
/* term_flush does not work with some drivers. If we try to
drain or even close the port while there are still data in
it's output buffers *and* flow-control is enabled we may
block forever. So we "fake" a flush, by temporarily setting
f/c to none, waiting for any data in the output buffer to
drain, and then reseting f/c to it's original setting. If
the real flush above does works, then the fake one should
amount to instantaneously switching f/c to none and then
back to its propper setting. */
if ( opts.flow != FC_NONE ) term_fake_flush(tty_fd);
term_set_hupcl(tty_fd, !noreset || hup);
term_apply(tty_fd, 1);
if ( noreset ) {
pinfo("Skipping tty reset...\r\n");
term_erase(tty_fd);
#ifdef USE_FLOCK
/* Explicitly unlock tty_fd before exiting. See
comments in term.c/term_exitfunc() for more. */
flock(tty_fd, LOCK_UN);
#endif
close(tty_fd);
tty_fd = -1;
}
}
#ifdef LINENOISE
cleanup_history();
#endif
#ifdef UUCP_LOCK_DIR
uucp_unlock();
#endif
if ( opts.initstring ) {
free(opts.initstring);
opts.initstring = NULL;
}
if ( tty_q.buff ) {
free(tty_q.buff);
tty_q.buff = NULL;
}
free(opts.port);
if (opts.log_filename) {
free(opts.log_filename);
close(log_fd);
}
}
void
fatal (const char *format, ...)
{
va_list args;
fd_printf(STE, "\r\nFATAL: ");
va_start(args, format);
fd_vprintf(STE, format, args);
va_end(args);
fd_printf(STE, "\r\n");
cleanup(0 /* drain */, opts.noreset, opts.hangup);
exit(EXIT_FAILURE);
}
/**********************************************************************/
/* maximum number of chars that can replace a single characted
due to mapping */
#define M_MAXMAP 4
int
map2hex (char *b, char c)
{
const char *hexd = "0123456789abcdef";
b[0] = '[';
b[1] = hexd[(unsigned char)c >> 4];
b[2] = hexd[(unsigned char)c & 0x0f];
b[3] = ']';
return 4;
}
int
do_map (char *b, int map, char c)
{
int n = -1;
switch (c) {
case '\x7f':
/* DEL mapings */
if ( map & M_DELBS ) {
b[0] = '\x08'; n = 1;
}
break;
case '\x08':
/* BS mapings */
if ( map & M_BSDEL ) {
b[0] = '\x7f'; n = 1;
}
break;
case '\x0d':
/* CR mappings */
if ( map & M_CRLF ) {
b[0] = '\x0a'; n = 1;
} else if ( map & M_CRCRLF ) {
b[0] = '\x0d'; b[1] = '\x0a'; n = 2;
} else if ( map & M_IGNCR ) {
n = 0;
} else if ( map & M_CRHEX ) {
n = map2hex(b, c);
}
break;
case '\x0a':
/* LF mappings */
if ( map & M_LFCR ) {
b[0] = '\x0d'; n = 1;
} else if ( map & M_LFCRLF ) {
b[0] = '\x0d'; b[1] = '\x0a'; n = 2;
} else if ( map & M_IGNLF ) {
n = 0;
} else if ( map & M_LFHEX ) {
n = map2hex(b, c);
}
break;
case '\x09':
/* TAB mappings */
if ( map & M_TABHEX ) {
n = map2hex(b,c);
}
break;
default:
break;
}
if ( n < 0 && map & M_SPCHEX ) {
if ( c == '\x7f' || ( (unsigned char)c < 0x20
&& c != '\x09' && c != '\x0a'
&& c != '\x0d') ) {
n = map2hex(b,c);
}
}
if ( n < 0 && map & M_8BITHEX ) {
if ( c & 0x80 ) {
n = map2hex(b,c);
}
}
if ( n < 0 && map & M_NRMHEX ) {
if ( (unsigned char)c >= 0x20 && (unsigned char)c < 0x7f ) {
n = map2hex(b,c);
}
}
if ( n < 0 ) {
b[0] = c; n = 1;
}
assert(n > 0 && n <= M_MAXMAP);
return n;
}
void
map_and_write (int fd, int map, char c)
{
char b[M_MAXMAP];
int n;
n = do_map(b, map, c);
if ( n )
if ( writen_ni(fd, b, n) < n )
fatal("write to stdout failed: %s", strerror(errno));
}
/**********************************************************************/
int
baud_up (int baud)
{
return term_baud_up(baud);
}
int
baud_down (int baud)
{
int nb;
nb = term_baud_down(baud);
if (nb == 0)
nb = baud;
return nb;
}
enum flowcntrl_e
flow_next (enum flowcntrl_e flow)
{
switch(flow) {
case FC_NONE:
flow = FC_RTSCTS;
break;
case FC_RTSCTS:
flow = FC_XONXOFF;
break;
case FC_XONXOFF:
flow = FC_NONE;
break;
default:
flow = FC_NONE;
break;
}
return flow;
}
enum parity_e
parity_next (enum parity_e parity)
{
switch(parity) {
case P_NONE:
parity = P_EVEN;
break;
case P_EVEN:
parity = P_ODD;
break;
case P_ODD:
parity = P_NONE;
break;
default:
parity = P_NONE;
break;
}
return parity;
}
int
bits_next (int bits)
{
bits++;
if (bits > 8) bits = 5;
return bits;
}
int
stopbits_next (int bits)
{
bits++;
if (bits > 2) bits = 1;
return bits;
}
/**********************************************************************/
#define statpf(...) \
do { if (! quiet) fd_printf(__VA_ARGS__); } while(0)
int
show_status (int quiet)
{
int baud, bits, stopbits, mctl;
enum flowcntrl_e flow;
enum parity_e parity;
int mismatch = 0;
term_refresh(tty_fd);
baud = term_get_baudrate(tty_fd, NULL);
flow = term_get_flowcntrl(tty_fd);
parity = term_get_parity(tty_fd);
bits = term_get_databits(tty_fd);
stopbits = term_get_stopbits(tty_fd);
statpf(STO, "\r\n");
if ( baud != opts.baud ) {
mismatch++;
statpf(STO, "*** baud: %d (%d)\r\n", opts.baud, baud);
} else {
statpf(STO, "*** baud: %d\r\n", opts.baud);
}
if ( flow != opts.flow ) {
mismatch++;
statpf(STO, "*** flow: %s (%s)\r\n",
flow_str[opts.flow], flow_str[flow]);
} else {
statpf(STO, "*** flow: %s\r\n", flow_str[opts.flow]);
}
if ( parity != opts.parity ) {
mismatch++;
statpf(STO, "*** parity: %s (%s)\r\n",
parity_str[opts.parity], parity_str[parity]);
} else {
statpf(STO, "*** parity: %s\r\n", parity_str[opts.parity]);
}
if ( bits != opts.databits ) {
mismatch++;
statpf(STO, "*** databits: %d (%d)\r\n", opts.databits, bits);
} else {
statpf(STO, "*** databits: %d\r\n", opts.databits);
}
if ( stopbits != opts.stopbits ) {
mismatch++;
statpf(STO, "*** stopbits: %d (%d)\r\n", opts.stopbits, stopbits);
} else {
statpf(STO, "*** stopbits: %d\r\n", opts.stopbits);
}
mctl = term_get_mctl(tty_fd);
if (mctl >= 0 && mctl != MCTL_UNAVAIL) {
if ( ((mctl & MCTL_DTR) ? 1 : 0) == dtr_up ) {
statpf(STO, "*** dtr: %s\r\n", dtr_up ? "up" : "down");
} else {
mismatch++;
statpf(STO, "*** dtr: %s (%s)\r\n",
dtr_up ? "up" : "down",
(mctl & MCTL_DTR) ? "up" : "down");
}
if ( ((mctl & MCTL_RTS) ? 1 : 0) == rts_up ) {
statpf(STO, "*** rts: %s\r\n", rts_up ? "up" : "down");
} else {
mismatch++;
statpf(STO, "*** rts: %s (%s)\r\n",
rts_up ? "up" : "down",
(mctl & MCTL_RTS) ? "up" : "down");
}
statpf(STO, "*** mctl: ");
statpf(STO, "DTR:%c DSR:%c DCD:%c RTS:%c CTS:%c RI:%c\r\n",
(mctl & MCTL_DTR) ? '1' : '0',
(mctl & MCTL_DSR) ? '1' : '0',
(mctl & MCTL_DCD) ? '1' : '0',
(mctl & MCTL_RTS) ? '1' : '0',
(mctl & MCTL_CTS) ? '1' : '0',
(mctl & MCTL_RI) ? '1' : '0');
} else {
statpf(STO, "*** dtr: %s\r\n", dtr_up ? "up" : "down");
statpf(STO, "*** rts: %s\r\n", rts_up ? "up" : "down");
}
return mismatch;
}
#undef statpf
/**********************************************************************/
void
show_keys()
{
#ifndef NO_HELP
fd_printf(STO, "\r\n");
fd_printf(STO, "*** Picocom commands (all prefixed by [C-%c])\r\n",
KEYC(opts.escape));
fd_printf(STO, "\r\n");
fd_printf(STO, "*** [C-%c] : Exit picocom\r\n",
KEYC(KEY_EXIT));
fd_printf(STO, "*** [C-%c] : Exit without reseting serial port\r\n",
KEYC(KEY_QUIT));
fd_printf(STO, "*** [C-%c] : Set baudrate\r\n",
KEYC(KEY_BAUD));
fd_printf(STO, "*** [C-%c] : Increase baudrate (baud-up)\r\n",
KEYC(KEY_BAUD_UP));
fd_printf(STO, "*** [C-%c] : Decrease baudrate (baud-down)\r\n",
KEYC(KEY_BAUD_DN));;
fd_printf(STO, "*** [C-%c] : Change number of databits\r\n",
KEYC(KEY_BITS));
fd_printf(STO, "*** [C-%c] : Change number of stopbits\r\n",
KEYC(KEY_STOP));
fd_printf(STO, "*** [C-%c] : Change flow-control mode\r\n",
KEYC(KEY_FLOW));
fd_printf(STO, "*** [C-%c] : Change parity mode\r\n",
KEYC(KEY_PARITY));
fd_printf(STO, "*** [C-%c] : Pulse DTR\r\n",
KEYC(KEY_PULSE));
fd_printf(STO, "*** [C-%c] : Toggle DTR\r\n",
KEYC(KEY_TOG_DTR));
fd_printf(STO, "*** [C-%c] : Toggle RTS\r\n",
KEYC(KEY_TOG_RTS));
fd_printf(STO, "*** [C-%c] : Send break\r\n",
KEYC(KEY_BREAK));
fd_printf(STO, "*** [C-%c] : Toggle local echo\r\n",
KEYC(KEY_LECHO));
fd_printf(STO, "*** [C-%c] : Write hex\r\n",
KEYC(KEY_HEX));
fd_printf(STO, "*** [C-%c] : Send file\r\n",
KEYC(KEY_SEND));
fd_printf(STO, "*** [C-%c] : Receive file\r\n",
KEYC(KEY_RECEIVE));
fd_printf(STO, "*** [C-%c] : Show port settings\r\n",
KEYC(KEY_STATUS));
fd_printf(STO, "*** [C-%c] : Show this message\r\n",
KEYC(KEY_HELP));
fd_printf(STO, "\r\n");
#else /* defined NO_HELP */
fd_printf(STO, "*** Help is disabled.\r\n");
#endif /* of NO_HELP */
}
/**********************************************************************/
#define RUNCMD_ARGS_MAX 32
#define RUNCMD_EXEC_FAIL 126
void
establish_child_signal_handlers (void)
{
struct sigaction dfl_action;
/* Set up the structure to specify the default action. */
dfl_action.sa_handler = SIG_DFL;
sigemptyset (&dfl_action.sa_mask);
dfl_action.sa_flags = 0;
sigaction (SIGINT, &dfl_action, NULL);
sigaction (SIGTERM, &dfl_action, NULL);
}
int
run_cmd(int fd, const char *cmd, const char *args_extra)
{
pid_t pid;
sigset_t sigm, sigm_old;
struct sigaction ign_action, old_action;
/* Picocom ignores SIGINT while the command is running */
ign_action.sa_handler = SIG_IGN;
sigemptyset (&ign_action.sa_mask);
ign_action.sa_flags = 0;
sigaction (SIGINT, &ign_action, &old_action);
/* block signals, let child establish its own handlers */
sigemptyset(&sigm);
sigaddset(&sigm, SIGTERM);
sigaddset(&sigm, SIGINT);
sigprocmask(SIG_BLOCK, &sigm, &sigm_old);
pid = fork();
if ( pid < 0 ) {
sigprocmask(SIG_SETMASK, &sigm_old, NULL);
fd_printf(STO, "*** cannot fork: %s ***\r\n", strerror(errno));
return -1;
} else if ( pid ) {
/* father: picocom */
int status, r;
/* reset the mask */
sigprocmask(SIG_SETMASK, &sigm_old, NULL);
/* wait for child to finish */
do {
r = waitpid(pid, &status, 0);
} while ( r < 0 && errno == EINTR );
/* reset terminal (back to raw mode) */
term_apply(STI, 0);
/* re-enable SIGINT */
sigaction(SIGINT, &old_action, NULL);
/* check and report child return status */
if ( WIFEXITED(status) ) {
fd_printf(STO, "\r\n*** exit status: %d ***\r\n",
WEXITSTATUS(status));
return WEXITSTATUS(status);
} else if ( WIFSIGNALED(status) ) {
fd_printf(STO, "\r\n*** killed by signal: %d ***\r\n",
WTERMSIG(status));
return -1;
} else {
fd_printf(STO, "\r\n*** abnormal termination: 0x%x ***\r\n", r);
return -1;
}
} else {
/* child: external program */
long fl;
int argc;
char *argv[RUNCMD_ARGS_MAX + 1];
int r;
/* unmanage terminal, and reset it to canonical mode */
term_drain(STI);
term_remove(STI);
/* unmanage serial port fd, without reset */
term_erase(fd);
/* set serial port fd to blocking mode */
fl = fcntl(fd, F_GETFL);
fl &= ~O_NONBLOCK;
fcntl(fd, F_SETFL, fl);
/* connect stdin and stdout to serial port */
close(STI);
close(STO);
dup2(fd, STI);
dup2(fd, STO);
/* build command arguments vector */
argc = 0;
r = split_quoted(cmd, &argc, argv, RUNCMD_ARGS_MAX);
if ( r < 0 ) {
fd_printf(STE, "Cannot parse command\n");
exit(RUNCMD_EXEC_FAIL);
}
r = split_quoted(args_extra, &argc, argv, RUNCMD_ARGS_MAX);
if ( r < 0 ) {
fd_printf(STE, "Cannot parse extra args\n");
exit(RUNCMD_EXEC_FAIL);
}
if ( argc < 1 ) {
fd_printf(STE, "No command given\n");
exit(RUNCMD_EXEC_FAIL);
}
argv[argc] = NULL;
/* run extenral command */
fd_printf(STE, "$ %s %s\n", cmd, args_extra);
establish_child_signal_handlers();
sigprocmask(SIG_SETMASK, &sigm_old, NULL);
execvp(argv[0], argv);
fd_printf(STE, "exec: %s\n", strerror(errno));
exit(RUNCMD_EXEC_FAIL);
}
}
/**********************************************************************/
int tty_q_push(const char *s, int len) {
int i, sz, n;
unsigned char *b;
for (i = 0; i < len; i++) {
while (tty_q.len + M_MAXMAP > tty_q.sz) {
sz = tty_q.sz * 2;
if ( TTY_Q_SZ && sz > TTY_Q_SZ )
return i;
b = realloc(tty_q.buff, sz);
if ( ! b )
return i;
tty_q.buff = b;
tty_q.sz = sz;
#if 0
fd_printf(STO, "New tty_q size: %d\r\n", sz);
#endif
}
n = do_map((char *)tty_q.buff + tty_q.len,
opts.omap, s[i]);
tty_q.len += n;
/* write to STO if local-echo is enabled */
if ( opts.lecho )
map_and_write(STO, opts.emap, s[i]);
}
return i;
}
/* Process command key. Returns non-zero if command results in picocom
exit, zero otherwise. */
int
do_command (unsigned char c)
{
int newbaud, newbits, newstopbits;
enum flowcntrl_e newflow;
enum parity_e newparity;
const char *xfr_cmd;
char *fname;
unsigned char hexbuf[HEXBUF_SZ];
int n, r;
switch (c) {
case KEY_EXIT:
return 1;
case KEY_QUIT:
opts.noreset = 1;
return 1;
case KEY_STATUS:
show_status(0);
break;
case KEY_HELP:
case KEY_KEYS:
show_keys();
break;
case KEY_PULSE:
fd_printf(STO, "\r\n*** pulse DTR ***\r\n");
if ( term_pulse_dtr(tty_fd) < 0 )
fd_printf(STO, "*** FAILED\r\n");
else
dtr_up = 1;
break;
case KEY_TOG_DTR:
if ( dtr_up )
r = term_lower_dtr(tty_fd);
else
r = term_raise_dtr(tty_fd);
if ( r >= 0 ) dtr_up = ! dtr_up;
fd_printf(STO, "\r\n*** DTR: %s ***\r\n",
dtr_up ? "up" : "down");
break;
case KEY_TOG_RTS:
if ( rts_up )
r = term_lower_rts(tty_fd);
else
r = term_raise_rts(tty_fd);
if ( r >= 0 ) rts_up = ! rts_up;
fd_printf(STO, "\r\n*** RTS: %s ***\r\n",
rts_up ? "up" : "down");
break;
case KEY_BAUD:
case KEY_BAUD_UP:
case KEY_BAUD_DN:
if ( c== KEY_BAUD) {
newbaud = read_baud();
if ( newbaud < 0 ) {
fd_printf(STO, "*** cannot read baudrate ***\r\n");
break;
}
opts.baud = newbaud;
} else if (c == KEY_BAUD_UP) {
opts.baud = baud_up(opts.baud);
} else {
opts.baud = baud_down(opts.baud);
}
term_set_baudrate(tty_fd, opts.baud);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newbaud = term_get_baudrate(tty_fd, NULL);
if ( opts.baud != newbaud ) {
fd_printf(STO, "\r\n*** baud: %d (%d) ***\r\n",
opts.baud, newbaud);
} else {
fd_printf(STO, "\r\n*** baud: %d ***\r\n", opts.baud);
}
set_tty_write_sz(newbaud);
break;
case KEY_FLOW:
opts.flow = flow_next(opts.flow);
term_set_flowcntrl(tty_fd, opts.flow);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newflow = term_get_flowcntrl(tty_fd);
if ( opts.flow != newflow ) {
fd_printf(STO, "\r\n*** flow: %s (%s) ***\r\n",
flow_str[opts.flow], flow_str[newflow]);
} else {
fd_printf(STO, "\r\n*** flow: %s ***\r\n",
flow_str[opts.flow]);
}
break;
case KEY_PARITY:
opts.parity = parity_next(opts.parity);
term_set_parity(tty_fd, opts.parity);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newparity = term_get_parity(tty_fd);
if (opts.parity != newparity ) {
fd_printf(STO, "\r\n*** parity: %s (%s) ***\r\n",
parity_str[opts.parity],
parity_str[newparity]);
} else {
fd_printf(STO, "\r\n*** parity: %s ***\r\n",
parity_str[opts.parity]);
}
break;
case KEY_BITS:
opts.databits = bits_next(opts.databits);
term_set_databits(tty_fd, opts.databits);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newbits = term_get_databits(tty_fd);
if (opts.databits != newbits ) {
fd_printf(STO, "\r\n*** databits: %d (%d) ***\r\n",
opts.databits, newbits);
} else {
fd_printf(STO, "\r\n*** databits: %d ***\r\n",
opts.databits);
}
break;
case KEY_STOP:
opts.stopbits = stopbits_next(opts.stopbits);
term_set_stopbits(tty_fd, opts.stopbits);
tty_q.len = 0; term_flush(tty_fd);
term_apply(tty_fd, 1);
newstopbits = term_get_stopbits(tty_fd);
if (opts.stopbits != newstopbits ) {
fd_printf(STO, "\r\n*** stopbits: %d (%d) ***\r\n",
opts.stopbits, newstopbits);
} else {
fd_printf(STO, "\r\n*** stopbits: %d ***\r\n",
opts.stopbits);
}
break;
case KEY_LECHO:
opts.lecho = ! opts.lecho;
fd_printf(STO, "\r\n*** local echo: %s ***\r\n",
opts.lecho ? "yes" : "no");
break;
case KEY_SEND:
case KEY_RECEIVE:
xfr_cmd = (c == KEY_SEND) ? opts.send_cmd : opts.receive_cmd;
if ( xfr_cmd[0] == '\0' ) {
fd_printf(STO, "\r\n*** command disabled ***\r\n");
break;
}
fname = read_filename();
if (fname == NULL) {
fd_printf(STO, "*** cannot read filename ***\r\n");
break;
}
run_cmd(tty_fd, xfr_cmd, fname);
free(fname);
break;
case KEY_HEX:
n = read_hex(hexbuf, sizeof(hexbuf));
if ( n < 0 ) {
fd_printf(STO, "*** cannot read hex ***\r\n");
break;
}
if ( tty_q_push((char *)hexbuf, n) != n )
fd_printf(STO, "*** output buffer full ***\r\n");
fd_printf(STO, "*** wrote %d bytes ***\r\n", n);
break;
case KEY_BREAK:
term_break(tty_fd);
fd_printf(STO, "\r\n*** break sent ***\r\n");
break;
default:
break;
}
return 0;
}
/**********************************************************************/
static struct timeval *
msec2tv (struct timeval *tv, long ms)
{
tv->tv_sec = ms / 1000;
tv->tv_usec = (ms % 1000) * 1000;
return tv;
}
/* loop-exit reason */
enum le_reason {
LE_CMD,
LE_IDLE,
LE_STDIN,
LE_SIGNAL
};
enum le_reason
loop(void)
{
enum {
ST_COMMAND,
ST_TRANSPARENT
} state;
fd_set rdset, wrset;
int r, n;
int stdin_closed;
state = ST_TRANSPARENT;
if ( ! opts.exit )
stdin_closed = 0;
else
stdin_closed = 1;
while ( ! sig_exit ) {
struct timeval tv, *ptv;
ptv = NULL;
FD_ZERO(&rdset);
FD_ZERO(&wrset);
if ( ! stdin_closed ) FD_SET(STI, &rdset);
if ( ! opts.exit ) FD_SET(tty_fd, &rdset);
if ( tty_q.len ) {
FD_SET(tty_fd, &wrset);
} else {
if ( opts.exit_after >= 0 ) {
msec2tv(&tv, opts.exit_after);
ptv = &tv;
} else if ( stdin_closed ) {
/* stdin closed, output queue empty, and no
idle timeout: Exit. */
return LE_STDIN;
}
}
r = select(tty_fd + 1, &rdset, &wrset, NULL, ptv);
if ( r < 0 ) {
if ( errno == EINTR )
continue;
else
fatal("select failed: %d : %s", errno, strerror(errno));
}
if ( r == 0 ) {
/* Idle timeout expired */
return LE_IDLE;
}
if ( FD_ISSET(STI, &rdset) ) {
/* read from terminal */
char buff_rd[STI_RD_SZ];
int i;
unsigned char c;
do {
n = read(STI, buff_rd, sizeof(buff_rd));
} while (n < 0 && errno == EINTR);
if (n == 0) {
stdin_closed = 1;
pinfo("\r\n** read zero bytes from stdin **\r\n");
goto skip_proc_STI;
} else if (n < 0) {
/* is this really necessary? better safe than sory! */
if ( errno != EAGAIN && errno != EWOULDBLOCK )
fatal("read from stdin failed: %s", strerror(errno));
else
goto skip_proc_STI;
}
for ( i = 0; i < n; i++ ) {
c = buff_rd[i];
switch (state) {
case ST_COMMAND:
if ( c == opts.escape ) {
/* pass the escape character down */
if ( tty_q_push((char *)&c, 1) != 1 )
fd_printf(STO, "\x07");
} else {
/* process command key */
if ( do_command(c) )
/* picocom exit */
return LE_CMD;
}
state = ST_TRANSPARENT;
break;
case ST_TRANSPARENT:
if ( ! opts.noescape && c == opts.escape )
state = ST_COMMAND;
else
if ( tty_q_push((char *)&c, 1) != 1 )
fd_printf(STO, "\x07");
break;
default:
assert(0);
break;
}
}
}
skip_proc_STI:
if ( FD_ISSET(tty_fd, &rdset) ) {
char buff_rd[TTY_RD_SZ];
char buff_map[TTY_RD_SZ * M_MAXMAP];
/* read from port */
do {
n = read(tty_fd, &buff_rd, sizeof(buff_rd));
} while (n < 0 && errno == EINTR);
if (n == 0) {
fatal("read zero bytes from port");
} else if ( n < 0 ) {
if ( errno != EAGAIN && errno != EWOULDBLOCK )
fatal("read from port failed: %s", strerror(errno));
} else {
int i;
char *bmp = &buff_map[0];
if ( opts.log_filename )
if ( writen_ni(log_fd, buff_rd, n) < n )
fatal("write to logfile failed: %s", strerror(errno));
for (i = 0; i < n; i++) {
bmp += do_map(bmp, opts.imap, buff_rd[i]);
}
n = bmp - buff_map;
if ( writen_ni(STO, buff_map, n) < n )
fatal("write to stdout failed: %s", strerror(errno));
}
}
if ( FD_ISSET(tty_fd, &wrset) ) {
/* write to port */
int sz;
sz = (tty_q.len < tty_write_sz) ? tty_q.len : tty_write_sz;
do {
n = write(tty_fd, tty_q.buff, sz);
} while ( n < 0 && errno == EINTR );
if ( n <= 0 )
fatal("write to port failed: %s", strerror(errno));
if ( opts.lecho && opts.log_filename )
if ( writen_ni(log_fd, tty_q.buff, n) < n )
fatal("write to logfile failed: %s", strerror(errno));
memmove(tty_q.buff, tty_q.buff + n, tty_q.len - n);
tty_q.len -= n;
}
}
return LE_SIGNAL;
}
/**********************************************************************/
void
deadly_handler(int signum)
{
(void)signum; /* silence unused warning */
if ( ! sig_exit ) {
sig_exit = 1;
kill(0, SIGTERM);
}
}
void
establish_signal_handlers (void)
{
struct sigaction exit_action, ign_action;
/* Set up the structure to specify the exit action. */
exit_action.sa_handler = deadly_handler;
sigemptyset (&exit_action.sa_mask);
exit_action.sa_flags = 0;
/* Set up the structure to specify the ignore action. */
ign_action.sa_handler = SIG_IGN;
sigemptyset (&ign_action.sa_mask);
ign_action.sa_flags = 0;
sigaction (SIGTERM, &exit_action, NULL);
sigaction (SIGINT, &exit_action, NULL);
sigaction (SIGHUP, &ign_action, NULL);
sigaction (SIGQUIT, &ign_action, NULL);
sigaction (SIGALRM, &ign_action, NULL);
sigaction (SIGUSR1, &ign_action, NULL);
sigaction (SIGUSR2, &ign_action, NULL);
sigaction (SIGPIPE, &ign_action, NULL);
}
/**********************************************************************/
void
show_usage(char *name)
{
#ifndef NO_HELP
char *s;
s = strrchr(name, '/');
s = s ? s+1 : name;
printf("picocom v%s\n", VERSION_STR);
printf("\nCompiled-in options:\n");
printf(" TTY_Q_SZ is %d\n", TTY_Q_SZ);
#ifdef HIGH_BAUD
printf(" HIGH_BAUD is enabled\n");
#endif
#ifdef USE_FLOCK
printf(" USE_FLOCK is enabled\n");
#endif
#ifdef UUCP_LOCK_DIR
printf(" UUCP_LOCK_DIR is: %s\n", UUCP_LOCK_DIR);
#endif
#ifdef LINENOISE
printf(" LINENOISE is enabled\n");
printf(" HISTFILE is: %s\n", HISTFILE);
#endif
#ifdef USE_CUSTOM_BAUD
printf(" USE_CUSTOM_BAUD is enabled\n");
if ( ! use_custom_baud() )
printf(" NO_CUSTOM_BAUD is set\n");
#endif
printf("\nUsage is: %s [options] <tty port device>\n", s);
printf("Options are:\n");
printf(" --<b>aud <baudrate>\n");
printf(" --<f>low x (=soft,xon/xoff) | h (=hard) | n (=none)\n");
printf(" --parit<y> o (=odd) | e (=even) | n (=none)\n");
printf(" --<d>atabits 5 | 6 | 7 | 8\n");
printf(" --sto<p>bits 1 | 2\n");
printf(" --<e>scape <char>\n");
printf(" --<n>o-escape\n");
printf(" --e<c>ho\n");
printf(" --no<i>nit\n");
printf(" --no<r>eset\n");
printf(" --hang<u>p\n");
printf(" --no<l>ock\n");
printf(" --<s>end-cmd <command>\n");
printf(" --recei<v>e-cmd <command>\n");
printf(" --imap <map> (input mappings)\n");
printf(" --omap <map> (output mappings)\n");
printf(" --emap <map> (local-echo mappings)\n");
printf(" --lo<g>file <filename>\n");
printf(" --inits<t>ring <string>\n");
printf(" --e<x>it-after <msec>\n");
printf(" --e<X>it\n");
printf(" --lower-rts\n");
printf(" --raise-rts\n");
printf(" --lower-dtr\n");
printf(" --raise-dtr\n");
printf(" --<q>uiet\n");
printf(" --<h>elp\n");
printf("<map> is a comma-separated list of one or more of:\n");
printf(" crlf : map CR --> LF\n");
printf(" crcrlf : map CR --> CR + LF\n");
printf(" igncr : ignore CR\n");
printf(" lfcr : map LF --> CR\n");
printf(" lfcrlf : map LF --> CR + LF\n");
printf(" ignlf : ignore LF\n");
printf(" bsdel : map BS --> DEL\n");
printf(" delbs : map DEL --> BS\n");
printf(" spchex : map special chars (excl. CR, LF & TAB) --> hex\n");
printf(" tabhex : map TAB --> hex\n");
printf(" crhex : map CR --> hex\n");
printf(" lfhex : map LF --> hex\n");
printf(" 8bithex : map 8-bit chars --> hex\n");
printf(" nrmhex : map normal ascii chars --> hex\n");
printf("<?> indicates the equivalent short option.\n");
printf("Short options are prefixed by \"-\" instead of by \"--\".\n");
#else /* defined NO_HELP */
printf("Help disabled.\n");
#endif /* of NO_HELP */
fflush(stdout);
}
/**********************************************************************/
void
parse_args(int argc, char *argv[])
{
int r;
static struct option longOptions[] =
{
{"receive-cmd", required_argument, 0, 'v'},
{"send-cmd", required_argument, 0, 's'},
{"imap", required_argument, 0, 'I' },
{"omap", required_argument, 0, 'O' },
{"emap", required_argument, 0, 'E' },
{"escape", required_argument, 0, 'e'},
{"no-escape", no_argument, 0, 'n'},
{"echo", no_argument, 0, 'c'},
{"noinit", no_argument, 0, 'i'},
{"noreset", no_argument, 0, 'r'},
{"hangup", no_argument, 0, 'u'},
{"nolock", no_argument, 0, 'l'},
{"flow", required_argument, 0, 'f'},
{"baud", required_argument, 0, 'b'},
{"parity", required_argument, 0, 'y'},
{"databits", required_argument, 0, 'd'},
{"stopbits", required_argument, 0, 'p'},
{"logfile", required_argument, 0, 'g'},
{"initstring", required_argument, 0, 't'},
{"exit-after", required_argument, 0, 'x'},
{"exit", no_argument, 0, 'X'},
{"lower-rts", no_argument, 0, 1},
{"lower-dtr", no_argument, 0, 2},
{"raise-rts", no_argument, 0, 3},
{"raise-dtr", no_argument, 0, 4},
{"quiet", no_argument, 0, 'q'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
r = 0;
while (1) {
int optionIndex = 0;
int c;
int map;
char *ep;
/* no default error messages printed. */
opterr = 0;
c = getopt_long(argc, argv, "hirulcqXnv:s:r:e:f:b:y:d:p:g:t:x:",
longOptions, &optionIndex);
if (c < 0)
break;
switch (c) {
case 's':
strncpy(opts.send_cmd, optarg, sizeof(opts.send_cmd));
opts.send_cmd[sizeof(opts.send_cmd) - 1] = '\0';
break;
case 'v':
strncpy(opts.receive_cmd, optarg, sizeof(opts.receive_cmd));
opts.receive_cmd[sizeof(opts.receive_cmd) - 1] = '\0';
break;
case 'I':
map = parse_map(optarg);
if (map >= 0) opts.imap = map;
else { fprintf(stderr, "Invalid --imap\n"); r = -1; }
break;
case 'O':
map = parse_map(optarg);
if (map >= 0) opts.omap = map;
else { fprintf(stderr, "Invalid --omap\n"); r = -1; }
break;
case 'E':
map = parse_map(optarg);
if (map >= 0) opts.emap = map;
else { fprintf(stderr, "Invalid --emap\n"); r = -1; }
break;
case 'c':
opts.lecho = 1;
break;
case 'i':
opts.noinit = 1;
break;
case 'r':
opts.noreset = 1;
break;
case 'u':
opts.hangup = 1;
break;
case 'l':
#if defined (UUCP_LOCK_DIR) || defined (USE_FLOCK)
opts.nolock = 1;
#endif
break;
case 'e':
opts.escape = CKEY(optarg[0]);
break;
case 'n':
opts.noescape = 1;
break;
case 'f':
switch (optarg[0]) {
case 'X':
case 'x':
case 'S':
case 's':
opts.flow = FC_XONXOFF;
break;
case 'H':
case 'h':
opts.flow = FC_RTSCTS;
break;
case 'N':
case 'n':
opts.flow = FC_NONE;
break;
default:
fprintf(stderr, "Invalid --flow: %c\n", optarg[0]);
r = -1;
break;
}
break;
case 'b':
opts.baud = atoi(optarg);
if ( opts.baud == 0 || ! term_baud_ok(opts.baud) ) {
fprintf(stderr, "Invalid --baud: %d\n", opts.baud);
r = -1;
}
break;
case 'y':
switch (optarg[0]) {
case 'e':
opts.parity = P_EVEN;
break;
case 'o':
opts.parity = P_ODD;
break;
case 'n':
opts.parity = P_NONE;
break;
default:
fprintf(stderr, "Invalid --parity: %c\n", optarg[0]);
r = -1;
break;
}
break;
case 'd':
switch (optarg[0]) {
case '5':
opts.databits = 5;
break;
case '6':
opts.databits = 6;
break;
case '7':
opts.databits = 7;
break;
case '8':
opts.databits = 8;
break;
default:
fprintf(stderr, "Invalid --databits: %c\n", optarg[0]);
r = -1;
break;
}
break;
case 'p':
opts.stopbits = 1;
switch (optarg[0]) {
case '1':
break;
case '2':
opts.stopbits = 2;
break;
/* For backwards compatibility, you can use 'p' to set
the parity as well */
case 'e':
opts.parity = P_EVEN;
break;
case 'o':
opts.parity = P_ODD;
break;
case 'n':
opts.parity = P_NONE;
break;
default:
fprintf(stderr, "Invalid --stopbits: %c\n", optarg[0]);
r = -1;
break;
}
break;
case 'g':
if ( opts.log_filename ) free(opts.log_filename);
opts.log_filename = strdup(optarg);
break;
case 't':
if ( opts.initstring ) free(opts.initstring);
opts.initstring = strdup(optarg);
break;
case 1:
opts.lower_rts = 1;
break;
case 2:
opts.lower_dtr = 1;
break;
case 3:
opts.raise_rts = 1;
break;
case 4:
opts.raise_dtr = 1;
break;
case 'x':
opts.exit_after = strtol(optarg, &ep, 10);
if ( ! ep || *ep != '\0' || opts.exit_after < 0 ) {
fprintf(stderr, "Inavild --exit-after: %s\n", optarg);
r = -1;
break;
}
break;
case 'X':
opts.exit = 1;
break;
case 'q':
opts.quiet = 1;
break;
case 'h':
show_usage(argv[0]);
exit(EXIT_SUCCESS);
case '?':
default:
fprintf(stderr, "Unrecognized option(s)\n");
r = -1;
break;
}
if ( r < 0 ) {
fprintf(stderr, "Run with '--help'.\n");
exit(EXIT_FAILURE);
}
} /* while */
if ( opts.raise_rts && opts.lower_rts ) {
fprintf(stderr, "Both --raise-rts and --lower-rts given\n");
exit(EXIT_FAILURE);
}
if ( opts.raise_dtr && opts.lower_dtr ) {
fprintf(stderr, "Both --raise-dtr and --lower-dtr given\n");
exit(EXIT_FAILURE);
}
/* --exit overrides --exit-after */
if ( opts.exit ) opts.exit_after = -1;
if ( (argc - optind) < 1) {
fprintf(stderr, "No port given\n");
fprintf(stderr, "Run with '--help'.\n");
exit(EXIT_FAILURE);
}
opts.port = strdup(argv[argc-1]);
if ( ! opts.port ) {
fprintf(stderr, "Out of memory\n");
exit(EXIT_FAILURE);
}
if ( opts.quiet )
return;
#ifndef NO_HELP
printf("picocom v%s\n", VERSION_STR);
printf("\n");
printf("port is : %s\n", opts.port);
printf("flowcontrol : %s\n", flow_str[opts.flow]);
printf("baudrate is : %d\n", opts.baud);
printf("parity is : %s\n", parity_str[opts.parity]);
printf("databits are : %d\n", opts.databits);
printf("stopbits are : %d\n", opts.stopbits);
if ( opts.noescape ) {
printf("escape is : none\n");
} else {
printf("escape is : C-%c\n", KEYC(opts.escape));
}
printf("local echo is : %s\n", opts.lecho ? "yes" : "no");
printf("noinit is : %s\n", opts.noinit ? "yes" : "no");
printf("noreset is : %s\n", opts.noreset ? "yes" : "no");
printf("hangup is : %s\n", opts.hangup ? "yes" : "no");
#if defined (UUCP_LOCK_DIR) || defined (USE_FLOCK)
printf("nolock is : %s\n", opts.nolock ? "yes" : "no");
#endif
printf("send_cmd is : %s\n",
(opts.send_cmd[0] == '\0') ? "disabled" : opts.send_cmd);
printf("receive_cmd is : %s\n",
(opts.receive_cmd[0] == '\0') ? "disabled" : opts.receive_cmd);
printf("imap is : "); print_map(opts.imap);
printf("omap is : "); print_map(opts.omap);
printf("emap is : "); print_map(opts.emap);
printf("logfile is : %s\n", opts.log_filename ? opts.log_filename : "none");
if ( opts.initstring ) {
printf("initstring len : %lu bytes\n",
(unsigned long)strlen(opts.initstring));
} else {
printf("initstring : none\n");
}
if (opts.exit_after < 0) {
printf("exit_after is : not set\n");
} else {
printf("exit_after is : %d ms\n", opts.exit_after);
}
printf("exit is : %s\n", opts.exit ? "yes" : "no");
printf("\n");
fflush(stdout);
#endif /* of NO_HELP */
}
/**********************************************************************/
void
set_dtr_rts (void)
{
int r;
if ( opts.lower_rts ) {
r = term_lower_rts(tty_fd);
if ( r < 0 )
fatal("failed to lower RTS of port: %s",
term_strerror(term_errno, errno));
rts_up = 0;
} else if ( opts.raise_rts ) {
r = term_raise_rts(tty_fd);
if ( r < 0 )
fatal("failed to raise RTS of port: %s",
term_strerror(term_errno, errno));
rts_up = 1;
}
if ( opts.lower_dtr ) {
r = term_lower_dtr(tty_fd);
if ( r < 0 )
fatal("failed to lower DTR of port: %s",
term_strerror(term_errno, errno));
dtr_up = 0;
} else if ( opts.raise_dtr ) {
r = term_raise_dtr(tty_fd);
if ( r < 0 )
fatal("failed to raise DTR of port: %s",
term_strerror(term_errno, errno));
dtr_up = 1;
}
/* Try to read the status of the modem-conrtol lines from the
port. */
r = term_get_mctl(tty_fd);
if ( r >= 0 && r != MCTL_UNAVAIL ) {
rts_up = (r & MCTL_RTS) != 0;
dtr_up = (r & MCTL_DTR) != 0;
}
}
int
main (int argc, char *argv[])
{
int xcode = EXIT_SUCCESS;
int ler;
int r;
parse_args(argc, argv);
establish_signal_handlers();
r = term_lib_init();
if ( r < 0 )
fatal("term_lib_init failed: %s", term_strerror(term_errno, errno));
#ifdef UUCP_LOCK_DIR
if ( ! opts.nolock ) uucp_lockname(UUCP_LOCK_DIR, opts.port);
if ( uucp_lock() < 0 )
fatal("cannot lock %s: %s", opts.port, strerror(errno));
#endif
if (opts.log_filename) {
log_fd = open(opts.log_filename,
O_CREAT | O_RDWR | O_APPEND,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
if (log_fd < 0)
fatal("cannot open %s: %s", opts.log_filename, strerror(errno));
}
tty_fd = open(opts.port, O_RDWR | O_NONBLOCK | O_NOCTTY);
if (tty_fd < 0)
fatal("cannot open %s: %s", opts.port, strerror(errno));
#ifdef USE_FLOCK
if ( ! opts.nolock ) {
r = flock(tty_fd, LOCK_EX | LOCK_NB);
if ( r < 0 )
fatal("cannot lock %s: %s", opts.port, strerror(errno));
}
#endif
if ( opts.noinit ) {
r = term_add(tty_fd);
} else {
r = term_set(tty_fd,
1, /* raw mode. */
opts.baud, /* baud rate. */
opts.parity, /* parity. */
opts.databits, /* data bits. */
opts.stopbits, /* stop bits. */
opts.flow, /* flow control. */
1, /* local or modem */
!opts.noreset); /* hup-on-close. */
}
if ( r < 0 )
fatal("failed to add port: %s", term_strerror(term_errno, errno));
/* Set DTR and RTS status, as quickly as possible after opening
the serial port (i.e. before configuring it) */
set_dtr_rts();
r = term_apply(tty_fd, 0);
if ( r < 0 )
fatal("failed to config port: %s",
term_strerror(term_errno, errno));
/* Set DTR and RTS status *again* after configuring the port. On
some systems term_apply() resets the status of DTR and / or
RTS */
set_dtr_rts();
set_tty_write_sz(term_get_baudrate(tty_fd, NULL));
/* Check for settings mismatch and print warning */
if ( !opts.quiet && !opts.noinit && show_status(1) != 0 ) {
pinfo("!! Settings mismatch !!");
if ( ! opts.noescape )
pinfo(" Type [C-%c] [C-%c] to see actual port settings",
KEYC(opts.escape), KEYC(KEY_STATUS));
pinfo("\r\n");
}
if ( ! opts.exit ) {
if ( isatty(STI) ) {
r = term_add(STI);
if ( r < 0 )
fatal("failed to add I/O device: %s",
term_strerror(term_errno, errno));
term_set_raw(STI);
r = term_apply(STI, 0);
if ( r < 0 )
fatal("failed to set I/O device to raw mode: %s",
term_strerror(term_errno, errno));
} else {
pinfo("!! STDIN is not a TTY !! Continue anyway...\r\n");
}
} else {
close(STI);
}
#ifdef LINENOISE
init_history();
#endif
/* Allocate output buffer with initial size */
tty_q.buff = calloc(TTY_Q_SZ_MIN, sizeof(*tty_q.buff));
if ( ! tty_q.buff )
fatal("out of memory");
tty_q.sz = TTY_Q_SZ_MIN;
tty_q.len = 0;
/* Prime output buffer with initstring */
if ( opts.initstring ) {
if ( opts.noinit ) {
pinfo("Ignoring init-string (--noinit)\r\n");
} else {
int l;
l = strlen(opts.initstring);
if ( tty_q_push(opts.initstring, l) != l ) {
fatal("initstring too long!");
}
}
}
/* Free initstirng, no longer needed */
if ( opts.initstring ) {
free(opts.initstring);
opts.initstring = NULL;
}
#ifndef NO_HELP
if ( ! opts.noescape ) {
pinfo("Type [C-%c] [C-%c] to see available commands\r\n",
KEYC(opts.escape), KEYC(KEY_HELP));
}
#endif
pinfo("Terminal ready\r\n");
/* Enter main processing loop */
ler = loop();
/* Terminating picocom */
pinfo("\r\n");
pinfo("Terminating...\r\n");
if ( ler == LE_CMD || ler == LE_SIGNAL )
cleanup(0 /* drain */, opts.noreset, opts.hangup);
else
cleanup(1 /* drain */, opts.noreset, opts.hangup);
if ( ler == LE_SIGNAL ) {
pinfo("Picocom was killed\r\n");
xcode = EXIT_FAILURE;
} else
pinfo("Thanks for using picocom\r\n");
return xcode;
}
/**********************************************************************/
/*
* Local Variables:
* mode:c
* tab-width: 4
* c-basic-offset: 4
* End:
*/