diff options
Diffstat (limited to '')
| -rw-r--r-- | src/watch.c | 1045 |
1 files changed, 1045 insertions, 0 deletions
diff --git a/src/watch.c b/src/watch.c new file mode 100644 index 0000000..5c159a9 --- /dev/null +++ b/src/watch.c @@ -0,0 +1,1045 @@ +/* + * watch - execute a program repeatedly, displaying output fullscreen + * + * Copyright © 2010-2023 Jim Warner <james.warner@comcast.net> + * Copyright © 2015-2023 Craig Small <csmall@dropbear.xyz> + * Copyright © 2011-2012 Sami Kerola <kerolasa@iki.fi> + * Copyright © 2002-2007 Albert Cahalan + * Copyright © 1999 Mike Coleman <mkc@acm.org>. + * + * Based on the original 1991 'watch' by Tony Rems <rembo@unisoft.com> + * (with mods and corrections by Francois Pinard). + * + * stderr handling, exec, and beep option added by Morty Abzug, 2008 + * Unicode Support added by Jarrod Lowe <procps@rrod.net> in 2009. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "c.h" +#include "config.h" +#include "fileutils.h" +#include "nls.h" +#include "strutils.h" +#include "xalloc.h" +#include <ctype.h> +#include <errno.h> +#include <getopt.h> +#include <locale.h> +#include <limits.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <sys/wait.h> +#include <termios.h> +#include <time.h> +#include <unistd.h> +#ifdef WITH_WATCH8BIT +# define _XOPEN_SOURCE_EXTENDED 1 +# include <wchar.h> +# include <wctype.h> +# include <ncursesw/ncurses.h> +#else +# include <ncurses.h> +#endif /* WITH_WATCH8BIT */ + +#ifdef FORCE_8BIT +# undef isprint +# define isprint(x) ( (x>=' '&&x<='~') || (x>=0xa0) ) +#endif + +/* Boolean command line options */ +static int flags; +#define WATCH_DIFF (1 << 1) +#define WATCH_CUMUL (1 << 2) +#define WATCH_EXEC (1 << 3) +#define WATCH_BEEP (1 << 4) +#define WATCH_COLOR (1 << 5) +#define WATCH_ERREXIT (1 << 6) +#define WATCH_CHGEXIT (1 << 7) +#define WATCH_EQUEXIT (1 << 8) +#define WATCH_NORERUN (1 << 9) + +static int curses_started = 0; +static long height = 24, width = 80; +static int screen_size_changed = 0; +static int first_screen = 1; +static int show_title = 2; /* number of lines used, 2 or 0 */ +static int precise_timekeeping = 0; +static int line_wrap = 1; + +#define min(x,y) ((x) > (y) ? (y) : (x)) +#define MAX_ANSIBUF 100 + +static void __attribute__ ((__noreturn__)) + usage(FILE * out) +{ + fputs(USAGE_HEADER, out); + fprintf(out, + _(" %s [options] command\n"), program_invocation_short_name); + fputs(USAGE_OPTIONS, out); + fputs(_(" -b, --beep beep if command has a non-zero exit\n"), out); + fputs(_(" -c, --color interpret ANSI color and style sequences\n"), out); + fputs(_(" -C, --no-color do not interpret ANSI color and style sequences\n"), out); + fputs(_(" -d, --differences[=<permanent>]\n" + " highlight changes between updates\n"), out); + fputs(_(" -e, --errexit exit if command has a non-zero exit\n"), out); + fputs(_(" -g, --chgexit exit when output from command changes\n"), out); + fputs(_(" -q, --equexit <cycles>\n" + " exit when output from command does not change\n"), out); + fputs(_(" -n, --interval <secs> seconds to wait between updates\n"), out); + fputs(_(" -p, --precise attempt run command in precise intervals\n"), out); + fputs(_(" -r, --no-rerun do not rerun program on window resize\n"), out); + fputs(_(" -t, --no-title turn off header\n"), out); + fputs(_(" -w, --no-wrap turn off line wrapping\n"), out); + fputs(_(" -x, --exec pass command to exec instead of \"sh -c\"\n"), out); + fputs(USAGE_SEPARATOR, out); + fputs(USAGE_HELP, out); + fputs(_(" -v, --version output version information and exit\n"), out); + fprintf(out, USAGE_MAN_TAIL("watch(1)")); + + exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS); +} + +static int nr_of_colors; +static int attributes; +static int fg_col; +static int bg_col; +static int more_colors; + + +static void reset_ansi(void) +{ + attributes = A_NORMAL; + fg_col = 0; + bg_col = 0; +} + +static void init_ansi_colors(void) +{ + short ncurses_colors[] = { + -1, COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, + COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE + }; + nr_of_colors = sizeof(ncurses_colors) / sizeof(short); + + more_colors = (COLORS >= 16) && (COLOR_PAIRS >= 16 * 16); + + // Initialize ncurses colors. -1 is terminal default + // 0-7 are auto created standard colors initialized by ncurses + if (more_colors) { + // Initialize using ANSI SGR 8-bit specified colors + // 8-15 are bright colors + init_color(8, 333, 333, 333); // Bright black + init_color(9, 1000, 333, 333); // Bright red + init_color(10, 333, 1000, 333); // Bright green + init_color(11, 1000, 1000, 333); // Bright yellow + init_color(12, 333, 333, 1000); // Bright blue + init_color(13, 1000, 333, 1000); // Bright magenta + init_color(14, 333, 1000, 1000); // Bright cyan + // Often ncurses is built with only 256 colors, so lets + // stop here - so we can support the -1 terminal default + //init_color(15, 1000, 1000, 1000); // Bright white + nr_of_colors += 7; + } + + // Initialize all color pairs with ncurses + for (bg_col = 0; bg_col < nr_of_colors; bg_col++) + for (fg_col = 0; fg_col < nr_of_colors; fg_col++) + init_pair(bg_col * nr_of_colors + fg_col + 1, fg_col - 1, bg_col - 1); + + reset_ansi(); +} + + +static int process_ansi_color_escape_sequence(char** escape_sequence) { + // process SGR ANSI color escape sequence + // Eg 8-bit + // 38;5;⟨n⟩ (set fg color to n) + // 48;5;⟨n⟩ (set bg color to n) + // + // Eg 24-bit (not yet implemented) + // ESC[ 38;2;⟨r⟩;⟨g⟩;⟨b⟩ m Select RGB foreground color + // ESC[ 48;2;⟨r⟩;⟨g⟩;⟨b⟩ m Select RGB background color + int num; + + if (!escape_sequence) + return 0; /* avoid NULLPTR dereference, return "not understood" */ + + if ((*escape_sequence)[0] != ';') + return 0; /* not understood */ + + if ((*escape_sequence)[1] == '5') { + // 8 bit! ANSI specifies a predefined set of 256 colors here. + if ((*escape_sequence)[2] != ';') + return 0; /* not understood */ + num = strtol((*escape_sequence) + 3, escape_sequence, 10); + if (num >= 0 && num <= 7) { + // 0-7 are standard colors same as SGR 30-37 + return num + 1; + } + if (num >= 8 && num <= 15) { + // 8-15 are standard colors same as SGR 90-97 + return more_colors ? num + 1 : num - 8 + 1; + } + + // Remainder aren't yet implemented + // 16-231: 6 × 6 × 6 cube (216 colors): 16 + 36 × r + 6 × g + b (0 ≤ r, g, b ≤ 5) + // 232-255: grayscale from black to white in 24 steps + } + + return 0; /* not understood */ +} + + +static int set_ansi_attribute(const int attrib, char** escape_sequence) +{ + switch (attrib) { + case -1: /* restore last settings */ + break; + case 0: /* restore default settings */ + reset_ansi(); + break; + case 1: /* set bold / increased intensity */ + attributes |= A_BOLD; + break; + case 2: /* set decreased intensity (if supported) */ + attributes |= A_DIM; + break; +#ifdef A_ITALIC + case 3: /* set italic (if supported) */ + attributes |= A_ITALIC; + break; +#endif + case 4: /* set underline */ + attributes |= A_UNDERLINE; + break; + case 5: /* set blinking */ + attributes |= A_BLINK; + break; + case 7: /* set inversed */ + attributes |= A_REVERSE; + break; + case 21: /* unset bold / increased intensity */ + attributes &= ~A_BOLD; + break; + case 22: /* unset bold / any intensity modifier */ + attributes &= ~(A_BOLD | A_DIM); + break; +#ifdef A_ITALIC + case 23: /* unset italic */ + attributes &= ~A_ITALIC; + break; +#endif + case 24: /* unset underline */ + attributes &= ~A_UNDERLINE; + break; + case 25: /* unset blinking */ + attributes &= ~A_BLINK; + break; + case 27: /* unset inversed */ + attributes &= ~A_REVERSE; + break; + case 38: + fg_col = process_ansi_color_escape_sequence(escape_sequence); + if (fg_col == 0) { + return 0; /* not understood */ + } + break; + case 39: + fg_col = 0; + break; + case 48: + bg_col = process_ansi_color_escape_sequence(escape_sequence); + if (bg_col == 0) { + return 0; /* not understood */ + } + break; + case 49: + bg_col = 0; + break; + default: + if (attrib >= 30 && attrib <= 37) { /* set foreground color */ + fg_col = attrib - 30 + 1; + } else if (attrib >= 40 && attrib <= 47) { /* set background color */ + bg_col = attrib - 40 + 1; + } else if (attrib >= 90 && attrib <= 97) { /* set bright fg color */ + fg_col = more_colors ? attrib - 90 + 9 : attrib - 90 + 1; + } else if (attrib >= 100 && attrib <= 107) { /* set bright bg color */ + bg_col = more_colors ? attrib - 100 + 9 : attrib - 100 + 1; + } else { + return 0; /* Not understood */ + } + } + attr_set(attributes, bg_col * nr_of_colors + fg_col + 1, NULL); + return 1; +} + +static void process_ansi(FILE * fp) +{ + int i, c; + char buf[MAX_ANSIBUF]; + char *numstart, *endptr = buf; + int ansi_attribute; + + c = getc(fp); + + if (c == '(') { + c = getc(fp); + c = getc(fp); + } + if (c != '[') { + ungetc(c, fp); + return; + } + for (i = 0; i < MAX_ANSIBUF; i++) { + c = getc(fp); + /* COLOUR SEQUENCE ENDS in 'm' */ + if (c == 'm') { + buf[i] = '\0'; + break; + } + if ((c < '0' || c > '9') && c != ';') { + return; + } + buf[i] = (char)c; + } + /* + * buf now contains a semicolon-separated list of decimal integers, + * each indicating an attribute to apply. + * For example, buf might contain "0;1;31", derived from the color + * escape sequence "<ESC>[0;1;31m". There can be 1 or more + * attributes to apply, but typically there are between 1 and 3. + */ + + /* Special case of <ESC>[m */ + if (buf[0] == '\0') + set_ansi_attribute(0, NULL); + + for (endptr = numstart = buf; *endptr != '\0'; numstart = endptr + 1) { + ansi_attribute = strtol(numstart, &endptr, 10); + if (!set_ansi_attribute(ansi_attribute, &endptr)) + break; + if (numstart == endptr) + set_ansi_attribute(0, NULL); /* [m treated as [0m */ + } +} + +static void __attribute__ ((__noreturn__)) do_exit(int status) +{ + if (curses_started) + endwin(); + exit(status); +} + +/* signal handler */ +static void die(int notused __attribute__ ((__unused__))) +{ + do_exit(EXIT_SUCCESS); +} + +static void winch_handler(int notused __attribute__ ((__unused__))) +{ + screen_size_changed = 1; +} + +static char env_col_buf[24]; +static char env_row_buf[24]; +static int incoming_cols; +static int incoming_rows; + +static void get_terminal_size(void) +{ + struct winsize w; + if (!incoming_cols) { + /* have we checked COLUMNS? */ + const char *s = getenv("COLUMNS"); + incoming_cols = -1; + if (s && *s) { + long t; + char *endptr; + t = strtol(s, &endptr, 0); + if (!*endptr && 0 < t) + incoming_cols = t; + width = incoming_cols; + snprintf(env_col_buf, sizeof env_col_buf, "COLUMNS=%ld", + width); + putenv(env_col_buf); + } + } + if (!incoming_rows) { + /* have we checked LINES? */ + const char *s = getenv("LINES"); + incoming_rows = -1; + if (s && *s) { + long t; + char *endptr; + t = strtol(s, &endptr, 0); + if (!*endptr && 0 < t) + incoming_rows = t; + height = incoming_rows; + snprintf(env_row_buf, sizeof env_row_buf, "LINES=%ld", + height); + putenv(env_row_buf); + } + } + if (ioctl(STDERR_FILENO, TIOCGWINSZ, &w) == 0) { + if (incoming_cols < 0 || incoming_rows < 0) { + if (incoming_rows < 0 && w.ws_row > 0) { + height = w.ws_row; + snprintf(env_row_buf, sizeof env_row_buf, + "LINES=%ld", height); + putenv(env_row_buf); + } + if (incoming_cols < 0 && w.ws_col > 0) { + width = w.ws_col; + snprintf(env_col_buf, sizeof env_col_buf, + "COLUMNS=%ld", width); + putenv(env_col_buf); + } + } + } +} + +/* get current time in usec */ +typedef unsigned long long watch_usec_t; +#define USECS_PER_SEC (1000000ull) +static watch_usec_t get_time_usec() +{ + struct timeval now; + gettimeofday(&now, NULL); + return USECS_PER_SEC * now.tv_sec + now.tv_usec; +} + +#ifdef WITH_WATCH8BIT +/* read a wide character from a popen'd stream */ +#define MAX_ENC_BYTES 16 +wint_t my_getwc(FILE * s); +wint_t my_getwc(FILE * s) +{ + /* assuming no encoding ever consumes more than 16 bytes */ + char i[MAX_ENC_BYTES]; + int byte = 0; + int convert; + wchar_t rval; + while (1) { + i[byte] = getc(s); + if (i[byte] == EOF) { + return WEOF; + } + byte++; + errno = 0; + mbtowc(NULL, NULL, 0); + convert = mbtowc(&rval, i, byte); + if (convert > 0) { + /* legal conversion */ + return rval; + } + if (byte == MAX_ENC_BYTES) { + while (byte > 1) { + /* at least *try* to fix up */ + ungetc(i[--byte], s); + } + errno = -EILSEQ; + return WEOF; + } + } +} +#endif /* WITH_WATCH8BIT */ + +#ifdef WITH_WATCH8BIT +static void output_header(wchar_t *restrict wcommand, int wcommand_characters, double interval) +#else +static void output_header(char *restrict command, double interval) +#endif /* WITH_WATCH8BIT */ +{ + time_t t = time(NULL); + char *ts = ctime(&t); + char *header; + char *right_header; + int max_host_name_len = (int) sysconf(_SC_HOST_NAME_MAX); + char hostname[max_host_name_len + 1]; + int command_columns = 0; /* not including final \0 */ + + gethostname(hostname, sizeof(hostname)); + + /* + * left justify interval and command, right justify hostname and time, + * clipping all to fit window width + */ + int hlen = asprintf(&header, _("Every %.1fs: "), interval); + int rhlen = asprintf(&right_header, _("%s: %s"), hostname, ts); + + /* + * the rules: + * width < rhlen : print nothing + * width < rhlen + hlen + 1: print hostname, ts + * width = rhlen + hlen + 1: print header, hostname, ts + * width < rhlen + hlen + 4: print header, ..., hostname, ts + * width < rhlen + hlen + wcommand_columns: print header, + * truncated wcommand, ..., hostname, ts + * width > "": print header, wcomand, hostname, ts + * this is slightly different from how it used to be + */ + if (width < rhlen) { + free(header); + free(right_header); + return; + } + if (rhlen + hlen + 1 <= width) { + mvaddstr(0, 0, header); + if (rhlen + hlen + 2 <= width) { + if (width < rhlen + hlen + 4) { + mvaddstr(0, width - rhlen - 4, "... "); + } else { +#ifdef WITH_WATCH8BIT + command_columns = wcswidth(wcommand, -1); + if (width < rhlen + hlen + command_columns) { + /* print truncated */ + int available = width - rhlen - hlen; + int in_use = command_columns; + int wcomm_len = wcommand_characters; + while (available - 4 < in_use) { + wcomm_len--; + in_use = wcswidth(wcommand, wcomm_len); + } + mvaddnwstr(0, hlen, wcommand, wcomm_len); + mvaddstr(0, width - rhlen - 4, "... "); + } else { + mvaddwstr(0, hlen, wcommand); + } +#else + command_columns = strlen(command); + if (width < rhlen + hlen + command_columns) { + /* print truncated */ + mvaddnstr(0, hlen, command, width - rhlen - hlen - 4); + mvaddstr(0, width - rhlen - 4, "... "); + } else { + mvaddnstr(0, hlen, command, width - rhlen - hlen); + } +#endif /* WITH_WATCH8BIT */ + } + } + } + mvaddstr(0, width - rhlen + 1, right_header); + free(header); + free(right_header); + return; +} + +static void find_eol(FILE *p) +{ + int c; +#ifdef WITH_WATCH8BIT + do { + c = my_getwc(p); + } while (c != WEOF + && c!= L'\n'); +#else + do { + c = getc(p); + } while (c != EOF + && c != '\n'); +#endif /* WITH_WATCH8BIT */ +} + +static int run_command(char *restrict command, char **restrict command_argv) +{ + FILE *p; + int x, y; + int oldeolseen = 1; + int pipefd[2]; + pid_t child; + int exit_early = 0; + int buffer_size = 0; + int unchanged_buffer = 0; + int status; + + /* allocate pipes */ + if (pipe(pipefd) < 0) + xerr(7, _("unable to create IPC pipes")); + + /* flush stdout and stderr, since we're about to do fd stuff */ + fflush(stdout); + fflush(stderr); + + /* fork to prepare to run command */ + child = fork(); + + if (child < 0) { /* fork error */ + xerr(2, _("unable to fork process")); + } else if (child == 0) { /* in child */ + close(pipefd[0]); /* child doesn't need read side of pipe */ + close(1); /* prepare to replace stdout with pipe */ + if (dup2(pipefd[1], 1) < 0) { /* replace stdout with write side of pipe */ + xerr(3, _("dup2 failed")); + } + close(pipefd[1]); /* once duped, the write fd isn't needed */ + dup2(1, 2); /* stderr should default to stdout */ + + if (flags & WATCH_EXEC) { /* pass command to exec instead of system */ + if (execvp(command_argv[0], command_argv) == -1) { + xerr(4, _("unable to execute '%s'"), + command_argv[0]); + } + } else { + status = system(command); /* watch manpage promises sh quoting */ + /* propagate command exit status as child exit status */ + if (!WIFEXITED(status)) { /* child exits nonzero if command does */ + exit(EXIT_FAILURE); + } else { + exit(WEXITSTATUS(status)); + } + } + } + + /* otherwise, we're in parent */ + close(pipefd[1]); /* close write side of pipe */ + if ((p = fdopen(pipefd[0], "r")) == NULL) + xerr(5, _("fdopen")); + + reset_ansi(); + for (y = show_title; y < height; y++) { + int eolseen = 0, tabpending = 0, tabwaspending = 0; + if (flags & WATCH_COLOR) + set_ansi_attribute(-1, NULL); +#ifdef WITH_WATCH8BIT + wint_t carry = WEOF; +#endif + for (x = 0; x < width; x++) { +#ifdef WITH_WATCH8BIT + wint_t c = ' '; +#else + int c = ' '; +#endif + int attr = 0; + + if (tabwaspending && (flags & WATCH_COLOR)) + set_ansi_attribute(-1, NULL); + tabwaspending = 0; + + if (!eolseen) { + /* if there is a tab pending, just + * spit spaces until the next stop + * instead of reading characters */ + if (!tabpending) +#ifdef WITH_WATCH8BIT + do { + if (carry == WEOF) { + c = my_getwc(p); + } else { + c = carry; + carry = WEOF; + } + } while (c != WEOF && !iswprint(c) + && c < 128 + && wcwidth(c) == 0 + && c != L'\a' + && c != L'\n' + && c != L'\t' + && (c != L'\033' + || !(flags & WATCH_COLOR))); +#else + do + c = getc(p); + while (c != EOF && !isprint(c) + && c != '\a' + && c != '\n' + && c != '\t' + && (c != L'\033' + || !(flags & WATCH_COLOR))); +#endif + if (c == L'\033' && (flags & WATCH_COLOR)) { + x--; + process_ansi(p); + continue; + } + if (c == L'\n') + if (!oldeolseen && x == 0) { + x = -1; + continue; + } else + eolseen = 1; + else if (c == L'\t') + tabpending = 1; + else if (c == L'\a') { + beep(); + continue; + } +#ifdef WITH_WATCH8BIT + if (x == width - 1 && wcwidth(c) == 2) { + y++; + x = -1; /* process this double-width */ + carry = c; /* character on the next line */ + continue; /* because it won't fit here */ + } + if (c == WEOF || c == L'\n' || c == L'\t') { + c = L' '; + if (flags & WATCH_COLOR) + attrset(A_NORMAL); + } +#else + if (c == EOF || c == '\n' || c == '\t') { + c = ' '; + if (flags & WATCH_COLOR) + attrset(A_NORMAL); + } +#endif + if (tabpending && (((x + 1) % 8) == 0)) { + tabpending = 0; + tabwaspending = 1; + } + } + move(y, x); + + if (!first_screen && !exit_early && (flags & WATCH_CHGEXIT)) { +#ifdef WITH_WATCH8BIT + cchar_t oldc; + in_wch(&oldc); + exit_early = (wchar_t) c != oldc.chars[0]; +#else + chtype oldch = inch(); + unsigned char oldc = oldch & A_CHARTEXT; + exit_early = (unsigned char)c != oldc; +#endif + } + if (!first_screen && !exit_early && (flags & WATCH_EQUEXIT)) { + buffer_size++; +#ifdef WITH_WATCH8BIT + cchar_t oldc; + in_wch(&oldc); + if ((wchar_t) c == oldc.chars[0]) + unchanged_buffer++; +#else + chtype oldch = inch(); + unsigned char oldc = oldch & A_CHARTEXT; + if ((unsigned char)c == oldc) + unchanged_buffer++; +#endif + } + if (flags & WATCH_DIFF) { +#ifdef WITH_WATCH8BIT + cchar_t oldc; + in_wch(&oldc); + attr = !first_screen + && ((wchar_t) c != oldc.chars[0] + || + ((flags & WATCH_CUMUL) + && (oldc.attr & A_ATTRIBUTES))); +#else + chtype oldch = inch(); + unsigned char oldc = oldch & A_CHARTEXT; + attr = !first_screen + && ((unsigned char)c != oldc + || + ((flags & WATCH_CUMUL) + && (oldch & A_ATTRIBUTES))); +#endif + } + if (attr) + standout(); +#ifdef WITH_WATCH8BIT + addnwstr((wchar_t *) & c, 1); +#else + addch(c); +#endif + if (attr) + standend(); +#ifdef WITH_WATCH8BIT + if (wcwidth(c) == 0) { + x--; + } + if (wcwidth(c) == 2) { + x++; + } +#endif + } + oldeolseen = eolseen; + if (!line_wrap) { + reset_ansi(); + if (flags & WATCH_COLOR) + attrset(A_NORMAL); + } + if (!line_wrap && !eolseen) + { + find_eol(p); + } + } + + fclose(p); + + /* harvest child process and get status, propagated from command */ + if (waitpid(child, &status, 0) < 0) + xerr(8, _("waitpid")); + + /* if child process exited in error, beep if option_beep is set */ + if ((!WIFEXITED(status) || WEXITSTATUS(status))) { + if (flags & WATCH_BEEP) + beep(); + if (flags & WATCH_ERREXIT) { + mvaddstr(height - 1, 0, + _("command exit with a non-zero status, press a key to exit")); + refresh(); + fgetc(stdin); + endwin(); + exit(8); + } + } + + if (unchanged_buffer == buffer_size && (flags & WATCH_EQUEXIT)) + exit_early = 1; + + first_screen = 0; + refresh(); + return exit_early; +} + +int main(int argc, char *argv[]) +{ + int optc; + double interval = 2; + int max_cycles = 1; + int cycle_count = 0; + char *interval_string; + char *command; + char **command_argv; + int command_length = 0; /* not including final \0 */ + watch_usec_t last_run = 0; + watch_usec_t next_loop = 0; /* next loop time in us, used for precise time + * keeping only */ +#ifdef WITH_WATCH8BIT + wchar_t *wcommand = NULL; + int wcommand_characters = 0; /* not including final \0 */ +#endif /* WITH_WATCH8BIT */ + +#ifdef WITH_COLORWATCH + flags |= WATCH_COLOR; +#endif /* WITH_COLORWATCH */ + + static struct option longopts[] = { + {"color", no_argument, 0, 'c'}, + {"no-color", no_argument, 0, 'C'}, + {"differences", optional_argument, 0, 'd'}, + {"help", no_argument, 0, 'h'}, + {"interval", required_argument, 0, 'n'}, + {"beep", no_argument, 0, 'b'}, + {"errexit", no_argument, 0, 'e'}, + {"chgexit", no_argument, 0, 'g'}, + {"equexit", required_argument, 0, 'q'}, + {"exec", no_argument, 0, 'x'}, + {"precise", no_argument, 0, 'p'}, + {"no-rerun", no_argument, 0, 'r'}, + {"no-title", no_argument, 0, 't'}, + {"no-wrap", no_argument, 0, 'w'}, + {"version", no_argument, 0, 'v'}, + {0, 0, 0, 0} + }; + +#ifdef HAVE_PROGRAM_INVOCATION_NAME + program_invocation_name = program_invocation_short_name; +#endif + setlocale(LC_ALL, ""); + bindtextdomain(PACKAGE, LOCALEDIR); + textdomain(PACKAGE); + atexit(close_stdout); + + interval_string = getenv("WATCH_INTERVAL"); + if(interval_string != NULL) + interval = strtod_nol_or_err(interval_string, _("Could not parse interval from WATCH_INTERVAL")); + + while ((optc = + getopt_long(argc, argv, "+bCced::ghq:n:prtwvx", longopts, (int *)0)) + != EOF) { + switch (optc) { + case 'b': + flags |= WATCH_BEEP; + break; + case 'c': + flags |= WATCH_COLOR; + break; + case 'C': + flags &= ~WATCH_COLOR; + break; + case 'd': + flags |= WATCH_DIFF; + if (optarg) + flags |= WATCH_CUMUL; + break; + case 'e': + flags |= WATCH_ERREXIT; + break; + case 'g': + flags |= WATCH_CHGEXIT; + break; + case 'q': + flags |= WATCH_EQUEXIT; + max_cycles = strtod_nol_or_err(optarg, _("failed to parse argument")); + break; + case 'r': + flags |= WATCH_NORERUN; + break; + case 't': + show_title = 0; + break; + case 'w': + line_wrap = 0; + break; + case 'x': + flags |= WATCH_EXEC; + break; + case 'n': + interval = strtod_nol_or_err(optarg, _("failed to parse argument")); + break; + case 'p': + precise_timekeeping = 1; + break; + case 'h': + usage(stdout); + break; + case 'v': + printf(PROCPS_NG_VERSION); + return EXIT_SUCCESS; + default: + usage(stderr); + break; + } + } + + if (interval < 0.1) + interval = 0.1; + if (interval > UINT_MAX) + interval = UINT_MAX; + + if (optind >= argc) + usage(stderr); + + /* save for later */ + command_argv = &(argv[optind]); + + command = xstrdup(argv[optind++]); + command_length = strlen(command); + for (; optind < argc; optind++) { + char *endp; + int s = strlen(argv[optind]); + /* space and \0 */ + command = xrealloc(command, command_length + s + 2); + endp = command + command_length; + *endp = ' '; + memcpy(endp + 1, argv[optind], s); + /* space then string length */ + command_length += 1 + s; + command[command_length] = '\0'; + } + +#ifdef WITH_WATCH8BIT + /* convert to wide for printing purposes */ + /*mbstowcs(NULL, NULL, 0); */ + wcommand_characters = mbstowcs(NULL, command, 0); + if (wcommand_characters < 0) { + fprintf(stderr, _("unicode handling error\n")); + exit(EXIT_FAILURE); + } + wcommand = + (wchar_t *) malloc((wcommand_characters + 1) * sizeof(wcommand)); + if (wcommand == NULL) { + fprintf(stderr, _("unicode handling error (malloc)\n")); + exit(EXIT_FAILURE); + } + mbstowcs(wcommand, command, wcommand_characters + 1); +#endif /* WITH_WATCH8BIT */ + + get_terminal_size(); + + /* Catch keyboard interrupts so we can put tty back in a sane + * state. */ + signal(SIGINT, die); + signal(SIGTERM, die); + signal(SIGHUP, die); + signal(SIGWINCH, winch_handler); + + /* Set up tty for curses use. */ + curses_started = 1; + initscr(); + if (flags & WATCH_COLOR) { + if (has_colors()) { + start_color(); + use_default_colors(); + init_ansi_colors(); + } else { + flags &= ~WATCH_COLOR; + } + } + nonl(); + noecho(); + cbreak(); + + if (precise_timekeeping) + next_loop = get_time_usec(); + + while (1) { + if (screen_size_changed) { + get_terminal_size(); + resizeterm(height, width); + clear(); + /* redrawwin(stdscr); */ + screen_size_changed = 0; + first_screen = 1; + } + + if (show_title) +#ifdef WITH_WATCH8BIT + output_header(wcommand, wcommand_characters, interval); +#else + output_header(command, interval); +#endif /* WITH_WATCH8BIT */ + + if (!(flags & WATCH_NORERUN) || + get_time_usec() - last_run > interval * USECS_PER_SEC) { + last_run = get_time_usec(); + int exit = run_command(command, command_argv); + + if (flags & WATCH_EQUEXIT) { + if (cycle_count == max_cycles && exit) { + break; + } else if (exit) { + cycle_count++; + } else { + cycle_count = 0; + } + } else if (exit) { + break; + } + } else { + refresh(); + } + + if (precise_timekeeping) { + watch_usec_t cur_time = get_time_usec(); + next_loop += USECS_PER_SEC * interval; + if (cur_time < next_loop) + usleep(next_loop - cur_time); + } else + if (interval < UINT_MAX / USECS_PER_SEC) + usleep(interval * USECS_PER_SEC); + else + sleep(interval); + } + + endwin(); + return EXIT_SUCCESS; +} |