termdesc.c File Reference

#include <fcntl.h>
#include <unistd.h>
#include <curses.h>
#include "internal.h"
#include "windows.h"
#include "linux.h"

Include dependency graph for termdesc.c:

Go to the source code of this file.

Macros
#define	TRIDEVATTR   "\x1b[=c"
#define	PRIDEVATTR   "\x1b[c"
#define	XTVERSION   "\x1b[>0q"
#define	XTGETTCAP   "\x1bP+q544e;524742;687061\x1b\\"
#define	SECDEVATTR   "\x1b[>c"
#define	KITTYQUERY   "\x1b_Gi=1,a=q;\x1b\\"
#define	KKBDSUPPORT   "\x1b[=27u"
#define	KKBDQUERY   "\x1b[?u"
#define	XTMODKEYS   "\x1b[>2;1m\x1b[>4;2m"
#define	IDQUERIES
#define	DEFBGQ   "\x1b]11;?\e\\"
#define	DEFFGQ   "\x1b]10;?\e\\"
#define	DSRCPR   "\x1b[6n"
#define	SUMQUERY   "\x1b[?2026$p"
#define	PIXELMOUSEQUERY   "\x1b[?1016$p"
#define	CREGSXTSM   "\x1b[?2;1;0S"
#define	GEOMXTSM   "\x1b[?1;1;0S"
#define	GEOMPIXEL   "\x1b[14t"
#define	GEOMCELL   "\x1b[18t"
#define	DIRECTIVES
#define	KKEYBOARD_PUSH   "\x1b[>u"
#define	KKBDENTER   KKEYBOARD_PUSH KKBDSUPPORT
#define	SMCUP   DECSET(SET_SMCUP)
#define	RMCUP   DECRST(SET_SMCUP)
#define	PQUERYBUFLEN   4096
#define	ENVVAR   "TERM"

Functions
int	grow_esc_table (tinfo *ti, const char *tstr, escape_e esc, size_t *tlen, size_t *tused)
void	free_terminfo_cache (tinfo *ti)
int	enter_alternate_screen (int fd, FILE *ttyfp, tinfo *ti, unsigned drain)
int	leave_alternate_screen (int fd, FILE *fp, tinfo *ti, unsigned drain)
int	interrogate_terminfo (tinfo *ti, FILE *out, unsigned utf8, unsigned noaltscreen, unsigned nocbreak, unsigned nonewfonts, int *cursor_y, int *cursor_x, ncsharedstats *stats, int lmargin, int tmargin, int rmargin, int bmargin, unsigned draininput)
char *	termdesc_longterm (const tinfo *ti)
int	locate_cursor (tinfo *ti, unsigned *cursor_y, unsigned *cursor_x)
int	tiocgwinsz (int fd, struct winsize *ws)
int	cbreak_mode (tinfo *ti)
int	putenv_term (const char *tname)

Macro Definition Documentation

CREGSXTSM

#define CREGSXTSM   "\x1b[?2;1;0S"

Definition at line 433 of file termdesc.c.

DEFBGQ

#define DEFBGQ   "\x1b]11;?\e\\"

Definition at line 414 of file termdesc.c.

DEFFGQ

#define DEFFGQ   "\x1b]10;?\e\\"

Definition at line 415 of file termdesc.c.

DIRECTIVES

#define DIRECTIVES

Value:

                   DEFFGQ \
                   DEFBGQ \
                   KKBDQUERY \
                   SUMQUERY \
                   PIXELMOUSEQUERY \
                   "\x1b[?1;3;256S" /* try to set 256 cregs */ \
                   "\x1b[?1;3;1024S" /* try to set 1024 cregs */ \
                   KITTYQUERY \
                   CREGSXTSM \
                   GEOMXTSM \
                   GEOMPIXEL \
                   GEOMCELL \
                   PRIDEVATTR

Definition at line 446 of file termdesc.c.

DSRCPR

#define DSRCPR   "\x1b[6n"

Definition at line 423 of file termdesc.c.

ENVVAR

#define ENVVAR   "TERM"

GEOMCELL

#define GEOMCELL   "\x1b[18t"

Definition at line 442 of file termdesc.c.

GEOMPIXEL

#define GEOMPIXEL   "\x1b[14t"

Definition at line 439 of file termdesc.c.

GEOMXTSM

#define GEOMXTSM   "\x1b[?1;1;0S"

Definition at line 436 of file termdesc.c.

IDQUERIES

#define IDQUERIES

Value:

                  TRIDEVATTR \
                  XTVERSION \
                  XTGETTCAP \
                  SECDEVATTR

Definition at line 405 of file termdesc.c.

KITTYQUERY

#define KITTYQUERY   "\x1b_Gi=1,a=q;\x1b\\"

Definition at line 383 of file termdesc.c.

KKBDENTER

#define KKBDENTER   KKEYBOARD_PUSH KKBDSUPPORT

Definition at line 465 of file termdesc.c.

KKBDQUERY

#define KKBDQUERY   "\x1b[?u"

Definition at line 395 of file termdesc.c.

KKBDSUPPORT

#define KKBDSUPPORT   "\x1b[=27u"

Definition at line 390 of file termdesc.c.

KKEYBOARD_PUSH

#define KKEYBOARD_PUSH   "\x1b[>u"

Definition at line 461 of file termdesc.c.

PIXELMOUSEQUERY

#define PIXELMOUSEQUERY   "\x1b[?1016$p"

Definition at line 430 of file termdesc.c.

PQUERYBUFLEN

#define PQUERYBUFLEN   4096

PRIDEVATTR

#define PRIDEVATTR   "\x1b[c"

Definition at line 351 of file termdesc.c.

RMCUP

#define RMCUP   DECRST(SET_SMCUP)

Definition at line 473 of file termdesc.c.

SECDEVATTR

#define SECDEVATTR   "\x1b[>c"

Definition at line 373 of file termdesc.c.

SMCUP

#define SMCUP   DECSET(SET_SMCUP)

Definition at line 472 of file termdesc.c.

SUMQUERY

#define SUMQUERY   "\x1b[?2026$p"

Definition at line 427 of file termdesc.c.

TRIDEVATTR

#define TRIDEVATTR   "\x1b[=c"

Definition at line 336 of file termdesc.c.

XTGETTCAP

#define XTGETTCAP   "\x1bP+q544e;524742;687061\x1b\\"

Definition at line 364 of file termdesc.c.

XTMODKEYS

#define XTMODKEYS   "\x1b[>2;1m\x1b[>4;2m"

Definition at line 400 of file termdesc.c.

XTVERSION

#define XTVERSION   "\x1b[>0q"

Definition at line 354 of file termdesc.c.

Function Documentation

cbreak_mode()

int cbreak_mode

(

tinfo *

ti

)

Definition at line 1595 of file termdesc.c.

                          {
#ifndef __MINGW32__
  int ttyfd = ti->ttyfd;
  if(ttyfd < 0){
    return 0;
  }
  // assume it's not a true terminal (e.g. we might be redirected to a file)
  struct termios modtermios;
  memcpy(&modtermios, ti->tpreserved, sizeof(modtermios));
  // see termios(3). disabling ECHO and ICANON means input will not be echoed
  // to the screen, input is made available without enter-based buffering, and
  // line editing is disabled. since we have not gone into raw mode, ctrl+c
  // etc. still have their typical effects. ICRNL maps return to 13 (Ctrl+M)
  // instead of 10 (Ctrl+J).
  modtermios.c_lflag &= (~ECHO & ~ICANON);
  modtermios.c_iflag &= ~ICRNL;
  if(tcsetattr(ttyfd, TCSANOW, &modtermios)){
    logerror("error disabling echo / canonical on %d (%s)", ttyfd, strerror(errno));
    return -1;
  }
#else
  // we don't yet have a way to take Cygwin/MSYS2 out of canonical mode FIXME.
  DWORD mode;
  if(!GetConsoleMode(ti->inhandle, &mode)){
    logerror("error acquiring input mode");
    return -1;
  }
  mode &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT);
  if(!SetConsoleMode(ti->inhandle, mode)){
    logerror("error setting input mode");
    return -1;
  }
#endif
  return 0;
}

Here is the caller graph for this function:

enter_alternate_screen()

int enter_alternate_screen	(	int	fd,
		FILE *	ttyfp,
		tinfo *	ti,
		unsigned	drain
	)

Definition at line 559 of file termdesc.c.

                                                                          {
  if(ti->in_alt_screen){
    return 0;
  }
  const char* popcolors = get_escape(ti, ESCAPE_RESTORECOLORS);
  if(popcolors){
    if(term_emit(popcolors, ttyfp, true)){
      return -1;
    }
  }
  const char* smcup = get_escape(ti, ESCAPE_SMCUP);
  if(smcup == NULL){
    logerror("alternate screen is unavailable");
    return -1;
  }
  if(!drain){
    if(ti->kbdlevel){
      if(tty_emit(KKEYBOARD_POP, fd)){
        return -1;
      }
    }else{
      if(tty_emit(XTMODKEYSUNDO, fd)){
        return -1;
      }
    }
  }
  if(tty_emit(smcup, fd) < 0){
    return -1;
  }
  if(!drain){
    if(ti->kbdlevel){
      if(tty_emit(KKBDENTER, fd)){
        return -1;
      }
    }else{
      if(tty_emit(XTMODKEYS, fd)){
        return -1;
      }
    }
  }
  const char* pushcolors = get_escape(ti, ESCAPE_SAVECOLORS);
  if(pushcolors){
    if(term_emit(pushcolors, ttyfp, true)){
      return -1;
    }
  }
  ti->in_alt_screen = true;
  return 0;
}

Here is the caller graph for this function:

free_terminfo_cache()

void free_terminfo_cache

(

tinfo *

ti

)

Definition at line 197 of file termdesc.c.

                                   {
  stop_inputlayer(ti);
  loginfo("brought down input layer");
  if(ti->pixel_cleanup){
    ti->pixel_cleanup(ti);
  }
  free(ti->termversion);
  free(ti->esctable);
#ifdef __linux__
  if(ti->linux_fb_fd >= 0){
    close(ti->linux_fb_fd);
  }
  free(ti->linux_fb_dev);
  if(ti->linux_fbuffer != MAP_FAILED){
    munmap(ti->linux_fbuffer, ti->linux_fb_len);
  }
#endif
  free(ti->tpreserved);
  loginfo("destroyed terminfo cache");
}

Here is the call graph for this function:

Here is the caller graph for this function:

grow_esc_table()

int grow_esc_table	(	tinfo *	ti,
		const char *	tstr,
		escape_e	esc,
		size_t *	tlen,
		size_t *	tused
	)

Definition at line 14 of file termdesc.c.

                                               {
  // the actual table can grow past 64KB, but we can't start there, as
  // we only have 16-bit indices.
  if(*tused >= 65535){
    fprintf(stderr, "Can't add escape %d to full table\n", esc);
    return -1;
  }
  if(get_escape(ti, esc)){
    fprintf(stderr, "Already defined escape %d (%s)\n",
            esc, get_escape(ti, esc));
    return -1;
  }
  size_t slen = strlen(tstr) + 1; // count the nul term
  if(*tlen - *tused < slen){
    // guaranteed to give us enough space to add tstr (and then some)
    size_t newsize = *tlen + 4020 + slen; // don't pull two pages ideally
    char* tmp = realloc(ti->esctable, newsize);
    if(tmp == NULL){
      return -1;
    }
    ti->esctable = tmp;
    *tlen = newsize;
  }
  // we now are guaranteed sufficient space to copy tstr
  memcpy(ti->esctable + *tused, tstr, slen);
  ti->escindices[esc] = *tused + 1; // one-bias
  *tused += slen;
  return 0;
}

Here is the caller graph for this function:

interrogate_terminfo()

int interrogate_terminfo	(	tinfo *	ti,
		FILE *	out,
		unsigned	utf8,
		unsigned	noaltscreen,
		unsigned	nocbreak,
		unsigned	nonewfonts,
		int *	cursor_y,
		int *	cursor_x,
		ncsharedstats *	stats,
		int	lmargin,
		int	tmargin,
		int	rmargin,
		int	bmargin,
		unsigned	draininput
	)

Definition at line 1294 of file termdesc.c.

                                             {
  // if a specified termtype was provided in the notcurses_options, it was
  // loaded into our environment at TERM.
  const char* termtype = getenv("TERM");
  int foolcursor_x, foolcursor_y;
  if(!cursor_x){
    cursor_x = &foolcursor_x;
  }
  if(!cursor_y){
    cursor_y = &foolcursor_y;
  }
  *cursor_x = *cursor_y = -1;
  ti->sixelengine = NULL;
  ti->bg_collides_default = 0xfe000000;
  ti->fg_default = 0xff000000;
  ti->kbdlevel = UINT_MAX; // see comment in tinfo definition
  ti->maxpaletteread = -1;
  ti->qterm = TERMINAL_UNKNOWN;
  // we don't need a controlling tty for everything we do; allow a failure here
  ti->ttyfd = get_tty_fd(out);
  ti->gpmfd = -1;
  size_t tablelen = 0;
  size_t tableused = 0;
  const char* tname = NULL;
#ifdef __APPLE__
  ti->qterm = macos_early_matches();
#elif defined(__MINGW32__)
  if(termtype){
    logwarn("termtype (%s) ignored on windows", termtype);
  }
  if(prepare_windows_terminal(ti, &tablelen, &tableused)){
    logpanic("failed opening Windows ConPTY");
    return -1;
  }
#else
  ti->qterm = unix_early_matches(termtype);
#if defined(__linux__)
  ti->linux_fb_fd = -1;
  ti->linux_fbuffer = MAP_FAILED;
  // we might or might not program quadrants into the console font
  if(is_linux_console(ti->ttyfd)){
    ti->qterm = TERMINAL_LINUX;
  }
#endif
#endif
  if(ti->ttyfd >= 0){
    if((ti->tpreserved = calloc(1, sizeof(*ti->tpreserved))) == NULL){
      return -1;
    }
    if(tcgetattr(ti->ttyfd, ti->tpreserved)){
      logpanic("couldn't preserve terminal state for %d (%s)", ti->ttyfd, strerror(errno));
      free(ti->tpreserved);
      return -1;
    }
    // enter cbreak mode regardless of user preference until we've performed
    // terminal interrogation. at that point, we might restore original mode.
    if(cbreak_mode(ti)){
      free(ti->tpreserved);
      return -1;
    }
    // if we already know our terminal (e.g. on the linux console), there's no
    // need to send the identification queries. the controls are sufficient.
    bool minimal = (ti->qterm != TERMINAL_UNKNOWN);
    if(send_initial_queries(ti, minimal, noaltscreen, draininput)){
      goto err;
    }
  }
#ifndef __MINGW32__
  // windows doesn't really have a concept of terminfo. you might ssh into other
  // machines, but they'll use the terminfo installed thereon (putty, etc.).
  int termerr;
  if(setupterm(termtype, ti->ttyfd, &termerr)){
    logpanic("terminfo error %d for [%s] (see terminfo(3ncurses))",
             termerr, termtype ? termtype : "");
    goto err;
  }
  tname = termname(); // longname() is also available
#endif
  int linesigs_enabled = 1;
  if(ti->tpreserved){
    if(!(ti->tpreserved->c_lflag & ISIG)){
      linesigs_enabled = 0;
    }
  }
  if(init_inputlayer(ti, stdin, lmargin, tmargin, rmargin, bmargin,
                     stats, draininput, linesigs_enabled)){
    goto err;
  }
  ti->sprixel_scale_height = 1;
  get_default_geometry(ti);
  ti->caps.utf8 = utf8;
  // allow the "rgb" boolean terminfo capability, a COLORTERM environment
  // variable of either "truecolor" or "24bit", or unconditionally enable it
  // for several terminals known to always support 8bpc rgb setaf/setab.
  if(ti->caps.colors == 0){
    int colors = tigetnum("colors");
    if(colors <= 0){
      ti->caps.colors = 1;
    }else{
      ti->caps.colors = colors;
    }
    ti->caps.rgb = query_rgb(); // independent of colors
  }
  if(do_terminfo_lookups(ti, &tablelen, &tableused)){
    goto err;
  }
  if(ti->ttyfd >= 0){
    // if the keypad needn't be explicitly enabled, smkx is not present
    const char* smkx = get_escape(ti, ESCAPE_SMKX);
    if(smkx){
      if(tty_emit(tiparm(smkx), ti->ttyfd) < 0){
        logpanic("error enabling keypad transmit mode");
        goto err;
      }
    }
  }
  if(tigetflag("bce") > 0){
    ti->bce = true;
  }
  if(ti->caps.colors > 1){
    const char* initc = get_escape(ti, ESCAPE_INITC);
    if(initc){
      ti->caps.can_change_colors = true;
    }
  }else{ // disable initc if there's no color support
    ti->escindices[ESCAPE_INITC] = 0;
  }
  // neither of these is supported on e.g. the "linux" virtual console.
  if(!noaltscreen){
    if(init_terminfo_esc(ti, "smcup", ESCAPE_SMCUP, &tablelen, &tableused) ||
       init_terminfo_esc(ti, "rmcup", ESCAPE_RMCUP, &tablelen, &tableused)){
      goto err;
    }
    const char* smcup = get_escape(ti, ESCAPE_SMCUP);
    if(smcup){
      ti->in_alt_screen = 1;
      // if we're not using the standard smcup, our initial hardcoded use of it
      // presumably had no effect; warn the user.
      if(strcmp(smcup, SMCUP)){
        logwarn("warning: non-standard smcup!");
      }
    }
  }else{
    ti->escindices[ESCAPE_SMCUP] = 0;
    ti->escindices[ESCAPE_RMCUP] = 0;
  }
  if(get_escape(ti, ESCAPE_CIVIS) == NULL){
    char* chts;
    if(terminfostr(&chts, "chts") == 0){
      if(grow_esc_table(ti, chts, ESCAPE_CIVIS, &tablelen, &tableused)){
        goto err;
      }
    }
  }
  if(get_escape(ti, ESCAPE_BOLD)){
    if(grow_esc_table(ti, "\e[22m", ESCAPE_NOBOLD, &tablelen, &tableused)){
      goto err;
    }
  }
  // if op is defined as ansi 39 + ansi 49, make the split definitions
  // available. this ought be asserted by extension capability "ax", but
  // no terminal i've found seems to do so. =[
  const char* op = get_escape(ti, ESCAPE_OP);
  if(op && strcmp(op, "\x1b[39;49m") == 0){
    if(grow_esc_table(ti, "\x1b[39m", ESCAPE_FGOP, &tablelen, &tableused) ||
       grow_esc_table(ti, "\x1b[49m", ESCAPE_BGOP, &tablelen, &tableused)){
      goto err;
    }
  }
  unsigned kitty_graphics = 0;
  if(ti->ttyfd >= 0){
    if(handle_responses(ti, &tablelen, &tableused, cursor_y, cursor_x,
                        draininput, &kitty_graphics)){
      goto err;
    }
    if(nocbreak){
      // FIXME do this in input later, upon signaling completion?
      if(tcsetattr(ti->ttyfd, TCSANOW, ti->tpreserved)){
        goto err;
      }
    }
  }else{
    ti->kbdlevel = 0; // confirmed no support, don't bother popping
  }
  // now look up any terminfo elements we might not have received via requests
  if(ti->escindices[ESCAPE_HPA] == 0){
    if(init_terminfo_esc(ti, "hpa", ESCAPE_HPA, &tablelen, &tableused)){
      goto err;
    }
  }
  if(*cursor_x >= 0 && *cursor_y >= 0){
    if(add_u7_escape(ti, &tablelen, &tableused)){
      goto err;
    }
  }
  bool forcesdm = false;
  bool invertsixel = false;
  if(apply_term_heuristics(ti, tname, ti->qterm, &tablelen, &tableused,
                           &forcesdm, &invertsixel, nonewfonts)){
    goto err;
  }
  build_supported_styles(ti);
  if(ti->pixel_draw == NULL && ti->pixel_draw_late == NULL){
    // color_registers was only assigned if kitty_graphics were unavailable
    if(ti->color_registers > 0){
      setup_sixel_bitmaps(ti, ti->ttyfd, forcesdm, invertsixel);
    }
    if(kitty_graphics){
      setup_kitty_bitmaps(ti, ti->ttyfd, NCPIXEL_KITTY_STATIC);
    }
  }
  return 0;
 
err:
  if(ti->ttyfd >= 0){
    // if we haven't yet received a reply confirming lack of kitty keyboard
    // support, it'll be UINT_MAX, and we ought try to pop (in case we died
    // following the keyboard set, but before confirming support).
    if(ti->kbdlevel){
      tty_emit(KKEYBOARD_POP, ti->ttyfd);
    }
    tty_emit(RMCUP, ti->ttyfd);
  }
  if(ti->tpreserved){
    (void)tcsetattr(ti->ttyfd, TCSANOW, ti->tpreserved);
    free(ti->tpreserved);
    ti->tpreserved = NULL;
  }
  stop_inputlayer(ti);
  free(ti->esctable);
  free(ti->termversion);
  del_curterm(cur_term);
  close(ti->ttyfd);
  ti->ttyfd = -1;
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

leave_alternate_screen()

int leave_alternate_screen	(	int	fd,
		FILE *	fp,
		tinfo *	ti,
		unsigned	drain
	)

Definition at line 611 of file termdesc.c.

                                                                       {
  if(!ti->in_alt_screen){
    return 0;
  }
  const char* rmcup = get_escape(ti, ESCAPE_RMCUP);
  if(rmcup == NULL){
    logerror("can't leave alternate screen");
    return -1;
  }
  if(!drain){
    if(ti->kbdlevel){
      if(tty_emit(KKEYBOARD_POP, fd)){
        return -1;
      }
    }else{
      if(tty_emit(XTMODKEYSUNDO, fd)){
        return -1;
      }
    }
  }
  const char* popcolors = get_escape(ti, ESCAPE_RESTORECOLORS);
  if(popcolors){
    if(term_emit(popcolors, fp, true)){
      return -1;
    }
  }
  if(tty_emit(rmcup, fd)){
    return -1;
  }
  if(!drain){
    if(ti->kbdlevel){
      if(tty_emit(KKBDENTER, fd)){
        return -1;
      }
    }else{
      if(tty_emit(XTMODKEYS, fd)){
        return -1;
      }
    }
  }
  const char* pushcolors = get_escape(ti, ESCAPE_SAVECOLORS);
  if(pushcolors){
    if(term_emit(popcolors, fp, true)){
      return -1;
    }
  }
  ti->in_alt_screen = false;
  return 0;
}

Here is the caller graph for this function:

locate_cursor()

int locate_cursor	(	tinfo *	ti,
		unsigned *	cursor_y,
		unsigned *	cursor_x
	)

Definition at line 1558 of file termdesc.c.

                                                                    {
  const char* u7 = get_escape(ti, ESCAPE_U7);
  if(u7 == NULL){
    logwarn("no support in terminfo");
    return -1;
  }
  if(ti->ttyfd < 0){
    logwarn("no valid path for cursor report");
    return -1;
  }
  int fd = ti->ttyfd;
  if(get_cursor_location(ti->ictx, u7, cursor_y, cursor_x)){
    return -1;
  }
  loginfo("got a report from %d %d/%d", fd, *cursor_y, *cursor_x);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

putenv_term()

int putenv_term

(

const char *

tname

)

Definition at line 1632 of file termdesc.c.

                                  {
  #define ENVVAR "TERM"
  const char* oldterm = getenv(ENVVAR);
  if(oldterm){
    logdebug("replacing %s value %s with %s", ENVVAR, oldterm, tname);
  }else{
    loginfo("provided %s value %s", ENVVAR, tname);
  }
  if(oldterm && strcmp(oldterm, tname) == 0){
    return 0;
  }
  char* buf = malloc(strlen(tname) + strlen(ENVVAR) + 1);
  if(buf == NULL){
    return -1;
  }
  int c = putenv(buf);
  if(c){
    logerror("couldn't export %s", buf);
  }
  free(buf);
  return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

termdesc_longterm()

char * termdesc_longterm

(

const tinfo *

ti

)

Definition at line 1535 of file termdesc.c.

                                        {
  size_t tlen = strlen(ti->termname) + 1;
  size_t slen = tlen;
  if(ti->termversion){
    slen += strlen(ti->termversion) + 1;
  }
  char* ret = malloc(slen);
  if(ret){
    memcpy(ret, ti->termname, tlen);
    if(ti->termversion){
      ret[tlen - 1] = ' ';
      strcpy(ret + tlen, ti->termversion);
    }
  }
  return ret;
}

Here is the caller graph for this function:

tiocgwinsz()

int tiocgwinsz	(	int	fd,
		struct winsize *	ws
	)

Definition at line 1576 of file termdesc.c.

                                          {
#ifndef __MINGW32__
  int i = ioctl(fd, TIOCGWINSZ, ws);
  if(i < 0){
    logerror("TIOCGWINSZ failed on %d (%s)", fd, strerror(errno));
    return -1;
  }
  if(ws->ws_row <= 0 || ws->ws_col <= 0){
    logerror("bogon from TIOCGWINSZ on %d (%d/%d)",
             fd, ws->ws_row, ws->ws_col);
    return -1;
  }
#else
  (void)fd;
  (void)ws;
#endif
  return 0;
}

Here is the caller graph for this function: